wip

nyurik · nyurik · commit 9c4c4a7e59b2 · 2023-08-15T23:04:08.000-04:00
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
@@ -1607,7 +1607,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         "Unexpected lifetime resolution {:?} for {:?} at {:?}",
                         res, lifetime.ident, lifetime.ident.span
                     );
-                    span_bug!(lifetime.ident.span, "{}", bug_msg);
+                    span_bug!(lifetime.ident.span, "{bug_msg}");
                 }
             };
 
diff --git a/compiler/rustc_ast_lowering/src/lifetime_collector.rs b/compiler/rustc_ast_lowering/src/lifetime_collector.rs
@@ -38,7 +38,7 @@ impl<'ast> LifetimeCollectVisitor<'ast> {
                     "Unexpected lifetime resolution {:?} for {:?} at {:?}",
                     res, lifetime.ident, lifetime.ident.span
                 );
-                span_bug!(lifetime.ident.span, "{}", bug_msg);
+                span_bug!(lifetime.ident.span, "{bug_msg}");
             }
         }
     }
diff --git a/compiler/rustc_borrowck/src/constraint_generation.rs b/compiler/rustc_borrowck/src/constraint_generation.rs
@@ -71,7 +71,7 @@ impl<'cg, 'tcx> Visitor<'tcx> for ConstraintGeneration<'cg, 'tcx> {
             | TyContext::YieldTy(SourceInfo { span, .. })
             | TyContext::UserTy(span)
             | TyContext::LocalDecl { source_info: SourceInfo { span, .. }, .. } => {
-                span_bug!(span, "should not be visiting outside of the CFG: {:?}", ty_context);
+                span_bug!(span, "should not be visiting outside of the CFG: {ty_context:?}");
             }
             TyContext::Location(location) => {
                 self.add_regular_live_constraint(ty, location);
diff --git a/compiler/rustc_builtin_macros/src/assert/context.rs b/compiler/rustc_builtin_macros/src/assert/context.rs
@@ -159,7 +159,7 @@ impl<'cx, 'a> Context<'cx, 'a> {
                     } else {
                         format!(
                             "Assertion failed: {escaped_expr_str}\nWith captures:\n{}",
-                            &self.fmt_string
+                            self.fmt_string
                         )
                     }),
                     suffix: None,
diff --git a/compiler/rustc_codegen_cranelift/src/common.rs b/compiler/rustc_codegen_cranelift/src/common.rs
@@ -480,7 +480,7 @@ impl<'tcx> LayoutOfHelpers<'tcx> for RevealAllLayoutCx<'tcx> {
         if let LayoutError::SizeOverflow(_) | LayoutError::ReferencesError(_) = err {
             self.0.sess.span_fatal(span, err.to_string())
         } else {
-            span_bug!(span, "failed to get layout for `{}`: {}", ty, err)
+            span_bug!(span, "failed to get layout for `{ty}`: {err}")
         }
     }
 }
diff --git a/compiler/rustc_codegen_cranelift/src/constant.rs b/compiler/rustc_codegen_cranelift/src/constant.rs
@@ -107,7 +107,7 @@ pub(crate) fn eval_mir_constant<'tcx>(
                 fx.tcx.sess.span_err(constant.span, "erroneous constant encountered");
             }
             ErrorHandled::TooGeneric => {
-                span_bug!(constant.span, "codegen encountered polymorphic constant: {:?}", err);
+                span_bug!(constant.span, "codegen encountered polymorphic constant: {err:?}");
             }
         })
         .ok();
diff --git a/compiler/rustc_codegen_gcc/src/context.rs b/compiler/rustc_codegen_gcc/src/context.rs
@@ -479,7 +479,7 @@ impl<'gcc, 'tcx> LayoutOfHelpers<'tcx> for CodegenCx<'gcc, 'tcx> {
         if let LayoutError::SizeOverflow(_) | LayoutError::ReferencesError(_) = err {
             self.sess().emit_fatal(respan(span, err.into_diagnostic()))
         } else {
-            span_bug!(span, "failed to get layout for `{}`: {}", ty, err)
+            span_bug!(span, "failed to get layout for `{ty}`: {err}")
         }
     }
 }
diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -971,7 +971,7 @@ fn link_natively<'a>(
                 sess.emit_err(errors::UnableToExeLinker {
                     linker_path,
                     error: e,
-                    command_formatted: format!("{:?}", &cmd),
+                    command_formatted: format!("{cmd:?}"),
                 });
             }
 
@@ -1477,7 +1477,7 @@ fn print_native_static_libs(
                 sess.emit_note(errors::StaticLibraryNativeArtifacts);
                 // Prefix for greppability
                 // Note: This must not be translated as tools are allowed to depend on this exact string.
-                sess.note_without_error(format!("native-static-libs: {}", &lib_args.join(" ")));
+                sess.note_without_error(format!("native-static-libs: {}", lib_args.join(" ")));
             }
         }
     }
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -313,7 +313,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
             sym::link_section => {
                 if let Some(val) = attr.value_str() {
                     if val.as_str().bytes().any(|b| b == 0) {
-                        let msg = format!("illegal null byte in link_section value: `{}`", &val);
+                        let msg = format!("illegal null byte in link_section value: `{val}`");
                         tcx.sess.span_err(attr.span, msg);
                     } else {
                         codegen_fn_attrs.link_section = Some(val);
@@ -648,7 +648,7 @@ fn check_link_ordinal(tcx: TyCtxt<'_>, attr: &ast::Attribute) -> Option<u16> {
         if *ordinal <= u16::MAX as u128 {
             Some(*ordinal as u16)
         } else {
-            let msg = format!("ordinal value in `link_ordinal` is too large: `{}`", &ordinal);
+            let msg = format!("ordinal value in `link_ordinal` is too large: `{ordinal}`");
             tcx.sess
                 .struct_span_err(attr.span, msg)
                 .note("the value may not exceed `u16::MAX`")
diff --git a/compiler/rustc_codegen_ssa/src/common.rs b/compiler/rustc_codegen_ssa/src/common.rs
@@ -198,7 +198,7 @@ pub fn asm_const_to_str<'tcx>(
     ty_and_layout: TyAndLayout<'tcx>,
 ) -> String {
     let ConstValue::Scalar(scalar) = const_value else {
-        span_bug!(sp, "expected Scalar for promoted asm const, but got {:#?}", const_value)
+        span_bug!(sp, "expected Scalar for promoted asm const, but got {const_value:#?}")
     };
     let value = scalar.assert_bits(ty_and_layout.size);
     match ty_and_layout.ty.kind() {
diff --git a/compiler/rustc_codegen_ssa/src/mir/block.rs b/compiler/rustc_codegen_ssa/src/mir/block.rs
@@ -941,7 +941,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                                 }
                             }
 
-                            span_bug!(span, "receiver has no non-zero-sized fields {:?}", op);
+                            span_bug!(span, "receiver has no non-zero-sized fields {op:?}");
                         }
 
                         // now that we have `*dyn Trait` or `&dyn Trait`, split it up into its
@@ -983,13 +983,13 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                                 }
                             }
 
-                            span_bug!(span, "receiver has no non-zero-sized fields {:?}", op);
+                            span_bug!(span, "receiver has no non-zero-sized fields {op:?}");
                         }
 
                         // Make sure that we've actually unwrapped the rcvr down
                         // to a pointer or ref to `dyn* Trait`.
                         if !op.layout.ty.builtin_deref(true).unwrap().ty.is_dyn_star() {
-                            span_bug!(span, "can't codegen a virtual call on {:#?}", op);
+                            span_bug!(span, "can't codegen a virtual call on {op:#?}");
                         }
                         let place = op.deref(bx.cx());
                         let data_ptr = place.project_field(bx, 0);
@@ -1005,7 +1005,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                         continue;
                     }
                     _ => {
-                        span_bug!(span, "can't codegen a virtual call on {:#?}", op);
+                        span_bug!(span, "can't codegen a virtual call on {op:#?}");
                     }
                 }
             }
diff --git a/compiler/rustc_codegen_ssa/src/mir/mod.rs b/compiler/rustc_codegen_ssa/src/mir/mod.rs
@@ -220,7 +220,7 @@ pub fn codegen_mir<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
                 // errored or at least linted
                 ErrorHandled::Reported(_) => {}
                 ErrorHandled::TooGeneric => {
-                    span_bug!(const_.span, "codegen encountered polymorphic constant: {:?}", err)
+                    span_bug!(const_.span, "codegen encountered polymorphic constant: {err:?}")
                 }
             }
         }
diff --git a/compiler/rustc_const_eval/src/interpret/cast.rs b/compiler/rustc_const_eval/src/interpret/cast.rs
@@ -98,7 +98,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                         // No change to value
                         self.write_immediate(*src, dest)?;
                     }
-                    _ => span_bug!(self.cur_span(), "fn to unsafe fn cast on {:?}", cast_ty),
+                    _ => span_bug!(self.cur_span(), "fn to unsafe fn cast on {cast_ty:?}"),
                 }
             }
 
@@ -298,7 +298,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             }
 
             // Casts to bool are not permitted by rustc, no need to handle them here.
-            _ => span_bug!(self.cur_span(), "invalid int to {:?} cast", cast_ty),
+            _ => span_bug!(self.cur_span(), "invalid int to {cast_ty:?} cast"),
         })
     }
 
@@ -331,7 +331,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             // float -> f64
             Float(FloatTy::F64) => Scalar::from_f64(f.convert(&mut false).value),
             // That's it.
-            _ => span_bug!(self.cur_span(), "invalid float to {:?} cast", dest_ty),
+            _ => span_bug!(self.cur_span(), "invalid float to {dest_ty:?} cast"),
         }
     }
 
diff --git a/compiler/rustc_const_eval/src/interpret/intern.rs b/compiler/rustc_const_eval/src/interpret/intern.rs
@@ -443,7 +443,7 @@ pub fn intern_const_alloc_recursive<
         } else if ecx.tcx.try_get_global_alloc(alloc_id).is_none() {
             // We have hit an `AllocId` that is neither in local or global memory and isn't
             // marked as dangling by local memory. That should be impossible.
-            span_bug!(ecx.tcx.span, "encountered unknown alloc id {:?}", alloc_id);
+            span_bug!(ecx.tcx.span, "encountered unknown alloc id {alloc_id:?}");
         }
     }
     Ok(())
diff --git a/compiler/rustc_const_eval/src/interpret/operator.rs b/compiler/rustc_const_eval/src/interpret/operator.rs
@@ -76,7 +76,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             Le => l <= r,
             Gt => l > r,
             Ge => l >= r,
-            _ => span_bug!(self.cur_span(), "Invalid operation on char: {:?}", bin_op),
+            _ => span_bug!(self.cur_span(), "Invalid operation on char: {bin_op:?}"),
         };
         (Scalar::from_bool(res), false, self.tcx.types.bool)
     }
@@ -99,7 +99,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             BitAnd => l & r,
             BitOr => l | r,
             BitXor => l ^ r,
-            _ => span_bug!(self.cur_span(), "Invalid operation on bool: {:?}", bin_op),
+            _ => span_bug!(self.cur_span(), "Invalid operation on bool: {bin_op:?}"),
         };
         (Scalar::from_bool(res), false, self.tcx.types.bool)
     }
@@ -125,7 +125,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             Mul => ((l * r).value.into(), ty),
             Div => ((l / r).value.into(), ty),
             Rem => ((l % r).value.into(), ty),
-            _ => span_bug!(self.cur_span(), "invalid float op: `{:?}`", bin_op),
+            _ => span_bug!(self.cur_span(), "invalid float op: `{bin_op:?}`"),
         };
         (val, false, ty)
     }
@@ -453,15 +453,15 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 let val = val.to_bool()?;
                 let res = match un_op {
                     Not => !val,
-                    _ => span_bug!(self.cur_span(), "Invalid bool op {:?}", un_op),
+                    _ => span_bug!(self.cur_span(), "Invalid bool op {un_op:?}"),
                 };
                 Ok((Scalar::from_bool(res), false, self.tcx.types.bool))
             }
             ty::Float(fty) => {
                 let res = match (un_op, fty) {
                     (Neg, FloatTy::F32) => Scalar::from_f32(-val.to_f32()?),
                     (Neg, FloatTy::F64) => Scalar::from_f64(-val.to_f64()?),
-                    _ => span_bug!(self.cur_span(), "Invalid float op {:?}", un_op),
+                    _ => span_bug!(self.cur_span(), "Invalid float op {un_op:?}"),
                 };
                 Ok((res, false, layout.ty))
             }
diff --git a/compiler/rustc_const_eval/src/transform/check_consts/check.rs b/compiler/rustc_const_eval/src/transform/check_consts/check.rs
@@ -567,7 +567,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                 } else if ty.is_floating_point() {
                     self.check_op(ops::FloatingPointOp);
                 } else {
-                    span_bug!(self.span, "non-primitive type in `Rvalue::UnaryOp`: {:?}", ty);
+                    span_bug!(self.span, "non-primitive type in `Rvalue::UnaryOp`: {ty:?}");
                 }
             }
 
@@ -715,7 +715,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                         return;
                     }
                     _ => {
-                        span_bug!(terminator.source_info.span, "invalid callee of type {:?}", fn_ty)
+                        span_bug!(terminator.source_info.span, "invalid callee of type {fn_ty:?}")
                     }
                 };
 
diff --git a/compiler/rustc_const_eval/src/transform/promote_consts.rs b/compiler/rustc_const_eval/src/transform/promote_consts.rs
@@ -249,7 +249,7 @@ impl<'tcx> Validator<'_, 'tcx> {
                         Q::in_any_value_of_ty(&self.ccx, return_ty)
                     }
                     kind => {
-                        span_bug!(terminator.source_info.span, "{:?} not promotable", kind);
+                        span_bug!(terminator.source_info.span, "{kind:?} not promotable");
                     }
                 }
             }
@@ -290,7 +290,7 @@ impl<'tcx> Validator<'_, 'tcx> {
                             }
                             TerminatorKind::Yield { .. } => Err(Unpromotable),
                             kind => {
-                                span_bug!(terminator.source_info.span, "{:?} not promotable", kind);
+                                span_bug!(terminator.source_info.span, "{kind:?} not promotable");
                             }
                         }
                     }
@@ -738,7 +738,7 @@ impl<'a, 'tcx> Promoter<'a, 'tcx> {
                 location
             }
             state => {
-                span_bug!(self.promoted.span, "{:?} not promotable: {:?}", temp, state);
+                span_bug!(self.promoted.span, "{temp:?} not promotable: {state:?}");
             }
         };
         if !self.keep_original {
@@ -759,7 +759,7 @@ impl<'a, 'tcx> Promoter<'a, 'tcx> {
             let (mut rvalue, source_info) = {
                 let statement = &mut self.source[loc.block].statements[loc.statement_index];
                 let StatementKind::Assign(box (_, rhs)) = &mut statement.kind else {
-                    span_bug!(statement.source_info.span, "{:?} is not an assignment", statement);
+                    span_bug!(statement.source_info.span, "{statement:?} is not an assignment");
                 };
 
                 (
@@ -787,7 +787,7 @@ impl<'a, 'tcx> Promoter<'a, 'tcx> {
                 let target = match &terminator.kind {
                     TerminatorKind::Call { target: Some(target), .. } => *target,
                     kind => {
-                        span_bug!(terminator.source_info.span, "{:?} not promotable", kind);
+                        span_bug!(terminator.source_info.span, "{kind:?} not promotable");
                     }
                 };
                 Terminator {
@@ -823,7 +823,7 @@ impl<'a, 'tcx> Promoter<'a, 'tcx> {
                     };
                 }
                 kind => {
-                    span_bug!(terminator.source_info.span, "{:?} not promotable", kind);
+                    span_bug!(terminator.source_info.span, "{kind:?} not promotable");
                 }
             };
         };
diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
@@ -1486,13 +1486,13 @@ impl HandlerInner {
                     self.failure(format!(
                         "For more information about an error, try \
                          `rustc --explain {}`.",
-                        &error_codes[0]
+                        error_codes[0]
                     ));
                 } else {
                     self.failure(format!(
                         "For more information about this error, try \
                          `rustc --explain {}`.",
-                        &error_codes[0]
+                        error_codes[0]
                     ));
                 }
             }
diff --git a/compiler/rustc_expand/src/mbe/metavar_expr.rs b/compiler/rustc_expand/src/mbe/metavar_expr.rs
@@ -134,11 +134,11 @@ fn parse_ident<'sess>(
         let token_str = pprust::token_to_string(token);
         let mut err = sess.span_diagnostic.struct_span_err(
             span,
-            format!("expected identifier, found `{}`", &token_str)
+            format!("expected identifier, found `{token_str}`")
         );
         err.span_suggestion(
             token.span,
-            format!("try removing `{}`", &token_str),
+            format!("try removing `{token_str}`"),
             "",
             Applicability::MaybeIncorrect,
         );
diff --git a/compiler/rustc_fluent_macro/src/fluent.rs b/compiler/rustc_fluent_macro/src/fluent.rs
@@ -243,7 +243,7 @@ pub(crate) fn fluent_messages(input: proc_macro::TokenStream) -> proc_macro::Tok
 
             for Attribute { id: Identifier { name: attr_name }, .. } in attributes {
                 let snake_name = Ident::new(
-                    &format!("{}{}", &crate_prefix, &attr_name.replace('-', "_")),
+                    &format!("{}{}", crate_prefix, attr_name.replace('-', "_")),
                     resource_str.span(),
                 );
                 if !previous_attrs.insert(snake_name.clone()) {
diff --git a/compiler/rustc_hir_typeck/src/demand.rs b/compiler/rustc_hir_typeck/src/demand.rs
@@ -1995,9 +1995,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     // Missing try_into implementation for `{integer}` to `{float}`
                     err.multipart_suggestion_verbose(
                         format!(
-                            "{}, producing the floating point representation of the integer, \
-                                rounded if necessary",
-                            &msg,
+                            "{msg}, producing the floating point representation of the integer, \
+                                rounded if necessary"
                         ),
                         cast_suggestion,
                         Applicability::MaybeIncorrect, // lossy conversion
diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -873,9 +873,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         }
                         (
                             match parent_pred {
-                                None => format!("`{}`", &p),
+                                None => format!("`{p}`"),
                                 Some(parent_pred) => match format_pred(*parent_pred) {
-                                    None => format!("`{}`", &p),
+                                    None => format!("`{p}`"),
                                     Some((parent_p, _)) => {
                                         if !suggested
                                             && !suggested_bounds.contains(pred)
diff --git a/compiler/rustc_middle/src/middle/stability.rs b/compiler/rustc_middle/src/middle/stability.rs
@@ -108,7 +108,7 @@ pub fn report_unstable(
 ) {
     let msg = match reason {
         Some(r) => format!("use of unstable library feature '{feature}': {r}"),
-        None => format!("use of unstable library feature '{}'", &feature),
+        None => format!("use of unstable library feature '{feature}'"),
     };
 
     if is_soft {
diff --git a/compiler/rustc_middle/src/mir/spanview.rs b/compiler/rustc_middle/src/mir/spanview.rs
@@ -624,7 +624,7 @@ fn tooltip<'tcx>(
 ) -> String {
     let source_map = tcx.sess.source_map();
     let mut text = Vec::new();
-    text.push(format!("{}: {}:", spanview_id, &source_map.span_to_embeddable_string(span)));
+    text.push(format!("{}: {}:", spanview_id, source_map.span_to_embeddable_string(span)));
     for statement in statements {
         let source_range = source_range_no_file(tcx, statement.source_info.span);
         text.push(format!(
diff --git a/compiler/rustc_mir_build/src/thir/pattern/mod.rs b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
diff --git a/compiler/rustc_mir_transform/src/early_otherwise_branch.rs b/compiler/rustc_mir_transform/src/early_otherwise_branch.rs
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
diff --git a/compiler/rustc_symbol_mangling/src/typeid/typeid_itanium_cxx_abi.rs b/compiler/rustc_symbol_mangling/src/typeid/typeid_itanium_cxx_abi.rs
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs

Original file line number	Diff line number	Diff line change
`@@ -1607,7 +1607,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {`
`1607`	`1607`	`"Unexpected lifetime resolution {:?} for {:?} at {:?}",`
`1608`	`1608`	`res, lifetime.ident, lifetime.ident.span`
`1609`	`1609`	`);`
`1610`		`- span_bug!(lifetime.ident.span, "{}", bug_msg);`
	`1610`	`+ span_bug!(lifetime.ident.span, "{bug_msg}");`
`1611`	`1611`	`}`
`1612`	`1612`	`};`
`1613`	`1613`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ impl<'ast> LifetimeCollectVisitor<'ast> {`
`38`	`38`	`"Unexpected lifetime resolution {:?} for {:?} at {:?}",`
`39`	`39`	`res, lifetime.ident, lifetime.ident.span`
`40`	`40`	`);`
`41`		`- span_bug!(lifetime.ident.span, "{}", bug_msg);`
	`41`	`+ span_bug!(lifetime.ident.span, "{bug_msg}");`
`42`	`42`	`}`
`43`	`43`	`}`
`44`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ impl<'cg, 'tcx> Visitor<'tcx> for ConstraintGeneration<'cg, 'tcx> {`
`71`	`71`	`\| TyContext::YieldTy(SourceInfo { span, .. })`
`72`	`72`	`\| TyContext::UserTy(span)`
`73`	`73`	`\| TyContext::LocalDecl { source_info: SourceInfo { span, .. }, .. } => {`
`74`		`- span_bug!(span, "should not be visiting outside of the CFG: {:?}", ty_context);`
	`74`	`+ span_bug!(span, "should not be visiting outside of the CFG: {ty_context:?}");`
`75`	`75`	`}`
`76`	`76`	`TyContext::Location(location) => {`
`77`	`77`	`self.add_regular_live_constraint(ty, location);`
Original file line number	Diff line number	Diff line change
`@@ -159,7 +159,7 @@ impl<'cx, 'a> Context<'cx, 'a> {`
`159`	`159`	`} else {`
`160`	`160`	`format!(`
`161`	`161`	`"Assertion failed: {escaped_expr_str}\nWith captures:\n{}",`
`162`		`- &self.fmt_string`
	`162`	`+ self.fmt_string`
`163`	`163`	`)`
`164`	`164`	`}),`
`165`	`165`	`suffix: None,`
Original file line number	Diff line number	Diff line change
`@@ -480,7 +480,7 @@ impl<'tcx> LayoutOfHelpers<'tcx> for RevealAllLayoutCx<'tcx> {`
`480`	`480`	`if let LayoutError::SizeOverflow(_) \| LayoutError::ReferencesError(_) = err {`
`481`	`481`	`self.0.sess.span_fatal(span, err.to_string())`
`482`	`482`	`} else {`
`483`		- span_bug!(span, "failed to get layout for `{}`: {}", ty, err)
	`483`	+ span_bug!(span, "failed to get layout for `{ty}`: {err}")
`484`	`484`	`}`
`485`	`485`	`}`
`486`	`486`	`}`
Original file line number	Diff line number	Diff line change
`@@ -107,7 +107,7 @@ pub(crate) fn eval_mir_constant<'tcx>(`
`107`	`107`	`fx.tcx.sess.span_err(constant.span, "erroneous constant encountered");`
`108`	`108`	`}`
`109`	`109`	`ErrorHandled::TooGeneric => {`
`110`		`- span_bug!(constant.span, "codegen encountered polymorphic constant: {:?}", err);`
	`110`	`+ span_bug!(constant.span, "codegen encountered polymorphic constant: {err:?}");`
`111`	`111`	`}`
`112`	`112`	`})`
`113`	`113`	`.ok();`
Original file line number	Diff line number	Diff line change
`@@ -479,7 +479,7 @@ impl<'gcc, 'tcx> LayoutOfHelpers<'tcx> for CodegenCx<'gcc, 'tcx> {`
`479`	`479`	`if let LayoutError::SizeOverflow(_) \| LayoutError::ReferencesError(_) = err {`
`480`	`480`	`self.sess().emit_fatal(respan(span, err.into_diagnostic()))`
`481`	`481`	`} else {`
`482`		- span_bug!(span, "failed to get layout for `{}`: {}", ty, err)
	`482`	+ span_bug!(span, "failed to get layout for `{ty}`: {err}")
`483`	`483`	`}`
`484`	`484`	`}`
`485`	`485`	`}`
Original file line number	Diff line number	Diff line change
`@@ -971,7 +971,7 @@ fn link_natively<'a>(`
`971`	`971`	`sess.emit_err(errors::UnableToExeLinker {`
`972`	`972`	`linker_path,`
`973`	`973`	`error: e,`
`974`		`- command_formatted: format!("{:?}", &cmd),`
	`974`	`+ command_formatted: format!("{cmd:?}"),`
`975`	`975`	`});`
`976`	`976`	`}`
`977`	`977`
`@@ -1477,7 +1477,7 @@ fn print_native_static_libs(`
`1477`	`1477`	`sess.emit_note(errors::StaticLibraryNativeArtifacts);`
`1478`	`1478`	`// Prefix for greppability`
`1479`	`1479`	`// Note: This must not be translated as tools are allowed to depend on this exact string.`
`1480`		`- sess.note_without_error(format!("native-static-libs: {}", &lib_args.join(" ")));`
	`1480`	`+ sess.note_without_error(format!("native-static-libs: {}", lib_args.join(" ")));`
`1481`	`1481`	`}`
`1482`	`1482`	`}`
`1483`	`1483`	`}`