bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

inline format!() args up to and including rustc_codegen_llvm

Browse source
This commit is contained in:
Matthias Krüger 2023-07-25 23:04:01 +02:00
parent 2e0136a131
commit 3ce90b1649
72 changed files with 411 additions and 481 deletions
Download patch file Download diff file Expand all files Collapse all files

8
compiler/rustc_trait_selection/src/traits/auto_trait.rs
View file

@ -161,7 +161,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
let (full_env, full_user_env) = self
.evaluate_predicates(&infcx, trait_did, ty, new_env, user_env, &mut fresh_preds)
.unwrap_or_else(|| {
panic!("Failed to fully process: {:?} {:?} {:?}", ty, trait_did, orig_env)
panic!("Failed to fully process: {ty:?} {trait_did:?} {orig_env:?}")
});
debug!(
@ -178,7 +178,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
ocx.register_bound(ObligationCause::dummy(), full_env, ty, trait_did);
let errors = ocx.select_all_or_error();
if !errors.is_empty() {
panic!("Unable to fulfill trait {:?} for '{:?}': {:?}", trait_did, ty, errors);
panic!("Unable to fulfill trait {trait_did:?} for '{ty:?}': {errors:?}");
}
let outlives_env = OutlivesEnvironment::new(full_env);
@ -339,7 +339,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
return None;
}
}
_ => panic!("Unexpected error for '{:?}': {:?}", ty, result),
_ => panic!("Unexpected error for '{ty:?}': {result:?}"),
};
let normalized_preds =
@ -747,7 +747,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
// subobligations or getting an error) when we started off with
// inference variables
if p.term().skip_binder().has_infer_types() {
panic!("Unexpected result when selecting {:?} {:?}", ty, obligation)
panic!("Unexpected result when selecting {ty:?} {obligation:?}")
}
}
}

2
compiler/rustc_trait_selection/src/traits/coherence.rs
View file

@ -357,7 +357,7 @@ fn impl_intersection_has_negative_obligation(
Err(err) => {
tcx.sess.delay_span_bug(
tcx.def_span(impl1_def_id),
format!("failed to fully normalize {:?}: {:?}", impl1_def_id, err),
format!("failed to fully normalize {impl1_def_id:?}: {err:?}"),
);
return false;
}

57
compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
View file

@ -226,7 +226,7 @@ impl<'tcx> InferCtxtExt<'tcx> for InferCtxt<'tcx> {
let span = variant_data.ctor_hir_id().map_or(DUMMY_SP, |id| hir.span(id));
(span, None, vec![ArgKind::empty(); variant_data.fields().len()])
}
_ => panic!("non-FnLike node found: {:?}", node),
_ => panic!("non-FnLike node found: {node:?}"),
})
}
@ -273,10 +273,10 @@ impl<'tcx> InferCtxtExt<'tcx> for InferCtxt<'tcx> {
found_str,
);
err.span_label(span, format!("expected {} that takes {}", kind, expected_str));
err.span_label(span, format!("expected {kind} that takes {expected_str}"));
if let Some(found_span) = found_span {
err.span_label(found_span, format!("takes {}", found_str));
err.span_label(found_span, format!("takes {found_str}"));
// Suggest to take and ignore the arguments with expected_args_length `_`s if
// found arguments is empty (assume the user just wants to ignore args in this case).
@ -289,7 +289,7 @@ impl<'tcx> InferCtxtExt<'tcx> for InferCtxt<'tcx> {
"consider changing the closure to take and ignore the expected argument{}",
pluralize!(expected_args.len())
),
format!("|{}|", underscores),
format!("|{underscores}|"),
Applicability::MachineApplicable,
);
}
@ -304,7 +304,7 @@ impl<'tcx> InferCtxtExt<'tcx> for InferCtxt<'tcx> {
err.span_suggestion_verbose(
found_span,
"change the closure to take multiple arguments instead of a single tuple",
format!("|{}|", sugg),
format!("|{sugg}|"),
Applicability::MachineApplicable,
);
}
@ -703,9 +703,9 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
.get_parent_trait_ref(obligation.cause.code())
.map(|(t, s)| {
(
format!(" in `{}`", t),
format!("within `{}`, ", t),
s.map(|s| (format!("within this `{}`", t), s)),
format!(" in `{t}`"),
format!("within `{t}`, "),
s.map(|s| (format!("within this `{t}`"), s)),
)
})
.unwrap_or_default();
@ -1070,7 +1070,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
// which bounds actually failed to hold.
self.tcx.sess.struct_span_err(
span,
format!("the type `{}` is not well-formed", ty),
format!("the type `{ty}` is not well-formed"),
)
}
}
@ -1108,7 +1108,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
ty::PredicateKind::Clause(ty::ClauseKind::ConstArgHasType(ct, ty)) => {
let mut diag = self.tcx.sess.struct_span_err(
span,
format!("the constant `{}` is not of type `{}`", ct, ty),
format!("the constant `{ct}` is not of type `{ty}`"),
);
self.note_type_err(
&mut diag,
@ -1980,7 +1980,7 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
if all_traits_equal {
format!("\n {}", c.self_ty())
} else {
format!("\n {}", c)
format!("\n {c}")
}
})
.collect();
@ -2178,10 +2178,8 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
format!("trait impl{} with same name found", pluralize!(trait_impls.len())),
);
let trait_crate = self.tcx.crate_name(trait_with_same_path.krate);
let crate_msg = format!(
"perhaps two different versions of crate `{}` are being used?",
trait_crate
);
let crate_msg =
format!("perhaps two different versions of crate `{trait_crate}` are being used?");
err.note(crate_msg);
suggested = true;
}
@ -2309,7 +2307,7 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
err.cancel();
return;
}
err.note(format!("cannot satisfy `{}`", predicate));
err.note(format!("cannot satisfy `{predicate}`"));
let impl_candidates = self
.find_similar_impl_candidates(predicate.to_opt_poly_trait_pred().unwrap());
if impl_candidates.len() < 10 {
@ -2373,7 +2371,7 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
if let Some(local_def_id) = data.trait_ref.def_id.as_local()
&& let Some(hir::Node::Item(hir::Item { ident: trait_name, kind: hir::ItemKind::Trait(_, _, _, _, trait_item_refs), .. })) = self.tcx.hir().find_by_def_id(local_def_id)
&& let Some(method_ref) = trait_item_refs.iter().find(|item_ref| item_ref.ident == *assoc_item_name) {
err.span_label(method_ref.span, format!("`{}::{}` defined here", trait_name, assoc_item_name));
err.span_label(method_ref.span, format!("`{trait_name}::{assoc_item_name}` defined here"));
}
err.span_label(span, format!("cannot {verb} associated {noun} of trait"));
@ -2474,7 +2472,7 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
ErrorCode::E0284,
true,
);
err.note(format!("cannot satisfy `{}`", predicate));
err.note(format!("cannot satisfy `{predicate}`"));
err
} else {
// If we can't find a substitution, just print a generic error
@ -2485,7 +2483,7 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
"type annotations needed: cannot satisfy `{}`",
predicate,
);
err.span_label(span, format!("cannot satisfy `{}`", predicate));
err.span_label(span, format!("cannot satisfy `{predicate}`"));
err
}
}
@ -2513,7 +2511,7 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
"type annotations needed: cannot satisfy `{}`",
predicate,
);
err.span_label(span, format!("cannot satisfy `{}`", predicate));
err.span_label(span, format!("cannot satisfy `{predicate}`"));
err
}
}
@ -2528,7 +2526,7 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
"type annotations needed: cannot satisfy `{}`",
predicate,
);
err.span_label(span, format!("cannot satisfy `{}`", predicate));
err.span_label(span, format!("cannot satisfy `{predicate}`"));
err
}
};
@ -2565,7 +2563,7 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
}
}
}
let mut crate_names: Vec<_> = crates.iter().map(|n| format!("`{}`", n)).collect();
let mut crate_names: Vec<_> = crates.iter().map(|n| format!("`{n}`")).collect();
crate_names.sort();
crate_names.dedup();
post.sort();
@ -2592,7 +2590,7 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
predicate
);
let post = if post.len() > 1 || (post.len() == 1 && post[0].contains('\n')) {
format!(":\n{}", post.iter().map(|p| format!("- {}", p)).collect::<Vec<_>>().join("\n"),)
format!(":\n{}", post.iter().map(|p| format!("- {p}")).collect::<Vec<_>>().join("\n"),)
} else if post.len() == 1 {
format!(": `{}`", post[0])
} else {
@ -2601,7 +2599,7 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
match (spans.len(), crates.len(), crate_names.len()) {
(0, 0, 0) => {
err.note(format!("cannot satisfy `{}`", predicate));
err.note(format!("cannot satisfy `{predicate}`"));
}
(0, _, 1) => {
err.note(format!("{} in the `{}` crate{}", msg, crates[0], post,));
@ -2772,7 +2770,7 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
err.span_suggestion_verbose(
span,
"consider relaxing the implicit `Sized` restriction",
format!("{} ?Sized", separator),
format!("{separator} ?Sized"),
Applicability::MachineApplicable,
);
}
@ -2863,7 +2861,7 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
}
})
.unwrap_or_else(|| {
format!("the trait bound `{}` is not satisfied{}", trait_predicate, post_message)
format!("the trait bound `{trait_predicate}` is not satisfied{post_message}")
})
}
@ -3151,11 +3149,11 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
err.span_label(
closure_span,
format!("this closure implements `{}`, not `{}`", found_kind, kind),
format!("this closure implements `{found_kind}`, not `{kind}`"),
);
err.span_label(
obligation.cause.span,
format!("the requirement to implement `{}` derives from here", kind),
format!("the requirement to implement `{kind}` derives from here"),
);
// Additional context information explaining why the closure only implements
@ -3382,8 +3380,7 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
let const_span = self.tcx.def_span(uv.def);
match self.tcx.sess.source_map().span_to_snippet(const_span) {
Ok(snippet) => err.help(format!(
"try adding a `where` bound using this expression: `where [(); {}]:`",
snippet
"try adding a `where` bound using this expression: `where [(); {snippet}]:`"
)),
_ => err.help("consider adding a `where` bound using this expression"),
};

8
compiler/rustc_trait_selection/src/traits/error_reporting/on_unimplemented.rs
View file

@ -170,7 +170,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
if let Some(k) = obligation.cause.span.desugaring_kind() {
flags.push((sym::from_desugaring, None));
flags.push((sym::from_desugaring, Some(format!("{:?}", k))));
flags.push((sym::from_desugaring, Some(format!("{k:?}"))));
}
if let ObligationCauseCode::MainFunctionType = obligation.cause.code() {
@ -258,9 +258,9 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
if let ty::Array(aty, len) = self_ty.kind() {
flags.push((sym::_Self, Some("[]".to_string())));
let len = len.try_to_value().and_then(|v| v.try_to_target_usize(self.tcx));
flags.push((sym::_Self, Some(format!("[{}; _]", aty))));
flags.push((sym::_Self, Some(format!("[{aty}; _]"))));
if let Some(n) = len {
flags.push((sym::_Self, Some(format!("[{}; {}]", aty, n))));
flags.push((sym::_Self, Some(format!("[{aty}; {n}]"))));
}
if let Some(def) = aty.ty_adt_def() {
// We also want to be able to select the array's type's original
@ -579,7 +579,7 @@ impl<'tcx> OnUnimplementedFormatString {
"there is no parameter `{}` on {}",
s,
if trait_def_id == item_def_id {
format!("trait `{}`", trait_name)
format!("trait `{trait_name}`")
} else {
"impl".to_string()
}

152
compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
View file

@ -479,13 +479,13 @@ fn suggest_restriction<'tcx>(
.visit_ty(input);
}
// The type param `T: Trait` we will suggest to introduce.
let type_param = format!("{}: {}", type_param_name, bound_str);
let type_param = format!("{type_param_name}: {bound_str}");
let mut sugg = vec![
if let Some(span) = hir_generics.span_for_param_suggestion() {
(span, format!(", {}", type_param))
(span, format!(", {type_param}"))
} else {
(hir_generics.span, format!("<{}>", type_param))
(hir_generics.span, format!("<{type_param}>"))
},
// `fn foo(t: impl Trait)`
// ^ suggest `where <T as Trait>::A: Bound`
@ -530,7 +530,7 @@ fn suggest_restriction<'tcx>(
err.span_suggestion_verbose(
sp,
format!("consider further restricting {}", msg),
format!("consider further restricting {msg}"),
suggestion,
Applicability::MachineApplicable,
);
@ -694,7 +694,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
term
);
} else {
constraint.push_str(&format!("<{} = {}>", name, term));
constraint.push_str(&format!("<{name} = {term}>"));
}
}
@ -1016,7 +1016,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
let name = self.tcx.def_path_str(def_id);
err.span_label(
self.tcx.def_span(def_id),
format!("consider calling the constructor for `{}`", name),
format!("consider calling the constructor for `{name}`"),
);
name
}
@ -1395,7 +1395,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
// Because of this, we modify the error to refer to the original obligation and
// return early in the caller.
let msg = format!("the trait bound `{}` is not satisfied", old_pred);
let msg = format!("the trait bound `{old_pred}` is not satisfied");
if has_custom_message {
err.note(msg);
} else {
@ -1435,7 +1435,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
err.multipart_suggestion_verbose(
sugg_msg,
vec![
(span.shrink_to_lo(), format!("({}", sugg_prefix)),
(span.shrink_to_lo(), format!("({sugg_prefix}")),
(span.shrink_to_hi(), ")".to_string()),
],
Applicability::MaybeIncorrect,
@ -1471,7 +1471,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
vec![(span.shrink_to_lo(), sugg_prefix)]
} else {
vec![
(span.shrink_to_lo(), format!("{}(", sugg_prefix)),
(span.shrink_to_lo(), format!("{sugg_prefix}(")),
(span.shrink_to_hi(), ")".to_string()),
]
};
@ -1702,8 +1702,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
hir.get_if_local(*def_id)
{
let msg = format!(
"alternatively, consider making `fn {}` asynchronous",
ident
"alternatively, consider making `fn {ident}` asynchronous"
);
if vis_span.is_empty() {
err.span_suggestion_verbose(
@ -1954,10 +1953,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
// don't print out the [type error] here
err.delay_as_bug();
} else {
err.span_label(
expr.span,
format!("this returned value is of type `{}`", ty),
);
err.span_label(expr.span, format!("this returned value is of type `{ty}`"));
}
}
}
@ -2458,8 +2454,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
err.clear_code();
err.set_primary_message(format!(
"{} cannot be {} between threads safely",
future_or_generator, trait_verb
"{future_or_generator} cannot be {trait_verb} between threads safely"
));
let original_span = err.span.primary_span().unwrap();
@ -2468,7 +2463,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
let message = outer_generator
.and_then(|generator_did| {
Some(match self.tcx.generator_kind(generator_did).unwrap() {
GeneratorKind::Gen => format!("generator is not {}", trait_name),
GeneratorKind::Gen => format!("generator is not {trait_name}"),
GeneratorKind::Async(AsyncGeneratorKind::Fn) => self
.tcx
.parent(generator_did)
@ -2476,73 +2471,73 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
.map(|parent_did| hir.local_def_id_to_hir_id(parent_did))
.and_then(|parent_hir_id| hir.opt_name(parent_hir_id))
.map(|name| {
format!("future returned by `{}` is not {}", name, trait_name)
format!("future returned by `{name}` is not {trait_name}")
})?,
GeneratorKind::Async(AsyncGeneratorKind::Block) => {
format!("future created by async block is not {}", trait_name)
format!("future created by async block is not {trait_name}")
}
GeneratorKind::Async(AsyncGeneratorKind::Closure) => {
format!("future created by async closure is not {}", trait_name)
format!("future created by async closure is not {trait_name}")
}
})
})
.unwrap_or_else(|| format!("{} is not {}", future_or_generator, trait_name));
.unwrap_or_else(|| format!("{future_or_generator} is not {trait_name}"));
span.push_span_label(original_span, message);
err.set_span(span);
format!("is not {}", trait_name)
format!("is not {trait_name}")
} else {
format!("does not implement `{}`", trait_pred.print_modifiers_and_trait_path())
};
let mut explain_yield =
|interior_span: Span, yield_span: Span, scope_span: Option<Span>| {
let mut span = MultiSpan::from_span(yield_span);
let snippet = match source_map.span_to_snippet(interior_span) {
// #70935: If snippet contains newlines, display "the value" instead
// so that we do not emit complex diagnostics.
Ok(snippet) if !snippet.contains('\n') => format!("`{}`", snippet),
_ => "the value".to_string(),
};
// note: future is not `Send` as this value is used across an await
// --> $DIR/issue-70935-complex-spans.rs:13:9
// |
// LL | baz(|| async {
// | ______________-
// | |
// | |
// LL | | foo(tx.clone());
// LL | | }).await;
// | | - ^^^^^^ await occurs here, with value maybe used later
// | |__________|
// | has type `closure` which is not `Send`
// note: value is later dropped here
// LL | | }).await;
// | | ^
//
span.push_span_label(
yield_span,
format!("{} occurs here, with {} maybe used later", await_or_yield, snippet),
);
span.push_span_label(
interior_span,
format!("has type `{}` which {}", target_ty, trait_explanation),
);
if let Some(scope_span) = scope_span {
let scope_span = source_map.end_point(scope_span);
let mut explain_yield = |interior_span: Span,
yield_span: Span,
scope_span: Option<Span>| {
let mut span = MultiSpan::from_span(yield_span);
let snippet = match source_map.span_to_snippet(interior_span) {
// #70935: If snippet contains newlines, display "the value" instead
// so that we do not emit complex diagnostics.
Ok(snippet) if !snippet.contains('\n') => format!("`{snippet}`"),
_ => "the value".to_string(),
};
// note: future is not `Send` as this value is used across an await
// --> $DIR/issue-70935-complex-spans.rs:13:9
// |
// LL | baz(|| async {
// | ______________-
// | |
// | |
// LL | | foo(tx.clone());
// LL | | }).await;
// | | - ^^^^^^ await occurs here, with value maybe used later
// | |__________|
// | has type `closure` which is not `Send`
// note: value is later dropped here
// LL | | }).await;
// | | ^
//
span.push_span_label(
yield_span,
format!("{await_or_yield} occurs here, with {snippet} maybe used later"),
);
span.push_span_label(
interior_span,
format!("has type `{target_ty}` which {trait_explanation}"),
);
if let Some(scope_span) = scope_span {
let scope_span = source_map.end_point(scope_span);
let msg = format!("{} is later dropped here", snippet);
span.push_span_label(scope_span, msg);
}
err.span_note(
let msg = format!("{snippet} is later dropped here");
span.push_span_label(scope_span, msg);
}
err.span_note(
span,
format!(
"{} {} as this value is used across {}",
future_or_generator, trait_explanation, an_await_or_yield
"{future_or_generator} {trait_explanation} as this value is used across {an_await_or_yield}"
),
);
};
};
match interior_or_upvar_span {
GeneratorInteriorOrUpvar::Interior(interior_span, interior_extra_info) => {
if let Some((scope_span, yield_span, expr, from_awaited_ty)) = interior_extra_info {
@ -2552,15 +2547,13 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
span.push_span_label(
await_span,
format!(
"await occurs here on type `{}`, which {}",
target_ty, trait_explanation
"await occurs here on type `{target_ty}`, which {trait_explanation}"
),
);
err.span_note(
span,
format!(
"future {not_trait} as it awaits another future which {not_trait}",
not_trait = trait_explanation
"future {trait_explanation} as it awaits another future which {trait_explanation}"
),
);
} else {
@ -2643,18 +2636,16 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
let ref_kind = if is_mut { "&mut" } else { "&" };
(
format!(
"has type `{}` which {}, because `{}` is not `{}`",
target_ty, trait_explanation, ref_ty, ref_ty_trait
"has type `{target_ty}` which {trait_explanation}, because `{ref_ty}` is not `{ref_ty_trait}`"
),
format!(
"captured value {} because `{}` references cannot be sent unless their referent is `{}`",
trait_explanation, ref_kind, ref_ty_trait
"captured value {trait_explanation} because `{ref_kind}` references cannot be sent unless their referent is `{ref_ty_trait}`"
),
)
}
None => (
format!("has type `{}` which {}", target_ty, trait_explanation),
format!("captured value {}", trait_explanation),
format!("has type `{target_ty}` which {trait_explanation}"),
format!("captured value {trait_explanation}"),
),
};
@ -2743,8 +2734,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
}
ObligationCauseCode::ObjectTypeBound(object_ty, region) => {
err.note(format!(
"required so that the lifetime bound of `{}` for `{}` is satisfied",
region, object_ty,
"required so that the lifetime bound of `{region}` for `{object_ty}` is satisfied",
));
}
ObligationCauseCode::ItemObligation(_)
@ -3064,7 +3054,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
let mut msg =
"required because it captures the following types: ".to_owned();
for ty in bound_tys.skip_binder() {
with_forced_trimmed_paths!(write!(msg, "`{}`, ", ty).unwrap());
with_forced_trimmed_paths!(write!(msg, "`{ty}`, ").unwrap());
}
err.note(msg.trim_end_matches(", ").to_string())
}
@ -3078,7 +3068,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
"required because it captures the following types: ".to_owned();
for bty in tcx.generator_hidden_types(*def_id) {
let ty = bty.instantiate(tcx, args);
write!(msg, "`{}`, ", ty).unwrap();
write!(msg, "`{ty}`, ").unwrap();
}
err.note(msg.trim_end_matches(", ").to_string())
}
@ -3513,7 +3503,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
trait_pred.skip_binder().self_ty(),
diagnostic_name,
),
format!("#[derive({})]\n", diagnostic_name),
format!("#[derive({diagnostic_name})]\n"),
Applicability::MaybeIncorrect,
);
}
@ -3999,7 +3989,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
.map(|trait_ref| trait_ref.trait_ref.self_ty())
.find(|t| is_slice(*t))
{
let msg = format!("convert the array to a `{}` slice instead", slice_ty);
let msg = format!("convert the array to a `{slice_ty}` slice instead");
if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span) {
let mut suggestions = vec![];

6
compiler/rustc_trait_selection/src/traits/object_safety.rs
View file

@ -517,8 +517,7 @@ fn virtual_call_violation_for_method<'tcx>(
tcx.sess.delay_span_bug(
tcx.def_span(method.def_id),
format!(
"receiver when `Self = ()` should have a Scalar ABI; found {:?}",
abi
"receiver when `Self = ()` should have a Scalar ABI; found {abi:?}"
),
);
}
@ -536,8 +535,7 @@ fn virtual_call_violation_for_method<'tcx>(
tcx.sess.delay_span_bug(
tcx.def_span(method.def_id),
format!(
"receiver when `Self = {}` should have a ScalarPair ABI; found {:?}",
trait_object_ty, abi
"receiver when `Self = {trait_object_ty}` should have a ScalarPair ABI; found {abi:?}"
),
);
}

8
compiler/rustc_trait_selection/src/traits/project.rs
View file

@ -483,8 +483,7 @@ impl<'a, 'b, 'tcx> AssocTypeNormalizer<'a, 'b, 'tcx> {
assert!(
!value.has_escaping_bound_vars(),
"Normalizing {:?} without wrapping in a `Binder`",
value
"Normalizing {value:?} without wrapping in a `Binder`"
);
if !needs_normalization(&value, self.param_env.reveal()) {
@ -1932,7 +1931,7 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
// These traits have no associated types.
selcx.tcx().sess.delay_span_bug(
obligation.cause.span,
format!("Cannot project an associated type from `{:?}`", impl_source),
format!("Cannot project an associated type from `{impl_source:?}`"),
);
return Err(());
}
@ -2303,8 +2302,7 @@ fn confirm_param_env_candidate<'cx, 'tcx>(
}
Err(e) => {
let msg = format!(
"Failed to unify obligation `{:?}` with poly_projection `{:?}`: {:?}",
obligation, poly_cache_entry, e,
"Failed to unify obligation `{obligation:?}` with poly_projection `{poly_cache_entry:?}`: {e:?}",
);
debug!("confirm_param_env_candidate: {}", msg);
let err = Ty::new_error_with_message(infcx.tcx, obligation.cause.span, msg);

2
compiler/rustc_trait_selection/src/traits/query/normalize.rs
View file

@ -299,7 +299,7 @@ impl<'cx, 'tcx> FallibleTypeFolder<TyCtxt<'tcx>> for QueryNormalizer<'cx, 'tcx>
if !tcx.sess.opts.actually_rustdoc {
tcx.sess.delay_span_bug(
DUMMY_SP,
format!("unexpected ambiguity: {:?} {:?}", c_data, result),
format!("unexpected ambiguity: {c_data:?} {result:?}"),
);
}
return Err(NoSolution);

5
compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs
View file

@ -77,8 +77,7 @@ where
let pre_obligations = infcx.take_registered_region_obligations();
assert!(
pre_obligations.is_empty(),
"scrape_region_constraints: incoming region obligations = {:#?}",
pre_obligations,
"scrape_region_constraints: incoming region obligations = {pre_obligations:#?}",
);
let value = infcx.commit_if_ok(|_| {
@ -92,7 +91,7 @@ where
} else {
Err(infcx.tcx.sess.delay_span_bug(
DUMMY_SP,
format!("errors selecting obligation during MIR typeck: {:?}", errors),
format!("errors selecting obligation during MIR typeck: {errors:?}"),
))
}
})?;

14
compiler/rustc_trait_selection/src/traits/select/mod.rs
View file

@ -74,22 +74,21 @@ impl IntercrateAmbiguityCause {
match self {
IntercrateAmbiguityCause::DownstreamCrate { trait_desc, self_desc } => {
let self_desc = if let Some(ty) = self_desc {
format!(" for type `{}`", ty)
format!(" for type `{ty}`")
} else {
String::new()
};
format!("downstream crates may implement trait `{}`{}", trait_desc, self_desc)
format!("downstream crates may implement trait `{trait_desc}`{self_desc}")
}
IntercrateAmbiguityCause::UpstreamCrateUpdate { trait_desc, self_desc } => {
let self_desc = if let Some(ty) = self_desc {
format!(" for type `{}`", ty)
format!(" for type `{ty}`")
} else {
String::new()
};
format!(
"upstream crates may add a new impl of trait `{}`{} \
in future versions",
trait_desc, self_desc
"upstream crates may add a new impl of trait `{trait_desc}`{self_desc} \
in future versions"
)
}
IntercrateAmbiguityCause::ReservationImpl { message } => message.clone(),
@ -2410,8 +2409,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
let guar = self.infcx.tcx.sess.delay_span_bug(
obligation.cause.span,
format!(
"Impl {:?} was matchable against {:?} but now is not",
impl_def_id, obligation
"Impl {impl_def_id:?} was matchable against {obligation:?} but now is not"
),
);
let value = self.infcx.fresh_args_for_item(obligation.cause.span, impl_def_id);

9
compiler/rustc_trait_selection/src/traits/specialize/mod.rs
View file

@ -388,16 +388,16 @@ fn report_conflicting_impls<'tcx>(
impl_span,
format!(
"conflicting implementation{}",
overlap.self_ty.map_or_else(String::new, |ty| format!(" for `{}`", ty))
overlap.self_ty.map_or_else(String::new, |ty| format!(" for `{ty}`"))
),
);
}
Err(cname) => {
let msg = match to_pretty_impl_header(tcx, overlap.with_impl) {
Some(s) => {
format!("conflicting implementation in crate `{}`:\n- {}", cname, s)
format!("conflicting implementation in crate `{cname}`:\n- {s}")
}
None => format!("conflicting implementation in crate `{}`", cname),
None => format!("conflicting implementation in crate `{cname}`"),
};
err.note(msg);
}
@ -514,8 +514,7 @@ pub(crate) fn to_pretty_impl_header(tcx: TyCtxt<'_>, impl_def_id: DefId) -> Opti
pretty_predicates.push(p.to_string());
}
pretty_predicates
.extend(types_without_default_bounds.iter().map(|ty| format!("{}: ?Sized", ty)));
pretty_predicates.extend(types_without_default_bounds.iter().map(|ty| format!("{ty}: ?Sized")));
if !pretty_predicates.is_empty() {
write!(w, "\n where {}", pretty_predicates.join(", ")).unwrap();

4
compiler/rustc_trait_selection/src/traits/util.rs
View file

@ -50,7 +50,7 @@ impl<'tcx> TraitAliasExpansionInfo<'tcx> {
diag.span_label(self.top().1, top_label);
if self.path.len() > 1 {
for (_, sp) in self.path.iter().rev().skip(1).take(self.path.len() - 2) {
diag.span_label(*sp, format!("referenced here ({})", use_desc));
diag.span_label(*sp, format!("referenced here ({use_desc})"));
}
}
if self.top().1 != self.bottom().1 {
@ -58,7 +58,7 @@ impl<'tcx> TraitAliasExpansionInfo<'tcx> {
// redundant labels.
diag.span_label(
self.bottom().1,
format!("trait alias used in trait object type ({})", use_desc),
format!("trait alias used in trait object type ({use_desc})"),
);
}
}

6
compiler/rustc_trait_selection/src/traits/vtable.rs
View file

@ -195,11 +195,7 @@ fn dump_vtable_entries<'tcx>(
trait_ref: ty::PolyTraitRef<'tcx>,
entries: &[VtblEntry<'tcx>],
) {
tcx.sess.emit_err(DumpVTableEntries {
span: sp,
trait_ref,
entries: format!("{:#?}", entries),
});
tcx.sess.emit_err(DumpVTableEntries { span: sp, trait_ref, entries: format!("{entries:#?}") });
}
fn has_own_existential_vtable_entries(tcx: TyCtxt<'_>, trait_def_id: DefId) -> bool {