Satisfy the -D rust-2018-idioms compiler flag (facebookexperimental#92)

Author: Herman Venter

src/abstract_domains.rs

@@ -32,7 +32,7 @@ pub struct AbstractDomain {
 }
 
 impl Debug for AbstractDomain {
-    fn fmt(&self, f: &mut Formatter) -> Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
         self.expression.fmt(f)
     }
 }
@@ -75,7 +75,7 @@ pub const TRUE: AbstractDomain = AbstractDomain {
 };
 
 impl<'a> From<&TyKind<'a>> for ExpressionType {
-    fn from(ty_kind: &TyKind) -> ExpressionType {
+    fn from(ty_kind: &TyKind<'a>) -> ExpressionType {
         match ty_kind {
             TyKind::Bool => ExpressionType::Bool,
             TyKind::Char => ExpressionType::Char,

src/abstract_value.rs

@@ -62,7 +62,7 @@ pub const TRUE: AbstractValue = AbstractValue {
 };
 
 impl Debug for AbstractValue {
-    fn fmt(&self, f: &mut Formatter) -> Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
         self.domain.fmt(f)
     }
 }

src/callbacks.rs

@@ -26,13 +26,13 @@ use syntax::{ast, errors};
 pub struct MiraiCallbacks {
     /// Called after static analysis is complete.
     /// Gives test harness a way to process intercepted diagnostics.
-    consume_buffered_diagnostics: Box<Fn(&Vec<Diagnostic>) -> ()>,
+    consume_buffered_diagnostics: Box<dyn Fn(&Vec<Diagnostic>) -> ()>,
     /// Use these to just defer to the Rust compiler's implementations.
     default_calls: Box<RustcDefaultCalls>,
     /// Called when static analysis reports a diagnostic message.
     /// By default, this just emits the message. When overridden it can
     /// intercept and buffer the diagnostics, which is used by the test harness.
-    emit_diagnostic: fn(&mut DiagnosticBuilder, &mut Vec<Diagnostic>) -> (),
+    emit_diagnostic: fn(&mut DiagnosticBuilder<'_>, &mut Vec<Diagnostic>) -> (),
     /// A path to the directory where analysis output, such as the summary cache, should be stored.
     output_directory: PathBuf,
     /// True if this run is done via cargo test
@@ -45,15 +45,15 @@ impl MiraiCallbacks {
         MiraiCallbacks {
             consume_buffered_diagnostics: box |_bd: &Vec<Diagnostic>| {},
             default_calls: box RustcDefaultCalls,
-            emit_diagnostic: |db: &mut DiagnosticBuilder, _buf: &mut Vec<Diagnostic>| db.emit(),
+            emit_diagnostic: |db: &mut DiagnosticBuilder<'_>, _buf: &mut Vec<Diagnostic>| db.emit(),
             output_directory: PathBuf::default(),
             test_run: false,
         }
     }
 
     pub fn with_buffered_diagnostics(
-        consume_buffered_diagnostics: Box<Fn(&Vec<Diagnostic>) -> ()>,
-        emit_diagnostic: fn(&mut DiagnosticBuilder, &mut Vec<Diagnostic>) -> (),
+        consume_buffered_diagnostics: Box<dyn Fn(&Vec<Diagnostic>) -> ()>,
+        emit_diagnostic: fn(&mut DiagnosticBuilder<'_>, &mut Vec<Diagnostic>) -> (),
     ) -> MiraiCallbacks {
         MiraiCallbacks {
             consume_buffered_diagnostics,
@@ -97,7 +97,7 @@ impl<'a> CompilerCalls<'a> for MiraiCallbacks {
     /// is called), after all arguments etc. have been completely handled.
     fn late_callback(
         &mut self,
-        codegen_backend: &CodegenBackend,
+        codegen_backend: &dyn CodegenBackend,
         matches: &::getopts::Matches,
         session: &Session,
         crate_store: &CStore,
@@ -159,9 +159,9 @@ impl<'a> CompilerCalls<'a> for MiraiCallbacks {
 /// At this point the compiler is ready to tell us all it knows and we can proceed to do abstract
 /// interpretation of all of the functions that will end up in the compiler output.
 fn after_analysis(
-    state: &mut driver::CompileState,
-    consume_buffered_diagnostics: &Box<Fn(&Vec<Diagnostic>) -> ()>,
-    emit_diagnostic: fn(&mut DiagnosticBuilder, &mut Vec<Diagnostic>) -> (),
+    state: &mut driver::CompileState<'_, '_>,
+    consume_buffered_diagnostics: &Box<dyn Fn(&Vec<Diagnostic>) -> ()>,
+    emit_diagnostic: fn(&mut DiagnosticBuilder<'_>, &mut Vec<Diagnostic>) -> (),
     output_directory: &mut PathBuf,
 ) {
     let session = state.session;

src/constant_domain.rs

@@ -57,8 +57,8 @@ impl ConstantDomain {
     /// Returns a constant value that is a reference to a function
     pub fn for_function(
         def_id: DefId,
-        tcx: &TyCtxt,
-        summary_cache: &mut PersistentSummaryCache,
+        tcx: &TyCtxt<'_, '_, '_>,
+        summary_cache: &mut PersistentSummaryCache<'_, '_>,
     ) -> ConstantDomain {
         let summary_cache_key = summary_cache.get_summary_key_for(def_id);
         ConstantDomain::Function {
@@ -633,8 +633,8 @@ impl ConstantValueCache {
     pub fn get_function_constant_for(
         &mut self,
         def_id: DefId,
-        tcx: &TyCtxt,
-        summary_cache: &mut PersistentSummaryCache,
+        tcx: &TyCtxt<'_, '_, '_>,
+        summary_cache: &mut PersistentSummaryCache<'_, '_>,
     ) -> &ConstantDomain {
         self.function_cache
             .entry(def_id)

src/environment.rs

@@ -34,7 +34,7 @@ impl Environment {
 }
 
 impl Debug for Environment {
-    fn fmt(&self, f: &mut Formatter) -> Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
         self.value_map.fmt(f)
     }
 }

src/lib.rs

@@ -19,22 +19,16 @@
 extern crate getopts;
 extern crate rustc;
 extern crate rustc_codegen_utils;
-extern crate rustc_data_structures;
 extern crate rustc_driver;
 extern crate rustc_metadata;
 extern crate rustc_target;
 extern crate syntax;
 extern crate syntax_pos;
 
-extern crate bincode;
 #[macro_use]
 extern crate log;
-//#[macro_use]
-extern crate rpds;
-extern crate sled;
 #[macro_use]
 extern crate serde_derive;
-extern crate serde;
 
 pub mod abstract_domains;
 pub mod abstract_value;

src/utils.rs

@@ -32,7 +32,7 @@ pub fn find_sysroot() -> String {
 
 /// Returns true if the function identified by def_id is a Rust intrinsic function.
 /// Warning: it is not clear what will happen if def_id does not identify a function.
-pub fn is_rust_intrinsic(def_id: DefId, tcx: &TyCtxt) -> bool {
+pub fn is_rust_intrinsic(def_id: DefId, tcx: &TyCtxt<'_, '_, '_>) -> bool {
     let binder = tcx.fn_sig(def_id);
     let sig = binder.skip_binder();
     match sig.abi {
@@ -42,7 +42,7 @@ pub fn is_rust_intrinsic(def_id: DefId, tcx: &TyCtxt) -> bool {
 }
 
 /// Returns true if the function identified by def_id is a public function.
-pub fn is_public(def_id: DefId, tcx: &TyCtxt) -> bool {
+pub fn is_public(def_id: DefId, tcx: &TyCtxt<'_, '_, '_>) -> bool {
     if let Some(node) = tcx.hir().get_if_local(def_id) {
         match node {
             Node::Item(item) => {
@@ -73,7 +73,7 @@ pub fn is_public(def_id: DefId, tcx: &TyCtxt) -> bool {
 /// the summary cache, which is a key value store. The string will always be the same as
 /// long as the definition does not change its name or location, so it can be used to
 /// transfer information from one compilation to the next, making incremental analysis possible.
-pub fn summary_key_str(tcx: &TyCtxt, def_id: DefId) -> String {
+pub fn summary_key_str(tcx: &TyCtxt<'_, '_, '_>, def_id: DefId) -> String {
     let crate_name = if def_id.is_local() {
         tcx.crate_name.as_interned_str().as_str().get()
     } else {

src/visitors.rs

@@ -29,27 +29,27 @@ pub struct MirVisitorCrateContext<'a, 'b: 'a, 'tcx: 'b, E> {
     pub buffered_diagnostics: &'a mut Vec<Diagnostic>,
     /// A call back that the test harness can use to buffer the diagnostic message.
     /// By default this just calls emit on the diagnostic.
-    pub emit_diagnostic: fn(&mut DiagnosticBuilder, buf: &mut Vec<Diagnostic>) -> (),
+    pub emit_diagnostic: fn(&mut DiagnosticBuilder<'_>, buf: &mut Vec<Diagnostic>) -> (),
     pub session: &'tcx Session,
     pub tcx: TyCtxt<'b, 'tcx, 'tcx>,
     pub def_id: hir::def_id::DefId,
     pub mir: &'a mir::Mir<'tcx>,
     pub constant_value_cache: &'a mut ConstantValueCache,
     pub summary_cache: &'a mut PersistentSummaryCache<'b, 'tcx>,
-    pub smt_solver: &'a mut SmtSolver<E>,
+    pub smt_solver: &'a mut dyn SmtSolver<E>,
 }
 
 /// Holds the state for the MIR test visitor.
 pub struct MirVisitor<'a, 'b: 'a, 'tcx: 'b, E> {
     buffered_diagnostics: &'a mut Vec<Diagnostic>,
-    emit_diagnostic: fn(&mut DiagnosticBuilder, buf: &mut Vec<Diagnostic>) -> (),
+    emit_diagnostic: fn(&mut DiagnosticBuilder<'_>, buf: &mut Vec<Diagnostic>) -> (),
     session: &'tcx Session,
     tcx: TyCtxt<'b, 'tcx, 'tcx>,
     def_id: hir::def_id::DefId,
     mir: &'a mir::Mir<'tcx>,
     constant_value_cache: &'a mut ConstantValueCache,
     summary_cache: &'a mut PersistentSummaryCache<'b, 'tcx>,
-    smt_solver: &'a mut SmtSolver<E>,
+    smt_solver: &'a mut dyn SmtSolver<E>,
 
     check_for_errors: bool,
     current_environment: Environment,
@@ -446,7 +446,7 @@ impl<'a, 'b: 'a, 'tcx: 'b, E> MirVisitor<'a, 'b, 'tcx, E> {
         &mut self,
         asm: &hir::InlineAsm,
         outputs: &[mir::Place<'tcx>],
-        inputs: &[(syntax_pos::Span, mir::Operand)],
+        inputs: &[(syntax_pos::Span, mir::Operand<'tcx>)],
     ) {
         debug!(
             "default visit_inline_asm(asm: {:?}, outputs: {:?}, inputs: {:?})",
@@ -544,7 +544,7 @@ impl<'a, 'b: 'a, 'tcx: 'b, E> MirVisitor<'a, 'b, 'tcx, E> {
     fn visit_switch_int(
         &mut self,
         discr: &mir::Operand<'tcx>,
-        switch_ty: rustc::ty::Ty,
+        switch_ty: rustc::ty::Ty<'tcx>,
         values: &[u128],
         targets: &[mir::BasicBlock],
     ) {
@@ -937,7 +937,7 @@ impl<'a, 'b: 'a, 'tcx: 'b, E> MirVisitor<'a, 'b, 'tcx, E> {
         &mut self,
         cond: &mir::Operand<'tcx>,
         expected: bool,
-        msg: &mir::AssertMessage,
+        msg: &mir::AssertMessage<'tcx>,
         target: mir::BasicBlock,
         cleanup: Option<mir::BasicBlock>,
     ) {
@@ -1334,7 +1334,7 @@ impl<'a, 'b: 'a, 'tcx: 'b, E> MirVisitor<'a, 'b, 'tcx, E> {
     fn visit_ref(
         &mut self,
         path: Path,
-        region: rustc::ty::Region,
+        region: rustc::ty::Region<'tcx>,
         borrow_kind: mir::BorrowKind,
         place: &mir::Place<'tcx>,
     ) {
@@ -1379,7 +1379,7 @@ impl<'a, 'b: 'a, 'tcx: 'b, E> MirVisitor<'a, 'b, 'tcx, E> {
         path: Path,
         cast_kind: mir::CastKind,
         operand: &mir::Operand<'tcx>,
-        ty: rustc::ty::Ty,
+        ty: rustc::ty::Ty<'tcx>,
     ) {
         debug!(
             "default visit_cast(path: {:?}, cast_kind: {:?}, operand: {:?}, ty: {:?})",
@@ -1481,7 +1481,7 @@ impl<'a, 'b: 'a, 'tcx: 'b, E> MirVisitor<'a, 'b, 'tcx, E> {
     }
 
     /// Create a value based on the given type and assign it to path.
-    fn visit_nullary_op(&mut self, path: Path, null_op: mir::NullOp, ty: rustc::ty::Ty) {
+    fn visit_nullary_op(&mut self, path: Path, null_op: mir::NullOp, ty: rustc::ty::Ty<'tcx>) {
         debug!(
             "default visit_nullary_op(path: {:?}, null_op: {:?}, ty: {:?})",
             path, null_op, ty
@@ -1542,7 +1542,7 @@ impl<'a, 'b: 'a, 'tcx: 'b, E> MirVisitor<'a, 'b, 'tcx, E> {
     fn visit_aggregate(
         &mut self,
         path: Path,
-        aggregate_kinds: &mir::AggregateKind,
+        aggregate_kinds: &mir::AggregateKind<'tcx>,
         operands: &[mir::Operand<'tcx>],
     ) {
         debug!(
@@ -1659,9 +1659,9 @@ impl<'a, 'b: 'a, 'tcx: 'b, E> MirVisitor<'a, 'b, 'tcx, E> {
     /// Synthesizes a constant value.
     fn visit_constant(
         &mut self,
-        ty: Ty,
+        ty: Ty<'tcx>,
         user_ty: Option<UserTypeAnnotationIndex>,
-        literal: &LazyConst,
+        literal: &LazyConst<'tcx>,
     ) -> AbstractValue {
         use rustc::mir::interpret::{AllocKind, ConstValue, Scalar};
         debug!(
@@ -2103,7 +2103,7 @@ impl<'a, 'b: 'a, 'tcx: 'b, E> MirVisitor<'a, 'b, 'tcx, E> {
     /// but which can be serialized.
     fn visit_projection_elem(
         &mut self,
-        projection_elem: &mir::ProjectionElem<mir::Local, &rustc::ty::TyS>,
+        projection_elem: &mir::ProjectionElem<'tcx, mir::Local, &rustc::ty::TyS<'tcx>>,
     ) -> PathSelector {
         debug!(
             "visit_projection_elem(projection_elem: {:?})",
@@ -2143,7 +2143,7 @@ impl<'a, 'b: 'a, 'tcx: 'b, E> MirVisitor<'a, 'b, 'tcx, E> {
     }
 
     /// Returns the rustc TyKind of the given place in memory.
-    fn get_rustc_place_type(&self, place: &mir::Place<'tcx>) -> &TyKind<'a> {
+    fn get_rustc_place_type(&self, place: &mir::Place<'tcx>) -> &TyKind<'tcx> {
         match place {
             mir::Place::Base(base_place) => match base_place {
                 mir::PlaceBase::Local(local) => {
@@ -2160,7 +2160,7 @@ impl<'a, 'b: 'a, 'tcx: 'b, E> MirVisitor<'a, 'b, 'tcx, E> {
     }
 
     /// Returns the rustc TyKind of the element selected by projection_elem.
-    fn get_type_for_projection_element(&self, place: &mir::Place<'tcx>) -> &TyKind<'a> {
+    fn get_type_for_projection_element(&self, place: &mir::Place<'tcx>) -> &TyKind<'tcx> {
         if let mir::Place::Projection(boxed_place_projection) = place {
             let base_ty = self.get_rustc_place_type(&boxed_place_projection.base);
             match boxed_place_projection.elem {

tests/validate.sh

@@ -9,7 +9,8 @@ cargo fmt --all
 # Run lint checks
 cargo clippy -- -D warnings
 # Build
-time cargo build
+cargo rustc --lib -- -D rust-2018-idioms
+cargo build
 # Run mirai on itself
 cargo uninstall mirai || true
 cargo install --debug --path .