bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Restrict From<S> for {D,Subd}iagnosticMessage.

Browse source 
Currently a `{D,Subd}iagnosticMessage` can be created from any type that
impls `Into<String>`. That includes `&str`, `String`, and `Cow<'static,
str>`, which are reasonable. It also includes `&String`, which is pretty
weird, and results in many places making unnecessary allocations for
patterns like this:
```
self.fatal(&format!(...))
```
This creates a string with `format!`, takes a reference, passes the
reference to `fatal`, which does an `into()`, which clones the
reference, doing a second allocation. Two allocations for a single
string, bleh.

This commit changes the `From` impls so that you can only create a
`{D,Subd}iagnosticMessage` from `&str`, `String`, or `Cow<'static,
str>`. This requires changing all the places that currently create one
from a `&String`. Most of these are of the `&format!(...)` form
described above; each one removes an unnecessary static `&`, plus an
allocation when executed. There are also a few places where the existing
use of `&String` was more reasonable; these now just use `clone()` at
the call site.

As well as making the code nicer and more efficient, this is a step
towards possibly using `Cow<'static, str>` in
`{D,Subd}iagnosticMessage::{Str,Eager}`. That would require changing
the `From<&'a str>` impls to `From<&'static str>`, which is doable, but
I'm not yet sure if it's worthwhile.
This commit is contained in:
Nicholas Nethercote 2023-04-20 13:26:58 +10:00
parent a368898de7
commit 6b62f37402
177 changed files with 791 additions and 787 deletions
Download patch file Download diff file Expand all files Collapse all files

2
compiler/rustc_resolve/src/build_reduced_graph.rs
View file

@ -1002,7 +1002,7 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
let msg = format!("`{}` is already in scope", name);
let note =
"macro-expanded `#[macro_use]`s may not shadow existing macros (see RFC 1560)";
self.r.tcx.sess.struct_span_err(span, &msg).note(note).emit();
self.r.tcx.sess.struct_span_err(span, msg).note(note).emit();
}
}

2
compiler/rustc_resolve/src/check_unused.rs
View file

@ -418,7 +418,7 @@ impl Resolver<'_, '_> {
UNUSED_IMPORTS,
unused.use_tree_id,
ms,
&msg,
msg,
BuiltinLintDiagnostics::UnusedImports(fix_msg.into(), fixes, test_module_span),
);
}

50
compiler/rustc_resolve/src/diagnostics.rs
View file

@ -238,7 +238,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
},
};
err.note(&format!(
err.note(format!(
"`{}` must be defined only once in the {} namespace of this {}",
name,
ns.descr(),
@ -683,7 +683,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
making the path in the pattern qualified: `path::to::ModOrType::{}`",
name,
);
err.span_help(span, &help_msg);
err.span_help(span, help_msg);
}
show_candidates(
self.tcx,
@ -783,10 +783,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
if let Some((suggestions, msg, applicability)) = suggestion {
if suggestions.is_empty() {
err.help(&msg);
err.help(msg);
return err;
}
err.multipart_suggestion(&msg, suggestions, applicability);
err.multipart_suggestion(msg, suggestions, applicability);
}
err
@ -930,7 +930,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
} => {
let mut err = self.tcx.sess.struct_span_err_with_code(
span,
&format!(
format!(
"item `{}` is an associated {}, which doesn't match its trait `{}`",
name, kind, trait_path,
),
@ -1359,7 +1359,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
if macro_kind == MacroKind::Derive && (ident.name == sym::Send || ident.name == sym::Sync) {
let msg = format!("unsafe traits like `{}` should be implemented explicitly", ident);
err.span_note(ident.span, &msg);
err.span_note(ident.span, msg);
return;
}
if self.macro_names.contains(&ident.normalize_to_macros_2_0()) {
@ -1419,7 +1419,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
if !import.span.is_dummy() {
err.span_note(
import.span,
&format!("`{}` is imported here, but it is {}", ident, desc),
format!("`{}` is imported here, but it is {}", ident, desc),
);
// Silence the 'unused import' warning we might get,
// since this diagnostic already covers that import.
@ -1427,7 +1427,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
return;
}
}
err.note(&format!("`{}` is in scope, but it is {}", ident, desc));
err.note(format!("`{}` is in scope, but it is {}", ident, desc));
return;
}
}
@ -1474,7 +1474,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
err.span_label(
self.tcx.sess.source_map().guess_head_span(def_span),
&format!(
format!(
"{}{} `{}` defined here",
prefix,
suggestion.res.descr(),
@ -1492,7 +1492,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
format!("maybe you meant this {}", suggestion.res.descr())
}
};
err.span_suggestion(span, &msg, suggestion.candidate, Applicability::MaybeIncorrect);
err.span_suggestion(span, msg, suggestion.candidate, Applicability::MaybeIncorrect);
true
}
@ -1534,7 +1534,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
let mut err = struct_span_err!(self.tcx.sess, ident.span, E0659, "`{ident}` is ambiguous");
err.span_label(ident.span, "ambiguous name");
err.note(&format!("ambiguous because of {}", kind.descr()));
err.note(format!("ambiguous because of {}", kind.descr()));
let mut could_refer_to = |b: &NameBinding<'_>, misc: AmbiguityErrorMisc, also: &str| {
let what = self.binding_description(b, ident, misc == AmbiguityErrorMisc::FromPrelude);
@ -1562,10 +1562,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
AmbiguityErrorMisc::FromPrelude | AmbiguityErrorMisc::None => {}
}
err.span_note(b.span, &note_msg);
err.span_note(b.span, note_msg);
for (i, help_msg) in help_msgs.iter().enumerate() {
let or = if i == 0 { "" } else { "or " };
err.help(&format!("{}{}", or, help_msg));
err.help(format!("{}{}", or, help_msg));
}
};
@ -1608,7 +1608,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
let descr = get_descr(binding);
let mut err =
struct_span_err!(self.tcx.sess, ident.span, E0603, "{} `{}` is private", descr, ident);
err.span_label(ident.span, &format!("private {}", descr));
err.span_label(ident.span, format!("private {}", descr));
let mut non_exhaustive = None;
// If an ADT is foreign and marked as `non_exhaustive`, then that's
@ -1623,7 +1623,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
err.span_label(span, "a constructor is private if any of the fields is private");
if let Res::Def(_, d) = res && let Some(fields) = self.field_visibility_spans.get(&d) {
err.multipart_suggestion_verbose(
&format!(
format!(
"consider making the field{} publicly accessible",
pluralize!(fields.len())
),
@ -1676,7 +1676,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
format!("cannot be constructed because it is `#[non_exhaustive]`"),
);
}
err.span_note(note_span, &msg);
err.span_note(note_span, msg);
}
err.emit();
@ -2444,7 +2444,7 @@ fn show_candidates(
};
for note in accessible_path_strings.iter().flat_map(|cand| cand.3.as_ref()) {
err.note(note);
err.note(note.clone());
}
if let Some(span) = use_placement_span {
@ -2452,7 +2452,7 @@ fn show_candidates(
DiagnosticMode::Pattern => {
err.span_suggestions(
span,
&msg,
msg,
accessible_path_strings.into_iter().map(|a| a.0),
Applicability::MaybeIncorrect,
);
@ -2471,7 +2471,7 @@ fn show_candidates(
err.span_suggestions_with_style(
span,
&msg,
msg,
accessible_path_strings.into_iter().map(|a| a.0),
Applicability::MaybeIncorrect,
SuggestionStyle::ShowAlways,
@ -2481,7 +2481,7 @@ fn show_candidates(
if sp.can_be_used_for_suggestions() {
err.span_suggestion_verbose(
sp,
&format!("if you import `{}`, refer to it directly", last.ident),
format!("if you import `{}`, refer to it directly", last.ident),
"",
Applicability::Unspecified,
);
@ -2495,7 +2495,7 @@ fn show_candidates(
msg.push_str(&candidate.0);
}
err.help(&msg);
err.help(msg);
}
} else if !matches!(mode, DiagnosticMode::Import) {
assert!(!inaccessible_path_strings.is_empty());
@ -2520,9 +2520,9 @@ fn show_candidates(
let span = tcx.sess.source_map().guess_head_span(span);
let mut multi_span = MultiSpan::from_span(span);
multi_span.push_span_label(span, "not accessible");
err.span_note(multi_span, &msg);
err.span_note(multi_span, msg);
} else {
err.note(&msg);
err.note(msg);
}
if let Some(note) = (*note).as_deref() {
err.note(note);
@ -2566,10 +2566,10 @@ fn show_candidates(
}
for note in inaccessible_path_strings.iter().flat_map(|cand| cand.3.as_ref()) {
err.note(note);
err.note(note.clone());
}
err.span_note(multi_span, &msg);
err.span_note(multi_span, msg);
}
}
}

2
compiler/rustc_resolve/src/ident.rs
View file

@ -527,7 +527,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
PROC_MACRO_DERIVE_RESOLUTION_FALLBACK,
lint_id,
orig_ident.span,
&format!(
format!(
"cannot find {} `{}` in this scope",
ns.descr(),
ident

14
compiler/rustc_resolve/src/imports.rs
View file

@ -578,7 +578,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
let mut diag = struct_span_err!(self.tcx.sess, span, E0432, "{}", &msg);
if let Some((_, UnresolvedImportError { note: Some(note), .. })) = errors.iter().last() {
diag.note(note);
diag.note(note.clone());
}
for (import, err) in errors.into_iter().take(MAX_LABEL_COUNT) {
@ -588,10 +588,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
if let Some((suggestions, msg, applicability)) = err.suggestion {
if suggestions.is_empty() {
diag.help(&msg);
diag.help(msg);
continue;
}
diag.multipart_suggestion(&msg, suggestions, applicability);
diag.multipart_suggestion(msg, suggestions, applicability);
}
if let Some(candidates) = &err.candidates {
@ -1063,7 +1063,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
PUB_USE_OF_PRIVATE_EXTERN_CRATE,
import_id,
import.span,
&msg,
msg,
);
} else {
let error_msg = if crate_private_reexport {
@ -1084,7 +1084,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
struct_span_err!(self.tcx.sess, import.span, E0365, "{}", error_msg)
.span_label(import.span, label_msg)
.note(&format!("consider declaring type or module `{}` with `pub`", ident))
.note(format!("consider declaring type or module `{}` with `pub`", ident))
.emit();
} else {
let mut err =
@ -1102,7 +1102,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
_ => {
err.span_note(
import.span,
&format!(
format!(
"consider marking `{ident}` as `pub` in the imported module"
),
);
@ -1200,7 +1200,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
UNUSED_IMPORTS,
id,
import.span,
&format!("the item `{}` is imported redundantly", ident),
format!("the item `{}` is imported redundantly", ident),
BuiltinLintDiagnostics::RedundantImport(redundant_spans, ident),
);
}

2
compiler/rustc_resolve/src/late.rs
View file

@ -2198,7 +2198,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
this.r
.tcx
.sess
.span_err(ident.span, &format!("imports cannot refer to {}", what));
.span_err(ident.span, format!("imports cannot refer to {}", what));
}
};

55
compiler/rustc_resolve/src/late/diagnostics.rs
View file

@ -315,8 +315,11 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
debug!(?res, ?source);
let base_error = self.make_base_error(path, span, source, res);
let code = source.error_code(res.is_some());
let mut err =
self.r.tcx.sess.struct_span_err_with_code(base_error.span, &base_error.msg, code);
let mut err = self.r.tcx.sess.struct_span_err_with_code(
base_error.span,
base_error.msg.clone(),
code,
);
self.suggest_swapping_misplaced_self_ty_and_trait(&mut err, source, res, base_error.span);
@ -332,7 +335,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
if self.suggest_pattern_match_with_let(&mut err, source, span) {
// Fallback label.
err.span_label(base_error.span, &base_error.fallback_label);
err.span_label(base_error.span, base_error.fallback_label);
return (err, Vec::new());
}
@ -358,7 +361,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
if fallback {
// Fallback label.
err.span_label(base_error.span, &base_error.fallback_label);
err.span_label(base_error.span, base_error.fallback_label);
}
self.err_code_special_cases(&mut err, source, path, span);
@ -509,7 +512,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
err.span_suggestions(
span,
&msg,
msg,
enum_candidates.into_iter().map(|(_variant_path, enum_ty_path)| enum_ty_path),
Applicability::MachineApplicable,
);
@ -556,7 +559,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
| AssocSuggestion::AssocType => {
err.span_suggestion(
span,
&format!("you might have meant to {}", candidate.action()),
format!("you might have meant to {}", candidate.action()),
format!("Self::{path_str}"),
Applicability::MachineApplicable,
);
@ -577,7 +580,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
err.span_suggestion(
call_span,
&format!("try calling `{ident}` as a method"),
format!("try calling `{ident}` as a method"),
format!("self.{path_str}({args_snippet})"),
Applicability::MachineApplicable,
);
@ -609,7 +612,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
ident.name == path[0].ident.name {
err.span_help(
ident.span,
&format!("the binding `{}` is available in a different scope in the same function", path_str),
format!("the binding `{}` is available in a different scope in the same function", path_str),
);
return (true, candidates);
}
@ -890,7 +893,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
if let Some(ident) = fn_kind.ident() {
err.span_label(
ident.span,
&format!("this function {} have a `self` parameter", doesnt),
format!("this function {} have a `self` parameter", doesnt),
);
}
}
@ -1066,7 +1069,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
if ident.span == span {
err.span_suggestion_verbose(
*where_span,
&format!("constrain the associated type to `{}`", ident),
format!("constrain the associated type to `{}`", ident),
format!(
"{}: {}<{} = {}>",
self.r
@ -1267,7 +1270,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
}
PathSource::Expr(_) | PathSource::TupleStruct(..) | PathSource::Pat => {
let span = find_span(&source, err);
err.span_label(self.r.def_span(def_id), &format!("`{path_str}` defined here"));
err.span_label(self.r.def_span(def_id), format!("`{path_str}` defined here"));
let (tail, descr, applicability, old_fields) = match source {
PathSource::Pat => ("", "pattern", Applicability::MachineApplicable, None),
@ -1311,7 +1314,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
};
err.span_suggestion(
span,
&format!("use struct {} syntax instead", descr),
format!("use struct {} syntax instead", descr),
format!("{path_str} {{{pad}{fields}{pad}}}"),
applicability,
);
@ -1453,7 +1456,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
if non_visible_spans.len() > 0 {
if let Some(fields) = self.r.field_visibility_spans.get(&def_id) {
err.multipart_suggestion_verbose(
&format!(
format!(
"consider making the field{} publicly accessible",
pluralize!(fields.len())
),
@ -1483,7 +1486,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
let span = find_span(&source, err);
err.span_label(
self.r.def_span(def_id),
&format!("`{path_str}` defined here"),
format!("`{path_str}` defined here"),
);
err.span_suggestion(
span,
@ -1497,7 +1500,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
}
(Res::Def(DefKind::Ctor(_, CtorKind::Fn), ctor_def_id), _) if ns == ValueNS => {
let def_id = self.r.tcx.parent(ctor_def_id);
err.span_label(self.r.def_span(def_id), &format!("`{path_str}` defined here"));
err.span_label(self.r.def_span(def_id), format!("`{path_str}` defined here"));
let fields = self.r.field_def_ids(def_id).map_or_else(
|| "/* fields */".to_string(),
|field_ids| vec!["_"; field_ids.len()].join(", "),
@ -1899,7 +1902,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
err.span_suggestions(
span,
&msg,
msg,
suggestable_variants,
Applicability::MaybeIncorrect,
);
@ -1907,17 +1910,17 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
// If the enum has no tuple variants..
if non_suggestable_variant_count == variants.len() {
err.help(&format!("the enum has no tuple variants {}", source_msg));
err.help(format!("the enum has no tuple variants {}", source_msg));
}
// If there are also non-tuple variants..
if non_suggestable_variant_count == 1 {
err.help(&format!(
err.help(format!(
"you might have meant {} the enum's non-tuple variant",
source_msg
));
} else if non_suggestable_variant_count >= 1 {
err.help(&format!(
err.help(format!(
"you might have meant {} one of the enum's non-tuple variants",
source_msg
));
@ -2167,7 +2170,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
lint::builtin::SINGLE_USE_LIFETIMES,
param.id,
param.ident.span,
&format!("lifetime parameter `{}` only used once", param.ident),
format!("lifetime parameter `{}` only used once", param.ident),
lint::BuiltinLintDiagnostics::SingleUseLifetime {
param_span: param.ident.span,
use_span: Some((use_span, elidable)),
@ -2186,7 +2189,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
lint::builtin::UNUSED_LIFETIMES,
param.id,
param.ident.span,
&format!("lifetime parameter `{}` never used", param.ident),
format!("lifetime parameter `{}` never used", param.ident),
lint::BuiltinLintDiagnostics::SingleUseLifetime {
param_span: param.ident.span,
use_span: None,
@ -2252,7 +2255,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
suggest_note = false; // Avoid displaying the same help multiple times.
err.span_label(
span,
&format!(
format!(
"lifetime `{}` is missing in item created through this procedural macro",
name,
),
@ -2458,13 +2461,13 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
)];
}
} else if num_params == 1 {
err.help(&format!(
err.help(format!(
"this function's return type contains a borrowed value, \
but the signature does not say which {} it is borrowed from",
m
));
} else {
err.help(&format!(
err.help(format!(
"this function's return type contains a borrowed value, \
but the signature does not say whether it is borrowed from {}",
m
@ -2533,7 +2536,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
}
1 => {
err.multipart_suggestion_verbose(
&format!("consider using the `{}` lifetime", existing_name),
format!("consider using the `{}` lifetime", existing_name),
spans_suggs,
Applicability::MaybeIncorrect,
);
@ -2584,7 +2587,7 @@ pub(super) fn signal_label_shadowing(sess: &Session, orig: Span, shadower: Ident
let shadower = shadower.span;
let mut err = sess.struct_span_warn(
shadower,
&format!("label name `{}` shadows a label name that is already in scope", name),
format!("label name `{}` shadows a label name that is already in scope", name),
);
err.span_label(orig, "first declared here");
err.span_label(shadower, format!("label `{}` already in scope", name));

22
compiler/rustc_resolve/src/macros.rs
View file

@ -121,7 +121,7 @@ pub(crate) fn registered_tools(tcx: TyCtxt<'_>, (): ()) -> RegisteredTools {
if let Some(old_ident) = registered_tools.replace(ident) {
let msg = format!("{} `{}` was already registered", "tool", ident);
tcx.sess
.struct_span_err(ident.span, &msg)
.struct_span_err(ident.span, msg)
.span_label(old_ident.span, "already registered here")
.emit();
}
@ -130,7 +130,7 @@ pub(crate) fn registered_tools(tcx: TyCtxt<'_>, (): ()) -> RegisteredTools {
let msg = format!("`{}` only accepts identifiers", sym::register_tool);
let span = nested_meta.span();
tcx.sess
.struct_span_err(span, &msg)
.struct_span_err(span, msg)
.span_label(span, "not an identifier")
.emit();
}
@ -202,7 +202,7 @@ impl<'a, 'tcx> ResolverExpand for Resolver<'a, 'tcx> {
self.tcx
.sess
.diagnostic()
.bug(&format!("built-in macro `{}` was already registered", name));
.bug(format!("built-in macro `{}` was already registered", name));
}
}
@ -315,7 +315,7 @@ impl<'a, 'tcx> ResolverExpand for Resolver<'a, 'tcx> {
UNUSED_MACROS,
node_id,
ident.span,
&format!("unused macro definition: `{}`", ident.name),
format!("unused macro definition: `{}`", ident.name),
);
}
for (&(def_id, arm_i), &(ident, rule_span)) in self.unused_macro_rules.iter() {
@ -328,7 +328,7 @@ impl<'a, 'tcx> ResolverExpand for Resolver<'a, 'tcx> {
UNUSED_MACRO_RULES,
node_id,
rule_span,
&format!(
format!(
"{} rule of macro `{}` is never used",
crate::diagnostics::ordinalize(arm_i + 1),
ident.name
@ -698,7 +698,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
Segment::names_to_string(path)
);
let msg_note = "import resolution is stuck, try simplifying macro imports";
this.tcx.sess.struct_span_err(span, &msg).note(msg_note).emit();
this.tcx.sess.struct_span_err(span, msg).note(msg_note).emit();
}
}
};
@ -788,7 +788,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
Err(..) => {
let expected = kind.descr_expected();
let msg = format!("cannot find {} `{}` in this scope", expected, ident);
let mut err = self.tcx.sess.struct_span_err(ident.span, &msg);
let mut err = self.tcx.sess.struct_span_err(ident.span, msg);
self.unresolved_macro_suggestions(&mut err, kind, &parent_scope, ident);
err.emit();
}
@ -866,9 +866,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
if kind != NonMacroAttrKind::Tool && binding.map_or(true, |b| b.is_import()) {
let msg =
format!("cannot use {} {} through an import", kind.article(), kind.descr());
let mut err = self.tcx.sess.struct_span_err(span, &msg);
let mut err = self.tcx.sess.struct_span_err(span, msg);
if let Some(binding) = binding {
err.span_note(binding.span, &format!("the {} imported here", kind.descr()));
err.span_note(binding.span, format!("the {} imported here", kind.descr()));
}
err.emit();
}
@ -883,7 +883,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
if macro_kind.is_some() && sub_namespace_match(macro_kind, Some(MacroKind::Attr)) {
self.tcx.sess.span_err(
ident.span,
&format!("name `{}` is reserved in attribute namespace", ident),
format!("name `{}` is reserved in attribute namespace", ident),
);
}
}
@ -927,7 +927,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
}
} else {
let msg = format!("cannot find a built-in macro with name `{}`", item.ident);
self.tcx.sess.span_err(item.span, &msg);
self.tcx.sess.span_err(item.span, msg);
}
}