Update rustc version incrementally to nightly-2022-12-06

analysis/runtime/src/events.rs

@@ -89,31 +89,31 @@ impl Debug for EventKind {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         use EventKind::*;
         match *self {
-            CopyPtr(ptr) => write!(f, "copy(0x{:x})", ptr),
-            Field(ptr, id) => write!(f, "field(0x{:x}, {})", ptr, id),
+            CopyPtr(ptr) => write!(f, "copy(0x{ptr:x})"),
+            Field(ptr, id) => write!(f, "field(0x{ptr:x}, {id})"),
             Alloc { size, ptr } => {
-                write!(f, "malloc({}) -> 0x{:x}", size, ptr)
+                write!(f, "malloc({size}) -> 0x{ptr:x}")
             }
-            Free { ptr } => write!(f, "free(0x{:x})", ptr),
+            Free { ptr } => write!(f, "free(0x{ptr:x})"),
             Realloc {
                 old_ptr,
                 size,
                 new_ptr,
-            } => write!(f, "realloc(0x{:x}, {}) -> 0x{:x}", old_ptr, size, new_ptr),
-            Ret(ptr) => write!(f, "ret(0x{:x})", ptr),
+            } => write!(f, "realloc(0x{old_ptr:x}, {size}) -> 0x{new_ptr:x}"),
+            Ret(ptr) => write!(f, "ret(0x{ptr:x})"),
             Done => write!(f, "done"),
             BeginFuncBody => write!(f, "begin func body"),
-            LoadAddr(ptr) => write!(f, "load(0x{:x})", ptr),
-            StoreAddr(ptr) => write!(f, "store(0x{:x})", ptr),
-            StoreAddrTaken(ptr) => write!(f, "store(0x{:x})", ptr),
+            LoadAddr(ptr) => write!(f, "load(0x{ptr:x})"),
+            StoreAddr(ptr) => write!(f, "store(0x{ptr:x})"),
+            StoreAddrTaken(ptr) => write!(f, "store(0x{ptr:x})"),
             CopyRef => write!(f, "copy_ref"),
-            AddrOfLocal(ptr, _) => write!(f, "addr_of_local = 0x{:x}", ptr),
-            ToInt(ptr) => write!(f, "to_int(0x{:x})", ptr),
-            FromInt(ptr) => write!(f, "from_int(0x{:x})", ptr),
-            LoadValue(ptr) => write!(f, "load_value(0x{:x})", ptr),
-            StoreValue(ptr) => write!(f, "store_value(0x{:x})", ptr),
+            AddrOfLocal(ptr, _) => write!(f, "addr_of_local = 0x{ptr:x}"),
+            ToInt(ptr) => write!(f, "to_int(0x{ptr:x})"),
+            FromInt(ptr) => write!(f, "from_int(0x{ptr:x})"),
+            LoadValue(ptr) => write!(f, "load_value(0x{ptr:x})"),
+            StoreValue(ptr) => write!(f, "store_value(0x{ptr:x})"),
             Offset(ptr, offset, new_ptr) => {
-                write!(f, "offset(0x{:x}, {:?}, 0x{:x})", ptr, offset, new_ptr)
+                write!(f, "offset(0x{ptr:x}, {offset:?}, 0x{new_ptr:x})")
             }
         }
     }

analysis/runtime/src/handlers.rs

@@ -115,21 +115,21 @@ pub fn ptr_field(mir_loc: MirLocId, ptr: usize, field_id: u32) {
 pub fn ptr_copy(mir_loc: MirLocId, ptr: usize) {
     RUNTIME.send_event(Event {
         mir_loc,
-        kind: EventKind::CopyPtr(ptr as usize),
+        kind: EventKind::CopyPtr(ptr),
     });
 }
 
 pub fn ptr_contrive(mir_loc: MirLocId, ptr: usize) {
     RUNTIME.send_event(Event {
         mir_loc,
-        kind: EventKind::FromInt(ptr as usize),
+        kind: EventKind::FromInt(ptr),
     });
 }
 
 pub fn ptr_to_int(mir_loc: MirLocId, ptr: usize) {
     RUNTIME.send_event(Event {
         mir_loc,
-        kind: EventKind::ToInt(ptr as usize),
+        kind: EventKind::ToInt(ptr),
     });
 }
 

analysis/runtime/src/mir_loc.rs

@@ -81,15 +81,15 @@ impl Display for MirPlace {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         write!(f, "{:?}", self.local)?;
         for p in &self.projection {
-            write!(f, ".{}", p)?;
+            write!(f, ".{p}")?;
         }
         Ok(())
     }
 }
 
 impl Debug for MirPlace {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "{}", self)
+        write!(f, "{self}")
     }
 }
 

analysis/runtime/src/runtime/backend.rs

@@ -120,7 +120,7 @@ impl Detect for LogBackend {
             .write(true)
             .append(append)
             .truncate(!append)
-            .open(&path)?;
+            .open(path)?;
         let writer = BufWriter::new(file);
         Ok(Self { writer })
     }

c2rust-analyze/src/borrowck/def_use.rs

@@ -157,7 +157,7 @@ impl<'tcx> Visitor<'tcx> for DefUseVisitor<'tcx, '_> {
 
     fn visit_statement(&mut self, stmt: &Statement<'tcx>, location: Location) {
         self.super_statement(stmt, location);
-        eprintln!("visit stmt {:?} at {:?}", stmt, location);
+        eprintln!("visit stmt {stmt:?} at {location:?}");
 
         if let StatementKind::StorageDead(local) = stmt.kind {
             // Observed: `StorageDead` emits `path_moved_at_base` at the `Mid` point.

c2rust-analyze/src/borrowck/dump.rs

@@ -205,7 +205,7 @@ impl<K: Render + Ord, V: Render> OutputTable for FxHashMap<K, V> {
 
 impl OutputTable for bool {
     fn write(&self, out: &mut dyn Write, _maps: &AtomMaps) -> Result<(), Box<dyn Error>> {
-        writeln!(out, "{}", self)?;
+        writeln!(out, "{self}")?;
         Ok(())
     }
 }
@@ -332,7 +332,7 @@ impl Render for Loan {
 impl Render for Point {
     fn to_string(&self, maps: &AtomMaps) -> String {
         let (bb, idx, sub) = maps.get_point(*self);
-        format!("{:?}({:?}[{}])", sub, bb, idx)
+        format!("{sub:?}({bb:?}[{idx}])")
     }
 }
 

c2rust-analyze/src/borrowck/mod.rs

@@ -82,7 +82,7 @@ pub enum OriginArg<'tcx> {
 impl<'tcx> Debug for OriginArg<'tcx> {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
         match &self {
-            OriginArg::Actual(r) => write!(f, "{:}", r),
+            OriginArg::Actual(r) => write!(f, "{r:}"),
             OriginArg::Hypothetical(h) => write!(f, "'h{h:?}"),
         }
     }
@@ -150,27 +150,24 @@ pub fn borrowck_mir<'tcx>(
                     .iter()
                     .find(|&&(_, l, _)| l == loan)
                     .map(|&(_, _, point)| point)
-                    .unwrap_or_else(|| panic!("loan {:?} was never issued?", loan));
+                    .unwrap_or_else(|| panic!("loan {loan:?} was never issued?"));
                 let issued_loc = maps.get_point_location(issued_point);
                 let stmt = mir.stmt_at(issued_loc).left().unwrap_or_else(|| {
-                    panic!(
-                        "loan {:?} was issued by a terminator (at {:?})?",
-                        loan, issued_loc
-                    );
+                    panic!("loan {loan:?} was issued by a terminator (at {issued_loc:?})?");
                 });
                 let ptr = match stmt.kind {
                     StatementKind::Assign(ref x) => match describe_rvalue(&x.1) {
                         Some(RvalueDesc::Project { base, proj: _ }) => acx
                             .ptr_of(base)
-                            .unwrap_or_else(|| panic!("missing pointer ID for {:?}", base)),
+                            .unwrap_or_else(|| panic!("missing pointer ID for {base:?}")),
                         Some(RvalueDesc::AddrOfLocal { local, proj: _ }) => {
                             acx.addr_of_local[local]
                         }
                         None => panic!("loan {:?} was issued by unknown rvalue {:?}?", loan, x.1),
                     },
-                    _ => panic!("loan {:?} was issued by non-assign stmt {:?}?", loan, stmt),
+                    _ => panic!("loan {loan:?} was issued by non-assign stmt {stmt:?}?"),
                 };
-                eprintln!("want to drop UNIQUE from pointer {:?}", ptr);
+                eprintln!("want to drop UNIQUE from pointer {ptr:?}");
 
                 if hypothesis[ptr].contains(PermissionSet::UNIQUE) {
                     hypothesis[ptr].remove(PermissionSet::UNIQUE);
@@ -216,8 +213,8 @@ fn run_polonius<'tcx>(
     //pretty::write_mir_fn(tcx, mir, &mut |_, _| Ok(()), &mut std::io::stdout()).unwrap();
 
     // Populate `cfg_edge`
-    for (bb, bb_data) in mir.basic_blocks().iter_enumerated() {
-        eprintln!("{:?}:", bb);
+    for (bb, bb_data) in mir.basic_blocks.iter_enumerated() {
+        eprintln!("{bb:?}:");
 
         for idx in 0..bb_data.statements.len() {
             eprintln!("  {}: {:?}", idx, bb_data.statements[idx]);
@@ -319,10 +316,10 @@ fn run_polonius<'tcx>(
     // Populate `var_defined/used/dropped_at` and `path_assigned/accessed_at_base`.
     def_use::visit(&mut facts, &mut maps, mir);
 
-    dump::dump_facts_to_dir(&facts, &maps, format!("inspect/{}", name)).unwrap();
+    dump::dump_facts_to_dir(&facts, &maps, format!("inspect/{name}")).unwrap();
 
     let output = polonius_engine::Output::compute(&facts, polonius_engine::Algorithm::Naive, true);
-    dump::dump_output_to_dir(&output, &maps, format!("inspect/{}", name)).unwrap();
+    dump::dump_output_to_dir(&output, &maps, format!("inspect/{name}")).unwrap();
 
     (facts, maps, output)
 }

c2rust-analyze/src/borrowck/type_check.rs

@@ -155,7 +155,7 @@ impl<'tcx> TypeChecker<'tcx, '_> {
         for proj in pl.projection {
             lty = util::lty_project(lty, &proj, &mut adt_func);
         }
-        eprintln!("final label for {pl:?}: {:?}", lty);
+        eprintln!("final label for {pl:?}: {lty:?}");
         lty
     }
 
@@ -182,7 +182,7 @@ impl<'tcx> TypeChecker<'tcx, '_> {
             .push((path, loan, borrow_kind));
         let point = self.current_point(SubPoint::Mid);
         self.facts.loan_issued_at.push((origin, loan, point));
-        eprintln!("issued loan {:?} = {:?} ({:?})", loan, pl, borrow_kind);
+        eprintln!("issued loan {loan:?} = {pl:?} ({borrow_kind:?})");
         origin
     }
 
@@ -289,7 +289,7 @@ impl<'tcx> TypeChecker<'tcx, '_> {
                     // relations between the regions of the array and the regions of its elements
                     self.ltcx.label(ty, &mut |_ty| Label::default())
                 }
-                _ => panic!("unsupported rvalue AggregateKind {:?}", kind),
+                _ => panic!("unsupported rvalue AggregateKind {kind:?}"),
             },
 
             Rvalue::Len(..) => {
@@ -299,12 +299,12 @@ impl<'tcx> TypeChecker<'tcx, '_> {
 
             Rvalue::UnaryOp(_, ref op) => self.visit_operand(op),
 
-            ref rv => panic!("unsupported rvalue {:?}", rv),
+            ref rv => panic!("unsupported rvalue {rv:?}"),
         }
     }
 
     fn do_assign(&mut self, pl_lty: LTy<'tcx>, rv_lty: LTy<'tcx>) {
-        eprintln!("assign {:?} = {:?}", pl_lty, rv_lty);
+        eprintln!("assign {pl_lty:?} = {rv_lty:?}");
 
         let mut add_subset_base = |pl: Origin, rv: Origin| {
             let point = self.current_point(SubPoint::Mid);
@@ -433,7 +433,7 @@ pub fn visit_body<'tcx>(
         adt_metadata,
     };
 
-    for (bb, bb_data) in mir.basic_blocks().iter_enumerated() {
+    for (bb, bb_data) in mir.basic_blocks.iter_enumerated() {
         for (idx, stmt) in bb_data.statements.iter().enumerate() {
             tc.current_location = Location {
                 block: bb,

c2rust-analyze/src/context.rs

@@ -261,10 +261,7 @@ impl<'a, 'tcx> AnalysisCtxt<'a, 'tcx> {
                 let (pointee_lty, proj, ptr) = match desc {
                     RvalueDesc::Project { base, proj } => {
                         let base_lty = self.type_of(base);
-                        eprintln!(
-                            "rvalue = {:?}, desc = {:?}, base_lty = {:?}",
-                            rv, desc, base_lty
-                        );
+                        eprintln!("rvalue = {rv:?}, desc = {desc:?}, base_lty = {base_lty:?}");
                         (
                             self.project(base_lty, &PlaceElem::Deref),
                             proj,
@@ -502,8 +499,7 @@ fn label_no_pointers<'tcx>(acx: &AnalysisCtxt<'_, 'tcx>, ty: Ty<'tcx>) -> LTy<'t
     acx.lcx().label(ty, &mut |inner_ty| {
         assert!(
             !matches!(inner_ty.kind(), TyKind::Ref(..) | TyKind::RawPtr(..)),
-            "unexpected pointer type in {:?}",
-            ty,
+            "unexpected pointer type in {ty:?}",
         );
         PointerId::NONE
     })

c2rust-analyze/src/dataflow/mod.rs

@@ -40,11 +40,11 @@ impl DataflowConstraints {
         eprintln!("=== propagating ===");
         eprintln!("constraints:");
         for c in &self.constraints {
-            eprintln!("  {:?}", c);
+            eprintln!("  {c:?}");
         }
         eprintln!("hypothesis:");
         for (id, p) in hypothesis.iter() {
-            eprintln!("  {}: {:?}", id, p);
+            eprintln!("  {id}: {p:?}");
         }
 
         struct PropagatePerms;

c2rust-analyze/src/dataflow/type_check.rs

@@ -50,7 +50,7 @@ impl<'tcx> TypeChecker<'tcx, '_> {
     }
 
     fn record_access(&mut self, ptr: PointerId, mutbl: Mutability) {
-        eprintln!("record_access({:?}, {:?})", ptr, mutbl);
+        eprintln!("record_access({ptr:?}, {mutbl:?})");
         if ptr == PointerId::NONE {
             return;
         }
@@ -155,7 +155,7 @@ impl<'tcx> TypeChecker<'tcx, '_> {
                 }
             }
 
-            _ => panic!("TODO: handle assignment of {:?}", rv),
+            _ => panic!("TODO: handle assignment of {rv:?}"),
         }
     }
 
@@ -211,7 +211,7 @@ impl<'tcx> TypeChecker<'tcx, '_> {
             self.acx.tcx().erase_regions(lty2.ty)
         );
         for (sub_lty1, sub_lty2) in lty1.iter().zip(lty2.iter()) {
-            eprintln!("equate {:?} = {:?}", sub_lty1, sub_lty2);
+            eprintln!("equate {sub_lty1:?} = {sub_lty2:?}");
             if sub_lty1.label != PointerId::NONE || sub_lty2.label != PointerId::NONE {
                 assert!(sub_lty1.label != PointerId::NONE);
                 assert!(sub_lty2.label != PointerId::NONE);
@@ -221,7 +221,7 @@ impl<'tcx> TypeChecker<'tcx, '_> {
     }
 
     pub fn visit_statement(&mut self, stmt: &Statement<'tcx>, loc: Location) {
-        eprintln!("visit_statement({:?})", stmt);
+        eprintln!("visit_statement({stmt:?})");
         // TODO(spernsteiner): other `StatementKind`s will be handled in the future
         #[allow(clippy::single_match)]
         match stmt.kind {
@@ -383,7 +383,7 @@ pub fn visit<'tcx>(
         equiv_constraints: Vec::new(),
     };
 
-    for (bb, bb_data) in mir.basic_blocks().iter_enumerated() {
+    for (bb, bb_data) in mir.basic_blocks.iter_enumerated() {
         for (i, stmt) in bb_data.statements.iter().enumerate() {
             tc.visit_statement(
                 stmt,

c2rust-analyze/src/expr_rewrite.rs

@@ -140,7 +140,7 @@ impl<'a, 'tcx> ExprRewriteVisitor<'a, 'tcx> {
             StatementKind::Retag(..) => {}
             StatementKind::AscribeUserType(..) => {}
             StatementKind::Coverage(..) => {}
-            StatementKind::CopyNonOverlapping(..) => todo!("statement {:?}", stmt),
+            StatementKind::Intrinsic(..) => todo!("statement {:?}", stmt),
             StatementKind::Nop => {}
         }
     }
@@ -402,7 +402,7 @@ pub fn gen_expr_rewrites<'tcx>(
 
     let mut v = ExprRewriteVisitor::new(acx, asn, &mut out, mir);
 
-    for (bb_id, bb) in mir.basic_blocks().iter_enumerated() {
+    for (bb_id, bb) in mir.basic_blocks.iter_enumerated() {
         for (i, stmt) in bb.statements.iter().enumerate() {
             let loc = Location {
                 block: bb_id,