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

16
compiler/rustc_infer/src/errors/mod.rs
View file

@ -210,10 +210,8 @@ impl<'a> SourceKindMultiSuggestion<'a> {
_ => ("", ""),
};
let (start_span, start_span_code, end_span) = match should_wrap_expr {
Some(end_span) => {
(data.span(), format!("{}{}{}{{ ", arrow, ty_info, post), Some(end_span))
}
None => (data.span(), format!("{}{}{}", arrow, ty_info, post), None),
Some(end_span) => (data.span(), format!("{arrow}{ty_info}{post}{{ "), Some(end_span)),
None => (data.span(), format!("{arrow}{ty_info}{post}"), None),
};
Self::ClosureReturn { start_span, start_span_code, end_span }
}
@ -404,9 +402,9 @@ impl AddToDiagnostic for AddLifetimeParamsSuggestion<'_> {
debug!(?lifetime_sub.ident.span);
let make_suggestion = |ident: Ident| {
let sugg = if ident.name == kw::Empty {
format!("{}, ", suggestion_param_name)
format!("{suggestion_param_name}, ")
} else if ident.name == kw::UnderscoreLifetime && ident.span.is_empty() {
format!("{} ", suggestion_param_name)
format!("{suggestion_param_name} ")
} else {
suggestion_param_name.clone()
};
@ -419,9 +417,9 @@ impl AddToDiagnostic for AddLifetimeParamsSuggestion<'_> {
let new_param_suggestion = if let Some(first) =
generics.params.iter().find(|p| !p.name.ident().span.is_empty())
{
(first.span.shrink_to_lo(), format!("{}, ", suggestion_param_name))
(first.span.shrink_to_lo(), format!("{suggestion_param_name}, "))
} else {
(generics.span, format!("<{}>", suggestion_param_name))
(generics.span, format!("<{suggestion_param_name}>"))
};
suggestions.push(new_param_suggestion);
@ -1320,7 +1318,7 @@ impl AddToDiagnostic for SuggestTuplePatternMany {
message,
self.compatible_variants.into_iter().map(|variant| {
vec![
(self.cause_span.shrink_to_lo(), format!("{}(", variant)),
(self.cause_span.shrink_to_lo(), format!("{variant}(")),
(self.cause_span.shrink_to_hi(), ")".to_string()),
]
}),

2
compiler/rustc_infer/src/errors/note_and_explain.rs
View file

@ -80,7 +80,7 @@ impl<'a> DescriptionCtx<'a> {
// We shouldn't really be having unification failures with ReVar
// and ReLateBound though.
ty::ReVar(_) | ty::ReLateBound(..) | ty::ReErased => {
(alt_span, "revar", format!("{:?}", region))
(alt_span, "revar", format!("{region:?}"))
}
};
Some(DescriptionCtx { span, kind, arg })

2
compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
View file

@ -205,7 +205,7 @@ impl CanonicalizeMode for CanonicalizeQueryResponse {
// `delay_span_bug` to allow type error over an ICE.
canonicalizer.tcx.sess.delay_span_bug(
rustc_span::DUMMY_SP,
format!("unexpected region in query response: `{:?}`", r),
format!("unexpected region in query response: `{r:?}`"),
);
r
}

2
compiler/rustc_infer/src/infer/combine.rs
View file

@ -177,7 +177,7 @@ impl<'tcx> InferCtxt<'tcx> {
self.tcx.check_tys_might_be_eq(canonical).map_err(|_| {
self.tcx.sess.delay_span_bug(
DUMMY_SP,
format!("cannot relate consts of different types (a={:?}, b={:?})", a, b,),
format!("cannot relate consts of different types (a={a:?}, b={b:?})",),
)
})
});

55
compiler/rustc_infer/src/infer/error_reporting/mod.rs
View file

@ -238,7 +238,7 @@ fn msg_span_from_named_region<'tcx>(
let text = if name == kw::UnderscoreLifetime {
"the anonymous lifetime as defined here".to_string()
} else {
format!("the lifetime `{}` as defined here", name)
format!("the lifetime `{name}` as defined here")
};
(text, Some(span))
}
@ -250,7 +250,7 @@ fn msg_span_from_named_region<'tcx>(
})
),
_ => (
format!("the lifetime `{}` as defined here", region),
format!("the lifetime `{region}` as defined here"),
Some(tcx.def_span(scope)),
),
}
@ -280,7 +280,7 @@ fn emit_msg_span(
span: Option<Span>,
suffix: &str,
) {
let message = format!("{}{}{}", prefix, description, suffix);
let message = format!("{prefix}{description}{suffix}");
if let Some(span) = span {
err.span_note(span, message);
@ -296,7 +296,7 @@ fn label_msg_span(
span: Option<Span>,
suffix: &str,
) {
let message = format!("{}{}{}", prefix, description, suffix);
let message = format!("{prefix}{description}{suffix}");
if let Some(span) = span {
err.span_label(span, message);
@ -333,7 +333,7 @@ pub fn unexpected_hidden_region_diagnostic<'tcx>(
explain_free_region(
tcx,
&mut err,
&format!("hidden type `{}` captures ", hidden_ty),
&format!("hidden type `{hidden_ty}` captures "),
hidden_region,
"",
);
@ -345,7 +345,7 @@ pub fn unexpected_hidden_region_diagnostic<'tcx>(
fn_returns,
hidden_region.to_string(),
None,
format!("captures `{}`", hidden_region),
format!("captures `{hidden_region}`"),
None,
Some(reg_info.def_id),
)
@ -373,7 +373,7 @@ pub fn unexpected_hidden_region_diagnostic<'tcx>(
note_and_explain_region(
tcx,
&mut err,
&format!("hidden type `{}` captures ", hidden_ty),
&format!("hidden type `{hidden_ty}` captures "),
hidden_region,
"",
None,
@ -716,7 +716,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
{
err.span_label(span, format!("this is an iterator with items of type `{}`", args.type_at(0)));
} else {
err.span_label(span, format!("this expression has type `{}`", ty));
err.span_label(span, format!("this expression has type `{ty}`"));
}
}
if let Some(ty::error::ExpectedFound { found, .. }) = exp_found
@ -726,7 +726,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
err.span_suggestion(
span,
"consider dereferencing the boxed value",
format!("*{}", snippet),
format!("*{snippet}"),
Applicability::MachineApplicable,
);
}
@ -785,13 +785,13 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
if prior_arms.len() <= 4 {
for sp in prior_arms {
any_multiline_arm |= source_map.is_multiline(*sp);
err.span_label(*sp, format!("this is found to be of type `{}`", t));
err.span_label(*sp, format!("this is found to be of type `{t}`"));
}
} else if let Some(sp) = prior_arms.last() {
any_multiline_arm |= source_map.is_multiline(*sp);
err.span_label(
*sp,
format!("this and all prior arms are found to be of type `{}`", t),
format!("this and all prior arms are found to be of type `{t}`"),
);
}
let outer = if any_multiline_arm || !source_map.is_multiline(cause.span) {
@ -1661,7 +1661,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
..
})) = values
{
Cow::from(format!("expected this to be `{}`", expected))
Cow::from(format!("expected this to be `{expected}`"))
} else {
terr.to_string(self.tcx)
};
@ -2368,13 +2368,13 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
}
let labeled_user_string = match bound_kind {
GenericKind::Param(ref p) => format!("the parameter type `{}`", p),
GenericKind::Param(ref p) => format!("the parameter type `{p}`"),
GenericKind::Alias(ref p) => match p.kind(self.tcx) {
ty::AliasKind::Projection | ty::AliasKind::Inherent => {
format!("the associated type `{}`", p)
format!("the associated type `{p}`")
}
ty::AliasKind::Weak => format!("the type alias `{}`", p),
ty::AliasKind::Opaque => format!("the opaque type `{}`", p),
ty::AliasKind::Weak => format!("the type alias `{p}`"),
ty::AliasKind::Opaque => format!("the opaque type `{p}`"),
},
};
@ -2388,7 +2388,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
span,
impl_item_def_id,
trait_item_def_id,
&format!("`{}: {}`", bound_kind, sub),
&format!("`{bound_kind}: {sub}`"),
);
}
@ -2402,7 +2402,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
let msg = "consider adding an explicit lifetime bound";
if let Some((sp, has_lifetimes)) = type_param_span {
let suggestion =
if has_lifetimes { format!(" + {}", sub) } else { format!(": {}", sub) };
if has_lifetimes { format!(" + {sub}") } else { format!(": {sub}") };
let mut suggestions = vec![(sp, suggestion)];
for add_lt_sugg in add_lt_suggs.into_iter().flatten() {
suggestions.push(add_lt_sugg);
@ -2413,7 +2413,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
Applicability::MaybeIncorrect, // Issue #41966
);
} else {
let consider = format!("{} `{}: {}`...", msg, bound_kind, sub);
let consider = format!("{msg} `{bound_kind}: {sub}`...");
err.help(consider);
}
}
@ -2422,13 +2422,10 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
|err: &mut Diagnostic, type_param_span: Option<(Span, bool)>| {
let msg = "consider introducing an explicit lifetime bound";
if let Some((sp, has_lifetimes)) = type_param_span {
let suggestion = if has_lifetimes {
format!(" + {}", new_lt)
} else {
format!(": {}", new_lt)
};
let suggestion =
if has_lifetimes { format!(" + {new_lt}") } else { format!(": {new_lt}") };
let mut sugg =
vec![(sp, suggestion), (span.shrink_to_hi(), format!(" + {}", new_lt))];
vec![(sp, suggestion), (span.shrink_to_hi(), format!(" + {new_lt}"))];
for lt in add_lt_suggs.clone().into_iter().flatten() {
sugg.push(lt);
sugg.rotate_right(1);
@ -2508,7 +2505,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
"{} may not live long enough",
labeled_user_string
);
let pred = format!("{}: {}", bound_kind, sub);
let pred = format!("{bound_kind}: {sub}");
let suggestion = format!("{} {}", generics.add_where_or_trailing_comma(), pred,);
err.span_suggestion(
generics.tail_span_for_predicate_suggestion(),
@ -2564,7 +2561,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
note_and_explain_region(
self.tcx,
&mut err,
&format!("{} must be valid for ", labeled_user_string),
&format!("{labeled_user_string} must be valid for "),
sub,
"...",
None,
@ -2814,10 +2811,10 @@ impl<'tcx> InferCtxt<'tcx> {
br_string(br),
self.tcx.associated_item(def_id).name
),
infer::EarlyBoundRegion(_, name) => format!(" for lifetime parameter `{}`", name),
infer::EarlyBoundRegion(_, name) => format!(" for lifetime parameter `{name}`"),
infer::UpvarRegion(ref upvar_id, _) => {
let var_name = self.tcx.hir().name(upvar_id.var_path.hir_id);
format!(" for capture of `{}` by closure", var_name)
format!(" for capture of `{var_name}` by closure")
}
infer::Nll(..) => bug!("NLL variable found in lexical phase"),
};

2
compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs
View file

@ -246,7 +246,7 @@ fn closure_as_fn_str<'tcx>(infcx: &InferCtxt<'tcx>, ty: Ty<'tcx>) -> String {
} else {
format!(" -> {}", ty_to_string(infcx, fn_sig.output().skip_binder(), None))
};
format!("fn({}){}", args, ret)
format!("fn({args}){ret}")
}
impl<'tcx> InferCtxt<'tcx> {

19
compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs
View file

@ -235,10 +235,10 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
}
let arg = match param.param.pat.simple_ident() {
Some(simple_ident) => format!("argument `{}`", simple_ident),
Some(simple_ident) => format!("argument `{simple_ident}`"),
None => "the argument".to_string(),
};
let captures = format!("captures data from {}", arg);
let captures = format!("captures data from {arg}");
suggest_new_region_bound(
tcx,
&mut err,
@ -269,11 +269,11 @@ pub fn suggest_new_region_bound(
// FIXME: account for the need of parens in `&(dyn Trait + '_)`
let consider = "consider changing";
let declare = "to declare that";
let explicit = format!("you can add an explicit `{}` lifetime bound", lifetime_name);
let explicit = format!("you can add an explicit `{lifetime_name}` lifetime bound");
let explicit_static =
arg.map(|arg| format!("explicit `'static` bound to the lifetime of {}", arg));
arg.map(|arg| format!("explicit `'static` bound to the lifetime of {arg}"));
let add_static_bound = "alternatively, add an explicit `'static` bound to this reference";
let plus_lt = format!(" + {}", lifetime_name);
let plus_lt = format!(" + {lifetime_name}");
for fn_return in fn_returns {
if fn_return.span.desugaring_kind().is_some() {
// Skip `async` desugaring `impl Future`.
@ -383,12 +383,7 @@ pub fn suggest_new_region_bound(
if let LifetimeName::ImplicitObjectLifetimeDefault = lt.res {
err.span_suggestion_verbose(
fn_return.span.shrink_to_hi(),
format!(
"{declare} the trait object {captures}, {explicit}",
declare = declare,
captures = captures,
explicit = explicit,
),
format!("{declare} the trait object {captures}, {explicit}",),
&plus_lt,
Applicability::MaybeIncorrect,
);
@ -400,7 +395,7 @@ pub fn suggest_new_region_bound(
if let Some(explicit_static) = &explicit_static {
err.span_suggestion_verbose(
lt.ident.span,
format!("{} the trait object's {}", consider, explicit_static),
format!("{consider} the trait object's {explicit_static}"),
&lifetime_name,
Applicability::MaybeIncorrect,
);

4
compiler/rustc_infer/src/infer/error_reporting/note.rs
View file

@ -227,7 +227,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
span,
impl_item_def_id,
trait_item_def_id,
&format!("`{}: {}`", sup, sub),
&format!("`{sup}: {sub}`"),
);
// We should only suggest rewriting the `where` clause if the predicate is within that `where` clause
if let Some(generics) = self.tcx.hir().get_generics(impl_item_def_id)
@ -251,7 +251,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
let item_name = self.tcx.item_name(impl_item_def_id.to_def_id());
err.span_label(
trait_item_span,
format!("definition of `{}` from trait", item_name),
format!("definition of `{item_name}` from trait"),
);
}

9
compiler/rustc_infer/src/infer/error_reporting/note_and_explain.rs
View file

@ -47,7 +47,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
diag.span_suggestion(
sp,
"use a float literal",
format!("{}.0", snippet),
format!("{snippet}.0"),
MachineApplicable,
);
}
@ -134,7 +134,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
if matched_end_of_args {
// Append suggestion to the end of our args
let path = format!(", {}{} = {}",item_name, item_args, p);
let path = format!(", {item_name}{item_args} = {p}");
note = !suggest_constraining_type_param(
tcx,
generics,
@ -148,7 +148,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
// Suggest adding a bound to an existing trait
// or if the trait doesn't exist, add the trait
// and the suggested bounds.
let path = format!("<{}{} = {}>", item_name, item_args, p);
let path = format!("<{item_name}{item_args} = {p}>");
note = !suggest_constraining_type_param(
tcx,
generics,
@ -213,8 +213,7 @@ impl<T> Trait<T> for X {
}
diag.help(format!(
"every closure has a distinct type and so could not always match the \
caller-chosen type of parameter `{}`",
p
caller-chosen type of parameter `{p}`"
));
}
(ty::Param(p), _) | (_, ty::Param(p)) => {

4
compiler/rustc_infer/src/infer/error_reporting/suggest.rs
View file

@ -575,12 +575,12 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
if param_hir.pat.span == param_hir.ty_span {
// for `|x|`, `|_|`, `|x: impl Foo|`
let Ok(pat) = self.tcx.sess.source_map().span_to_snippet(param_hir.pat.span) else { return; };
suggestion += &format!("{}: &_", pat);
suggestion += &format!("{pat}: &_");
} else {
// for `|x: ty|`, `|_: ty|`
let Ok(pat) = self.tcx.sess.source_map().span_to_snippet(param_hir.pat.span) else { return; };
let Ok(ty) = self.tcx.sess.source_map().span_to_snippet(param_hir.ty_span) else { return; };
suggestion += &format!("{}: &{}", pat, ty);
suggestion += &format!("{pat}: &{ty}");
}
has_suggestion = true;
} else {

5
compiler/rustc_infer/src/infer/lexical_region_resolve/mod.rs
View file

@ -837,9 +837,8 @@ impl<'cx, 'tcx> LexicalResolver<'cx, 'tcx> {
self.var_infos[node_idx].origin.span(),
format!(
"collect_error_for_expanding_node() could not find \
error for var {:?} in universe {:?}, lower_bounds={:#?}, \
upper_bounds={:#?}",
node_idx, node_universe, lower_bounds, upper_bounds
error for var {node_idx:?} in universe {node_universe:?}, lower_bounds={lower_bounds:#?}, \
upper_bounds={upper_bounds:#?}"
),
);
}

2
compiler/rustc_infer/src/infer/nll_relate/mod.rs
View file

@ -557,7 +557,7 @@ where
// Forbid inference variables in the RHS.
self.infcx.tcx.sess.delay_span_bug(
self.delegate.span(),
format!("unexpected inference var {:?}", b,),
format!("unexpected inference var {b:?}",),
);
Ok(a)
}

2
compiler/rustc_infer/src/infer/outlives/obligations.rs
View file

@ -253,7 +253,7 @@ where
// this point it never will be
self.tcx.sess.delay_span_bug(
origin.span(),
format!("unresolved inference variable in outlives: {:?}", v),
format!("unresolved inference variable in outlives: {v:?}"),
);
}
}

2
compiler/rustc_infer/src/infer/outlives/verify.rs
View file

@ -179,7 +179,7 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
// this point it never will be
self.tcx.sess.delay_span_bug(
rustc_span::DUMMY_SP,
format!("unresolved inference variable in outlives: {:?}", v),
format!("unresolved inference variable in outlives: {v:?}"),
);
// add a bound that never holds
VerifyBound::AnyBound(vec![])

8
compiler/rustc_infer/src/infer/region_constraints/mod.rs
View file

@ -704,8 +704,8 @@ impl fmt::Debug for RegionSnapshot {
impl<'tcx> fmt::Debug for GenericKind<'tcx> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
GenericKind::Param(ref p) => write!(f, "{:?}", p),
GenericKind::Alias(ref p) => write!(f, "{:?}", p),
GenericKind::Param(ref p) => write!(f, "{p:?}"),
GenericKind::Alias(ref p) => write!(f, "{p:?}"),
}
}
}
@ -713,8 +713,8 @@ impl<'tcx> fmt::Debug for GenericKind<'tcx> {
impl<'tcx> fmt::Display for GenericKind<'tcx> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
GenericKind::Param(ref p) => write!(f, "{}", p),
GenericKind::Alias(ref p) => write!(f, "{}", p),
GenericKind::Param(ref p) => write!(f, "{p}"),
GenericKind::Alias(ref p) => write!(f, "{p}"),
}
}
}

6
compiler/rustc_infer/src/traits/error_reporting/mod.rs
View file

@ -28,11 +28,11 @@ impl<'tcx> InferCtxt<'tcx> {
if !self.tcx.is_impl_trait_in_trait(trait_item_def_id) {
if let Some(span) = self.tcx.hir().span_if_local(trait_item_def_id) {
let item_name = self.tcx.item_name(impl_item_def_id.to_def_id());
err.span_label(span, format!("definition of `{}` from trait", item_name));
err.span_label(span, format!("definition of `{item_name}` from trait"));
}
}
err.span_label(error_span, format!("impl has extra requirement {}", requirement));
err.span_label(error_span, format!("impl has extra requirement {requirement}"));
err
}
@ -56,7 +56,7 @@ pub fn report_object_safety_error<'tcx>(
"the trait `{}` cannot be made into an object",
trait_str
);
err.span_label(span, format!("`{}` cannot be made into an object", trait_str));
err.span_label(span, format!("`{trait_str}` cannot be made into an object"));
let mut reported_violations = FxIndexSet::default();
let mut multi_span = vec![];

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

@ -190,7 +190,7 @@ impl<'tcx> ProjectionCache<'_, 'tcx> {
}
let fresh_key =
map.insert(key, ProjectionCacheEntry::NormalizedTy { ty: value, complete: None });
assert!(!fresh_key, "never started projecting `{:?}`", key);
assert!(!fresh_key, "never started projecting `{key:?}`");
}
/// Mark the relevant projection cache key as having its derived obligations
@ -229,7 +229,7 @@ impl<'tcx> ProjectionCache<'_, 'tcx> {
/// be different).
pub fn ambiguous(&mut self, key: ProjectionCacheKey<'tcx>) {
let fresh = self.map().insert(key, ProjectionCacheEntry::Ambiguous);
assert!(!fresh, "never started projecting `{:?}`", key);
assert!(!fresh, "never started projecting `{key:?}`");
}
/// Indicates that while trying to normalize `key`, `key` was required to
@ -237,14 +237,14 @@ impl<'tcx> ProjectionCache<'_, 'tcx> {
/// an error here.
pub fn recur(&mut self, key: ProjectionCacheKey<'tcx>) {
let fresh = self.map().insert(key, ProjectionCacheEntry::Recur);
assert!(!fresh, "never started projecting `{:?}`", key);
assert!(!fresh, "never started projecting `{key:?}`");
}
/// Indicates that trying to normalize `key` resulted in
/// error.
pub fn error(&mut self, key: ProjectionCacheKey<'tcx>) {
let fresh = self.map().insert(key, ProjectionCacheEntry::Error);
assert!(!fresh, "never started projecting `{:?}`", key);
assert!(!fresh, "never started projecting `{key:?}`");
}
}

10
compiler/rustc_infer/src/traits/structural_impls.rs
View file

@ -38,17 +38,17 @@ impl<'tcx> fmt::Debug for traits::FulfillmentError<'tcx> {
impl<'tcx> fmt::Debug for traits::FulfillmentErrorCode<'tcx> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
super::CodeSelectionError(ref e) => write!(f, "{:?}", e),
super::CodeProjectionError(ref e) => write!(f, "{:?}", e),
super::CodeSelectionError(ref e) => write!(f, "{e:?}"),
super::CodeProjectionError(ref e) => write!(f, "{e:?}"),
super::CodeSubtypeError(ref a, ref b) => {
write!(f, "CodeSubtypeError({:?}, {:?})", a, b)
write!(f, "CodeSubtypeError({a:?}, {b:?})")
}
super::CodeConstEquateError(ref a, ref b) => {
write!(f, "CodeConstEquateError({:?}, {:?})", a, b)
write!(f, "CodeConstEquateError({a:?}, {b:?})")
}
super::CodeAmbiguity { overflow: false } => write!(f, "Ambiguity"),
super::CodeAmbiguity { overflow: true } => write!(f, "Overflow"),
super::CodeCycle(ref cycle) => write!(f, "Cycle({:?})", cycle),
super::CodeCycle(ref cycle) => write!(f, "Cycle({cycle:?})"),
}
}
}