languages/rust
languages/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust synced 2024-07-08 22:42:25 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Rename consuming chaining methods on DiagnosticBuilder.

Browse Source 
In #119606 I added them and used a `_mv` suffix, but that wasn't great.

A `with_` prefix has three different existing uses.
- Constructors, e.g. `Vec::with_capacity`.
- Wrappers that provide an environment to execute some code, e.g.
  `with_session_globals`.
- Consuming chaining methods, e.g. `Span::with_{lo,hi,ctxt}`.

The third case is exactly what we want, so this commit changes
`DiagnosticBuilder::foo_mv` to `DiagnosticBuilder::with_foo`.

Thanks to @compiler-errors for the suggestion.
This commit is contained in:
Nicholas Nethercote 2024-01-09 09:08:49 +11:00
parent 2ea7a37e11
commit ed76b0b882
76 changed files with 296 additions and 293 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
compiler/rustc_ast_passes/src/feature_gate.rs
View File

@ -23,7 +23,7 @@ macro_rules! gate {
($visitor:expr, $feature:ident, $span:expr, $explain:expr, $help:expr) => {{
if !$visitor.features.$feature && !$span.allows_unstable(sym::$feature) {
feature_err(&$visitor.sess.parse_sess, sym::$feature, $span, $explain)
.help_mv($help)
.with_help($help)
.emit();
}
}};

10
compiler/rustc_attr/src/session_diagnostics.rs
View File

@ -55,11 +55,11 @@ impl<'a, G: EmissionGuarantee> IntoDiagnostic<'a, G> for UnknownMetaItem<'_> {
fn into_diagnostic(self, dcx: &'a DiagCtxt, level: Level) -> DiagnosticBuilder<'a, G> {
let expected = self.expected.iter().map(|name| format!("`{name}`")).collect::<Vec<_>>();
DiagnosticBuilder::new(dcx, level, fluent::attr_unknown_meta_item)
.span_mv(self.span)
.code_mv(error_code!(E0541))
.arg_mv("item", self.item)
.arg_mv("expected", expected.join(", "))
.span_label_mv(self.span, fluent::attr_label)
.with_span(self.span)
.with_code(error_code!(E0541))
.with_arg("item", self.item)
.with_arg("expected", expected.join(", "))
.with_span_label(self.span, fluent::attr_label)
}
}

24
compiler/rustc_borrowck/src/borrowck_errors.rs
View File

@ -38,8 +38,8 @@ pub(crate) fn cannot_use_when_mutably_borrowed(
"cannot use {} because it was mutably borrowed",
desc,
)
.span_label_mv(borrow_span, format!("{borrow_desc} is borrowed here"))
.span_label_mv(span, format!("use of borrowed {borrow_desc}"))
.with_span_label(borrow_span, format!("{borrow_desc} is borrowed here"))
.with_span_label(span, format!("use of borrowed {borrow_desc}"))
}
pub(crate) fn cannot_mutably_borrow_multiply(
@ -243,8 +243,8 @@ pub(crate) fn cannot_assign_to_borrowed(
"cannot assign to {} because it is borrowed",
desc,
)
.span_label_mv(borrow_span, format!("{desc} is borrowed here"))
.span_label_mv(span, format!("{desc} is assigned to here but it was already borrowed"))
.with_span_label(borrow_span, format!("{desc} is borrowed here"))
.with_span_label(span, format!("{desc} is assigned to here but it was already borrowed"))
}
pub(crate) fn cannot_reassign_immutable(
@ -297,7 +297,7 @@ pub(crate) fn cannot_move_out_of_interior_noncopy(
ty,
type_name,
)
.span_label_mv(move_from_span, "cannot move out of here")
.with_span_label(move_from_span, "cannot move out of here")
}
pub(crate) fn cannot_move_out_of_interior_of_drop(
@ -312,7 +312,7 @@ pub(crate) fn cannot_move_out_of_interior_of_drop(
"cannot move out of type `{}`, which implements the `Drop` trait",
container_ty,
)
.span_label_mv(move_from_span, "cannot move out of here")
.with_span_label(move_from_span, "cannot move out of here")
}
pub(crate) fn cannot_act_on_moved_value(
@ -368,8 +368,8 @@ pub(crate) fn cannot_mutate_in_immutable_section(
immutable_place,
immutable_section,
)
.span_label_mv(mutate_span, format!("cannot {action}"))
.span_label_mv(immutable_span, format!("value is immutable in {immutable_section}"))
.with_span_label(mutate_span, format!("cannot {action}"))
.with_span_label(immutable_span, format!("value is immutable in {immutable_section}"))
}
pub(crate) fn cannot_borrow_across_coroutine_yield(
@ -384,7 +384,7 @@ pub(crate) fn cannot_borrow_across_coroutine_yield(
E0626,
"borrow may still be in use when {coroutine_kind:#} yields",
)
.span_label_mv(yield_span, "possible yield occurs here")
.with_span_label(yield_span, "possible yield occurs here")
}
pub(crate) fn cannot_borrow_across_destructor(
@ -423,7 +423,7 @@ pub(crate) fn cannot_return_reference_to_local(
REFERENCE = reference_desc,
LOCAL = path_desc,
)
.span_label_mv(
.with_span_label(
span,
format!("{return_kind}s a {reference_desc} data owned by the current function"),
)
@ -444,8 +444,8 @@ pub(crate) fn cannot_capture_in_long_lived_closure(
"{closure_kind} may outlive the current {scope}, but it borrows {borrowed_path}, \
which is owned by the current {scope}",
)
.span_label_mv(capture_span, format!("{borrowed_path} is borrowed here"))
.span_label_mv(closure_span, format!("may outlive borrowed value {borrowed_path}"))
.with_span_label(capture_span, format!("{borrowed_path} is borrowed here"))
.with_span_label(closure_span, format!("may outlive borrowed value {borrowed_path}"))
}
pub(crate) fn thread_local_value_does_not_live_long_enough(

4
compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
View File

@ -2225,11 +2225,11 @@ fn report_thread_local_value_does_not_live_long_enough(
);
self.thread_local_value_does_not_live_long_enough(borrow_span)
.span_label_mv(
.with_span_label(
borrow_span,
"thread-local variables cannot be borrowed beyond the end of the function",
)
.span_label_mv(drop_span, "end of enclosing function is here")
.with_span_label(drop_span, "end of enclosing function is here")
}
#[instrument(level = "debug", skip(self))]

8
compiler/rustc_borrowck/src/diagnostics/move_errors.rs
View File

@ -334,9 +334,9 @@ fn report_cannot_move_from_borrowed_content(
span,
&format!("`{}` in pattern guard", self.local_names[local].unwrap()),
)
.note_mv(
.with_note(
"variables bound in patterns cannot be moved from \
until after the end of the pattern guard",
until after the end of the pattern guard",
);
} else if decl.is_ref_to_static() {
return self.report_cannot_move_from_static(move_place, span);
@ -382,8 +382,8 @@ fn report_cannot_move_from_borrowed_content(
);
self.cannot_move_out_of(span, &place_description)
.span_label_mv(upvar_span, "captured outer variable")
.span_label_mv(
.with_span_label(upvar_span, "captured outer variable")
.with_span_label(
self.infcx.tcx.def_span(def_id),
format!("captured by this `{closure_kind}` closure"),
)

2
compiler/rustc_borrowck/src/region_infer/opaque_types.rs
View File

@ -421,7 +421,7 @@ fn check_opaque_type_parameter_valid(
return Err(tcx
.dcx()
.struct_span_err(span, "non-defining opaque type use in defining scope")
.span_note_mv(spans, format!("{descr} used multiple times"))
.with_span_note(spans, format!("{descr} used multiple times"))
.emit());
}
}

4
compiler/rustc_builtin_macros/src/asm.rs
View File

@ -695,8 +695,8 @@ fn expand_preparsed_asm(ecx: &mut ExtCtxt<'_>, args: AsmArgs) -> Option<ast::Inl
let (sp, msg) = unused_operands.into_iter().next().unwrap();
ecx.dcx()
.struct_span_err(sp, msg)
.span_label_mv(sp, msg)
.help_mv(format!(
.with_span_label(sp, msg)
.with_help(format!(
"if this argument is intentionally unused, \
consider using it in an asm comment: `\"/*{help_str} */\"`"
))

6
compiler/rustc_builtin_macros/src/errors.rs
View File

@ -817,9 +817,9 @@ fn into_diagnostic(self, dcx: &'a DiagCtxt, level: Level) -> DiagnosticBuilder<'
level,
crate::fluent_generated::builtin_macros_asm_clobber_no_reg,
)
.span_mv(self.spans.clone())
.span_labels_mv(self.clobbers, &lbl1)
.span_labels_mv(self.spans, &lbl2)
.with_span(self.spans.clone())
.with_span_labels(self.clobbers, &lbl1)
.with_span_labels(self.spans, &lbl2)
}
}

2
compiler/rustc_builtin_macros/src/proc_macro_harness.rs
View File

@ -194,7 +194,7 @@ fn visit_item(&mut self, item: &'a ast::Item) {
self.dcx
.struct_span_err(attr.span, msg)
.span_label_mv(prev_attr.span, "previous attribute here")
.with_span_label(prev_attr.span, "previous attribute here")
.emit();
return;

6
compiler/rustc_builtin_macros/src/test.rs
View File

@ -409,8 +409,8 @@ fn not_testable_error(cx: &ExtCtxt<'_>, attr_sp: Span, item: Option<&ast::Item>)
),
);
}
err.span_label_mv(attr_sp, "the `#[test]` macro causes a function to be run as a test and has no effect on non-functions")
.span_suggestion_mv(attr_sp,
err.with_span_label(attr_sp, "the `#[test]` macro causes a function to be run as a test and has no effect on non-functions")
.with_span_suggestion(attr_sp,
"replace with conditional compilation to make the item only exist when tests are being run",
"#[cfg(test)]",
Applicability::MaybeIncorrect)
@ -480,7 +480,7 @@ fn should_panic(cx: &ExtCtxt<'_>, i: &ast::Item) -> ShouldPanic {
"argument must be of the form: \
`expected = \"error message\"`",
)
.note_mv(
.with_note(
"errors in this attribute were erroneously \
allowed and will become a hard error in a \
future release",

6
compiler/rustc_codegen_llvm/src/errors.rs
View File

@ -106,7 +106,7 @@ fn into_diagnostic(self, dcx: &'_ DiagCtxt, level: Level) -> DiagnosticBuilder<'
let message = dcx.eagerly_translate_to_string(message.clone(), diag.args());
DiagnosticBuilder::new(dcx, level, fluent::codegen_llvm_parse_target_machine_config)
.arg_mv("error", message)
.with_arg("error", message)
}
}
@ -204,8 +204,8 @@ fn into_diagnostic(self, dcx: &'_ DiagCtxt, level: Level) -> DiagnosticBuilder<'
};
self.0
.into_diagnostic(dcx, level)
.primary_message_mv(msg_with_llvm_err)
.arg_mv("llvm_err", self.1)
.with_primary_message(msg_with_llvm_err)
.with_arg("llvm_err", self.1)
}
}

6
compiler/rustc_codegen_ssa/src/codegen_attrs.rs
View File

@ -309,7 +309,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
attr.span,
"`#[target_feature(..)]` can only be applied to `unsafe` functions",
)
.span_label_mv(tcx.def_span(did), "not an `unsafe` function")
.with_span_label(tcx.def_span(did), "not an `unsafe` function")
.emit();
} else {
check_target_feature_trait_unsafe(tcx, did, attr.span);
@ -478,7 +478,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
InlineAttr::Never
} else {
struct_span_code_err!(tcx.dcx(), items[0].span(), E0535, "invalid argument")
.help_mv("valid inline arguments are `always` and `never`")
.with_help("valid inline arguments are `always` and `never`")
.emit();
InlineAttr::None
@ -663,7 +663,7 @@ fn check_link_ordinal(tcx: TyCtxt<'_>, attr: &ast::Attribute) -> Option<u16> {
let msg = format!("ordinal value in `link_ordinal` is too large: `{}`", &ordinal);
tcx.dcx()
.struct_span_err(attr.span, msg)
.note_mv("the value may not exceed `u16::MAX`")
.with_note("the value may not exceed `u16::MAX`")
.emit();
None
}

53
compiler/rustc_codegen_ssa/src/errors.rs
View File

@ -230,25 +230,25 @@ fn into_diagnostic(self, dcx: &DiagCtxt, level: Level) -> DiagnosticBuilder<'_,
thorin::Error::DecompressData(_) => build(fluent::codegen_ssa_thorin_decompress_data),
thorin::Error::NamelessSection(_, offset) => {
build(fluent::codegen_ssa_thorin_section_without_name)
.arg_mv("offset", format!("0x{offset:08x}"))
.with_arg("offset", format!("0x{offset:08x}"))
}
thorin::Error::RelocationWithInvalidSymbol(section, offset) => {
build(fluent::codegen_ssa_thorin_relocation_with_invalid_symbol)
.arg_mv("section", section)
.arg_mv("offset", format!("0x{offset:08x}"))
.with_arg("section", section)
.with_arg("offset", format!("0x{offset:08x}"))
}
thorin::Error::MultipleRelocations(section, offset) => {
build(fluent::codegen_ssa_thorin_multiple_relocations)
.arg_mv("section", section)
.arg_mv("offset", format!("0x{offset:08x}"))
.with_arg("section", section)
.with_arg("offset", format!("0x{offset:08x}"))
}
thorin::Error::UnsupportedRelocation(section, offset) => {
build(fluent::codegen_ssa_thorin_unsupported_relocation)
.arg_mv("section", section)
.arg_mv("offset", format!("0x{offset:08x}"))
.with_arg("section", section)
.with_arg("offset", format!("0x{offset:08x}"))
}
thorin::Error::MissingDwoName(id) => build(fluent::codegen_ssa_thorin_missing_dwo_name)
.arg_mv("id", format!("0x{id:08x}")),
.with_arg("id", format!("0x{id:08x}")),
thorin::Error::NoCompilationUnits => {
build(fluent::codegen_ssa_thorin_no_compilation_units)
}
@ -258,7 +258,7 @@ fn into_diagnostic(self, dcx: &DiagCtxt, level: Level) -> DiagnosticBuilder<'_,
}
thorin::Error::MissingRequiredSection(section) => {
build(fluent::codegen_ssa_thorin_missing_required_section)
.arg_mv("section", section)
.with_arg("section", section)
}
thorin::Error::ParseUnitAbbreviations(_) => {
build(fluent::codegen_ssa_thorin_parse_unit_abbreviations)
@ -272,31 +272,30 @@ fn into_diagnostic(self, dcx: &DiagCtxt, level: Level) -> DiagnosticBuilder<'_,
thorin::Error::ParseUnit(_) => build(fluent::codegen_ssa_thorin_parse_unit),
thorin::Error::IncompatibleIndexVersion(section, format, actual) => {
build(fluent::codegen_ssa_thorin_incompatible_index_version)
.arg_mv("section", section)
.arg_mv("actual", actual)
.arg_mv("format", format)
.with_arg("section", section)
.with_arg("actual", actual)
.with_arg("format", format)
}
thorin::Error::OffsetAtIndex(_, index) => {
build(fluent::codegen_ssa_thorin_offset_at_index).arg_mv("index", index)
build(fluent::codegen_ssa_thorin_offset_at_index).with_arg("index", index)
}
thorin::Error::StrAtOffset(_, offset) => {
build(fluent::codegen_ssa_thorin_str_at_offset)
.arg_mv("offset", format!("0x{offset:08x}"))
.with_arg("offset", format!("0x{offset:08x}"))
}
thorin::Error::ParseIndex(_, section) => {
build(fluent::codegen_ssa_thorin_parse_index).arg_mv("section", section)
build(fluent::codegen_ssa_thorin_parse_index).with_arg("section", section)
}
thorin::Error::UnitNotInIndex(unit) => {
build(fluent::codegen_ssa_thorin_unit_not_in_index)
.arg_mv("unit", format!("0x{unit:08x}"))
.with_arg("unit", format!("0x{unit:08x}"))
}
thorin::Error::RowNotInIndex(_, row) => {
build(fluent::codegen_ssa_thorin_row_not_in_index).arg_mv("row", row)
build(fluent::codegen_ssa_thorin_row_not_in_index).with_arg("row", row)
}
thorin::Error::SectionNotInRow => build(fluent::codegen_ssa_thorin_section_not_in_row),
thorin::Error::EmptyUnit(unit) => {
build(fluent::codegen_ssa_thorin_empty_unit).arg_mv("unit", format!("0x{unit:08x}"))
}
thorin::Error::EmptyUnit(unit) => build(fluent::codegen_ssa_thorin_empty_unit)
.with_arg("unit", format!("0x{unit:08x}")),
thorin::Error::MultipleDebugInfoSection => {
build(fluent::codegen_ssa_thorin_multiple_debug_info_section)
}
@ -305,10 +304,10 @@ fn into_diagnostic(self, dcx: &DiagCtxt, level: Level) -> DiagnosticBuilder<'_,
}
thorin::Error::NotSplitUnit => build(fluent::codegen_ssa_thorin_not_split_unit),
thorin::Error::DuplicateUnit(unit) => build(fluent::codegen_ssa_thorin_duplicate_unit)
.arg_mv("unit", format!("0x{unit:08x}")),
.with_arg("unit", format!("0x{unit:08x}")),
thorin::Error::MissingReferencedUnit(unit) => {
build(fluent::codegen_ssa_thorin_missing_referenced_unit)
.arg_mv("unit", format!("0x{unit:08x}"))
.with_arg("unit", format!("0x{unit:08x}"))
}
thorin::Error::NoOutputObjectCreated => {
build(fluent::codegen_ssa_thorin_not_output_object_created)
@ -317,19 +316,19 @@ fn into_diagnostic(self, dcx: &DiagCtxt, level: Level) -> DiagnosticBuilder<'_,
build(fluent::codegen_ssa_thorin_mixed_input_encodings)
}
thorin::Error::Io(e) => {
build(fluent::codegen_ssa_thorin_io).arg_mv("error", format!("{e}"))
build(fluent::codegen_ssa_thorin_io).with_arg("error", format!("{e}"))
}
thorin::Error::ObjectRead(e) => {
build(fluent::codegen_ssa_thorin_object_read).arg_mv("error", format!("{e}"))
build(fluent::codegen_ssa_thorin_object_read).with_arg("error", format!("{e}"))
}
thorin::Error::ObjectWrite(e) => {
build(fluent::codegen_ssa_thorin_object_write).arg_mv("error", format!("{e}"))
build(fluent::codegen_ssa_thorin_object_write).with_arg("error", format!("{e}"))
}
thorin::Error::GimliRead(e) => {
build(fluent::codegen_ssa_thorin_gimli_read).arg_mv("error", format!("{e}"))
build(fluent::codegen_ssa_thorin_gimli_read).with_arg("error", format!("{e}"))
}
thorin::Error::GimliWrite(e) => {
build(fluent::codegen_ssa_thorin_gimli_write).arg_mv("error", format!("{e}"))
build(fluent::codegen_ssa_thorin_gimli_write).with_arg("error", format!("{e}"))
}
_ => unimplemented!("Untranslated thorin error"),
}

2
compiler/rustc_codegen_ssa/src/target_features.rs
View File

@ -27,7 +27,7 @@ pub fn from_target_feature(
let code = "enable = \"..\"";
tcx.dcx()
.struct_span_err(span, msg)
.span_suggestion_mv(span, "must be of the form", code, Applicability::HasPlaceholders)
.with_span_suggestion(span, "must be of the form", code, Applicability::HasPlaceholders)
.emit();
};
let rust_features = tcx.features();

84
compiler/rustc_errors/src/diagnostic_builder.rs
View File

@ -30,7 +30,7 @@ impl<'a, T, G> IntoDiagnostic<'a, G> for Spanned<T>
G: EmissionGuarantee,
{
fn into_diagnostic(self, dcx: &'a DiagCtxt, level: Level) -> DiagnosticBuilder<'a, G> {
self.node.into_diagnostic(dcx, level).span_mv(self.span)
self.node.into_diagnostic(dcx, level).with_span(self.span)
}
}
@ -173,26 +173,26 @@ fn emit_producing_guarantee(db: DiagnosticBuilder<'_, Self>) -> Self::EmitResult
/// `Diagnostic` method. It is mostly to modify existing diagnostics, either
/// in a standalone fashion, e.g. `err.code(code)`, or in a chained fashion
/// to make multiple modifications, e.g. `err.code(code).span(span)`.
/// - A `self -> Self` method, with `_mv` suffix added (short for "move").
/// - A `self -> Self` method, which has a `with_` prefix added.
/// It is mostly used in a chained fashion when producing a new diagnostic,
/// e.g. `let err = struct_err(msg).code_mv(code)`, or when emitting a new
/// diagnostic , e.g. `struct_err(msg).code_mv(code).emit()`.
/// e.g. `let err = struct_err(msg).with_code(code)`, or when emitting a new
/// diagnostic , e.g. `struct_err(msg).with_code(code).emit()`.
///
/// Although the latter method can be used to modify an existing diagnostic,
/// e.g. `err = err.code_mv(code)`, this should be avoided because the former
/// method give shorter code, e.g. `err.code(code)`.
/// e.g. `err = err.with_code(code)`, this should be avoided because the former
/// method gives shorter code, e.g. `err.code(code)`.
macro_rules! forward {
(
($n:ident, $n_mv:ident)($($name:ident: $ty:ty),* $(,)?)
($f:ident, $with_f:ident)($($name:ident: $ty:ty),* $(,)?)
) => {
#[doc = concat!("See [`Diagnostic::", stringify!($n), "()`].")]
pub fn $n(&mut self, $($name: $ty),*) -> &mut Self {
self.diag.as_mut().unwrap().$n($($name),*);
#[doc = concat!("See [`Diagnostic::", stringify!($f), "()`].")]
pub fn $f(&mut self, $($name: $ty),*) -> &mut Self {
self.diag.as_mut().unwrap().$f($($name),*);
self
}
#[doc = concat!("See [`Diagnostic::", stringify!($n), "()`].")]
pub fn $n_mv(mut self, $($name: $ty),*) -> Self {
self.diag.as_mut().unwrap().$n($($name),*);
#[doc = concat!("See [`Diagnostic::", stringify!($f), "()`].")]
pub fn $with_f(mut self, $($name: $ty),*) -> Self {
self.diag.as_mut().unwrap().$f($($name),*);
self
}
};
@ -302,21 +302,21 @@ pub fn delay_as_bug(mut self) -> G::EmitResult {
self.emit()
}
forward!((span_label, span_label_mv)(
forward!((span_label, with_span_label)(
span: Span,
label: impl Into<SubdiagnosticMessage>,
));
forward!((span_labels, span_labels_mv)(
forward!((span_labels, with_span_labels)(
spans: impl IntoIterator<Item = Span>,
label: &str,
));
forward!((note_expected_found, note_expected_found_mv)(
forward!((note_expected_found, with_note_expected_found)(
expected_label: &dyn fmt::Display,
expected: DiagnosticStyledString,
found_label: &dyn fmt::Display,
found: DiagnosticStyledString,
));
forward!((note_expected_found_extra, note_expected_found_extra_mv)(
forward!((note_expected_found_extra, with_note_expected_found_extra)(
expected_label: &dyn fmt::Display,
expected: DiagnosticStyledString,
found_label: &dyn fmt::Display,
@ -324,106 +324,106 @@ pub fn delay_as_bug(mut self) -> G::EmitResult {
expected_extra: &dyn fmt::Display,
found_extra: &dyn fmt::Display,
));
forward!((note, note_mv)(
forward!((note, with_note)(
msg: impl Into<SubdiagnosticMessage>,
));
forward!((note_once, note_once_mv)(
forward!((note_once, with_note_once)(
msg: impl Into<SubdiagnosticMessage>,
));
forward!((span_note, span_note_mv)(
forward!((span_note, with_span_note)(
sp: impl Into<MultiSpan>,
msg: impl Into<SubdiagnosticMessage>,
));
forward!((span_note_once, span_note_once_mv)(
forward!((span_note_once, with_span_note_once)(
sp: impl Into<MultiSpan>,
msg: impl Into<SubdiagnosticMessage>,
));
forward!((warn, warn_mv)(
forward!((warn, with_warn)(
msg: impl Into<SubdiagnosticMessage>,
));
forward!((span_warn, span_warn_mv)(
forward!((span_warn, with_span_warn)(
sp: impl Into<MultiSpan>,
msg: impl Into<SubdiagnosticMessage>,
));
forward!((help, help_mv)(
forward!((help, with_help)(
msg: impl Into<SubdiagnosticMessage>,
));
forward!((help_once, help_once_mv)(
forward!((help_once, with_help_once)(
msg: impl Into<SubdiagnosticMessage>,
));
forward!((span_help, span_help_once_mv)(
forward!((span_help, with_span_help_once)(
sp: impl Into<MultiSpan>,
msg: impl Into<SubdiagnosticMessage>,
));
forward!((multipart_suggestion, multipart_suggestion_mv)(
forward!((multipart_suggestion, with_multipart_suggestion)(
msg: impl Into<SubdiagnosticMessage>,
suggestion: Vec<(Span, String)>,
applicability: Applicability,
));
forward!((multipart_suggestion_verbose, multipart_suggestion_verbose_mv)(
forward!((multipart_suggestion_verbose, with_multipart_suggestion_verbose)(
msg: impl Into<SubdiagnosticMessage>,
suggestion: Vec<(Span, String)>,
applicability: Applicability,
));
forward!((tool_only_multipart_suggestion, tool_only_multipart_suggestion_mv)(
forward!((tool_only_multipart_suggestion, with_tool_only_multipart_suggestion)(
msg: impl Into<SubdiagnosticMessage>,
suggestion: Vec<(Span, String)>,
applicability: Applicability,
));
forward!((span_suggestion, span_suggestion_mv)(
forward!((span_suggestion, with_span_suggestion)(
sp: Span,
msg: impl Into<SubdiagnosticMessage>,
suggestion: impl ToString,
applicability: Applicability,
));
forward!((span_suggestions, span_suggestions_mv)(
forward!((span_suggestions, with_span_suggestions)(
sp: Span,
msg: impl Into<SubdiagnosticMessage>,
suggestions: impl IntoIterator<Item = String>,
applicability: Applicability,
));
forward!((multipart_suggestions, multipart_suggestions_mv)(
forward!((multipart_suggestions, with_multipart_suggestions)(
msg: impl Into<SubdiagnosticMessage>,
suggestions: impl IntoIterator<Item = Vec<(Span, String)>>,
applicability: Applicability,
));
forward!((span_suggestion_short, span_suggestion_short_mv)(
forward!((span_suggestion_short, with_span_suggestion_short)(
sp: Span,
msg: impl Into<SubdiagnosticMessage>,
suggestion: impl ToString,
applicability: Applicability,
));
forward!((span_suggestion_verbose, span_suggestion_verbose_mv)(
forward!((span_suggestion_verbose, with_span_suggestion_verbose)(
sp: Span,
msg: impl Into<SubdiagnosticMessage>,
suggestion: impl ToString,
applicability: Applicability,
));
forward!((span_suggestion_hidden, span_suggestion_hidden_mv)(
forward!((span_suggestion_hidden, with_span_suggestion_hidden)(
sp: Span,
msg: impl Into<SubdiagnosticMessage>,
suggestion: impl ToString,
applicability: Applicability,
));
forward!((tool_only_span_suggestion, tool_only_span_suggestion_mv)(
forward!((tool_only_span_suggestion, with_tool_only_span_suggestion)(
sp: Span,
msg: impl Into<SubdiagnosticMessage>,
suggestion: impl ToString,
applicability: Applicability,
));
forward!((primary_message, primary_message_mv)(
forward!((primary_message, with_primary_message)(
msg: impl Into<DiagnosticMessage>,
));
forward!((span, span_mv)(
forward!((span, with_span)(
sp: impl Into<MultiSpan>,
));
forward!((code, code_mv)(
forward!((code, with_code)(
s: DiagnosticId,
));
forward!((arg, arg_mv)(
forward!((arg, with_arg)(
name: impl Into<Cow<'static, str>>, arg: impl IntoDiagnosticArg,
));
forward!((subdiagnostic, subdiagnostic_mv)(
forward!((subdiagnostic, with_subdiagnostic)(
subdiagnostic: impl crate::AddToDiagnostic,
));
}
@ -459,7 +459,7 @@ macro_rules! struct_span_code_err {
$span,
format!($($message)*),
)
.code_mv($crate::error_code!($code))
.with_code($crate::error_code!($code))
})
}

32
compiler/rustc_errors/src/diagnostic_impls.rs
View File

@ -252,40 +252,40 @@ fn into_diagnostic(self, dcx: &DiagCtxt, level: Level) -> DiagnosticBuilder<'_,
match self {
TargetDataLayoutErrors::InvalidAddressSpace { addr_space, err, cause } => {
DiagnosticBuilder::new(dcx, level, fluent::errors_target_invalid_address_space)
.arg_mv("addr_space", addr_space)
.arg_mv("cause", cause)
.arg_mv("err", err)
.with_arg("addr_space", addr_space)
.with_arg("cause", cause)
.with_arg("err", err)
}
TargetDataLayoutErrors::InvalidBits { kind, bit, cause, err } => {
DiagnosticBuilder::new(dcx, level, fluent::errors_target_invalid_bits)
.arg_mv("kind", kind)
.arg_mv("bit", bit)
.arg_mv("cause", cause)
.arg_mv("err", err)
.with_arg("kind", kind)
.with_arg("bit", bit)
.with_arg("cause", cause)
.with_arg("err", err)
}
TargetDataLayoutErrors::MissingAlignment { cause } => {
DiagnosticBuilder::new(dcx, level, fluent::errors_target_missing_alignment)
.arg_mv("cause", cause)
.with_arg("cause", cause)
}
TargetDataLayoutErrors::InvalidAlignment { cause, err } => {
DiagnosticBuilder::new(dcx, level, fluent::errors_target_invalid_alignment)
.arg_mv("cause", cause)
.arg_mv("err_kind", err.diag_ident())
.arg_mv("align", err.align())
.with_arg("cause", cause)
.with_arg("err_kind", err.diag_ident())
.with_arg("align", err.align())
}
TargetDataLayoutErrors::InconsistentTargetArchitecture { dl, target } => {
DiagnosticBuilder::new(dcx, level, fluent::errors_target_inconsistent_architecture)
.arg_mv("dl", dl)
.arg_mv("target", target)
.with_arg("dl", dl)
.with_arg("target", target)
}
TargetDataLayoutErrors::InconsistentTargetPointerWidth { pointer_size, target } => {
DiagnosticBuilder::new(dcx, level, fluent::errors_target_inconsistent_pointer_width)
.arg_mv("pointer_size", pointer_size)
.arg_mv("target", target)
.with_arg("pointer_size", pointer_size)
.with_arg("target", target)
}
TargetDataLayoutErrors::InvalidBitsSize { err } => {
DiagnosticBuilder::new(dcx, level, fluent::errors_target_invalid_bits_size)
.arg_mv("err", err)
.with_arg("err", err)
}
}
}

12
compiler/rustc_errors/src/lib.rs
View File

@ -727,7 +727,7 @@ pub fn struct_span_warn(
span: impl Into<MultiSpan>,
msg: impl Into<DiagnosticMessage>,
) -> DiagnosticBuilder<'_, ()> {
self.struct_warn(msg).span_mv(span)
self.struct_warn(msg).with_span(span)
}
/// Construct a builder at the `Warning` level with the `msg`.
@ -767,7 +767,7 @@ pub fn struct_span_err(
span: impl Into<MultiSpan>,
msg: impl Into<DiagnosticMessage>,
) -> DiagnosticBuilder<'_> {
self.struct_err(msg).span_mv(span)
self.struct_err(msg).with_span(span)
}
/// Construct a builder at the `Error` level with the `msg`.
@ -786,7 +786,7 @@ pub fn struct_span_fatal(
span: impl Into<MultiSpan>,
msg: impl Into<DiagnosticMessage>,
) -> DiagnosticBuilder<'_, FatalAbort> {
self.struct_fatal(msg).span_mv(span)
self.struct_fatal(msg).with_span(span)
}
/// Construct a builder at the `Fatal` level with the `msg`.
@ -827,7 +827,7 @@ pub fn struct_span_bug(
span: impl Into<MultiSpan>,
msg: impl Into<DiagnosticMessage>,
) -> DiagnosticBuilder<'_, BugAbort> {
self.struct_bug(msg).span_mv(span)
self.struct_bug(msg).with_span(span)
}
#[rustc_lint_diagnostics]
@ -888,7 +888,7 @@ pub fn span_delayed_bug(
if treat_next_err_as_bug {
self.span_bug(sp, msg);
}
DiagnosticBuilder::<ErrorGuaranteed>::new(self, DelayedBug, msg).span_mv(sp).emit()
DiagnosticBuilder::<ErrorGuaranteed>::new(self, DelayedBug, msg).with_span(sp).emit()
}
// FIXME(eddyb) note the comment inside `impl Drop for DiagCtxtInner`, that's
@ -913,7 +913,7 @@ pub fn struct_span_note(
span: impl Into<MultiSpan>,
msg: impl Into<DiagnosticMessage>,
) -> DiagnosticBuilder<'_, ()> {
DiagnosticBuilder::new(self, Note, msg).span_mv(span)
DiagnosticBuilder::new(self, Note, msg).with_span(span)
}
#[rustc_lint_diagnostics]

2
compiler/rustc_expand/src/mbe/macro_parser.rs
View File

@ -680,7 +680,7 @@ pub(super) fn parse_tt<'matcher, T: Tracker<'matcher>>(
// edition-specific matching behavior for non-terminals.
let nt = match parser.to_mut().parse_nonterminal(kind) {
Err(err) => {
let guarantee = err.span_label_mv(
let guarantee = err.with_span_label(
span,
format!(
"while parsing argument for this `{kind}` macro fragment"

2
compiler/rustc_expand/src/mbe/quoted.rs
View File

@ -86,7 +86,7 @@ pub(super) fn parse(
);
sess.dcx
.struct_span_err(span, msg)
.help_mv(VALID_FRAGMENT_NAMES_MSG)
.with_help(VALID_FRAGMENT_NAMES_MSG)
.emit();
token::NonterminalKind::Ident
},

2
compiler/rustc_hir_analysis/src/astconv/bounds.rs
View File

@ -305,7 +305,7 @@ pub(super) fn add_predicates_for_ast_type_binding(
binding.span,
format!("{} `{}` is private", assoc_item.kind, binding.item_name),
)
.span_label_mv(binding.span, format!("private {}", assoc_item.kind))
.with_span_label(binding.span, format!("private {}", assoc_item.kind))
.emit();
}
tcx.check_stability(assoc_item.def_id, Some(hir_ref_id), binding.span, None);

4
compiler/rustc_hir_analysis/src/astconv/generics.rs
View File

@ -70,7 +70,7 @@ fn generic_arg_mismatch_err(
Res::Err => {
add_braces_suggestion(arg, &mut err);
return err
.primary_message_mv("unresolved item provided when a constant was expected")
.with_primary_message("unresolved item provided when a constant was expected")
.emit();
}
Res::Def(DefKind::TyParam, src_def_id) => {
@ -651,7 +651,7 @@ pub(crate) fn prohibit_explicit_late_bound_lifetimes(
&& args.num_lifetime_params() != param_counts.lifetimes
{
struct_span_code_err!(tcx.dcx(), span, E0794, "{}", msg)
.span_note_mv(span_late, note)
.with_span_note(span_late, note)
.emit();
} else {
let mut multispan = MultiSpan::from_span(span);

6
compiler/rustc_hir_analysis/src/astconv/mod.rs
View File

@ -1618,9 +1618,9 @@ fn check_assoc_ty(
let def_span = tcx.def_span(item);
tcx.dcx()
.struct_span_err(span, msg)
.code_mv(rustc_errors::error_code!(E0624))
.span_label_mv(span, format!("private {kind}"))
.span_label_mv(def_span, format!("{kind} defined here"))
.with_code(rustc_errors::error_code!(E0624))
.with_span_label(span, format!("private {kind}"))
.with_span_label(def_span, format!("{kind} defined here"))
.emit();
}
tcx.check_stability(item, Some(block), span, None);

2
compiler/rustc_hir_analysis/src/astconv/object_safety.rs
View File

@ -298,7 +298,7 @@ trait here instead: `trait NewTrait: {} {{}}`",
tcx.def_descr(def_id),
tcx.item_name(def_id),
)
.note_mv(
.with_note(
rustc_middle::traits::ObjectSafetyViolation::SupertraitSelf(smallvec![])
.error_msg(),
)

17
compiler/rustc_hir_analysis/src/check/check.rs
View File

@ -566,8 +566,8 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) {
E0044,
"foreign items may not have {kinds} parameters",
)
.span_label_mv(item.span, format!("can't have {kinds} parameters"))
.help_mv(
.with_span_label(item.span, format!("can't have {kinds} parameters"))
.with_help(
// FIXME: once we start storing spans for type arguments, turn this
// into a suggestion.
format!(
@ -801,10 +801,9 @@ fn check_impl_items_against_trait<'tcx>(
};
tcx.dcx()
.struct_span_err(tcx.def_span(def_id), msg)
.note_mv(format!(
"specialization behaves in inconsistent and \
surprising ways with {feature}, \
and for now is disallowed"
.with_note(format!(
"specialization behaves in inconsistent and surprising ways with \
{feature}, and for now is disallowed"
))
.emit();
}
@ -843,7 +842,7 @@ pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: LocalDefId) {
let e = fields[FieldIdx::from_u32(0)].ty(tcx, args);
if !fields.iter().all(|f| f.ty(tcx, args) == e) {
struct_span_code_err!(tcx.dcx(), sp, E0076, "SIMD vector should be homogeneous")
.span_label_mv(sp, "SIMD elements must have the same type")
.with_span_label(sp, "SIMD elements must have the same type")
.emit();
return;
}
@ -1120,7 +1119,7 @@ fn check_enum(tcx: TyCtxt<'_>, def_id: LocalDefId) {
E0084,
"unsupported representation for zero-variant enum"
)
.span_label_mv(tcx.def_span(def_id), "zero-variant enum")
.with_span_label(tcx.def_span(def_id), "zero-variant enum")
.emit();
}
}
@ -1313,7 +1312,7 @@ pub(super) fn check_type_params_are_used<'tcx>(
"type parameter `{}` is unused",
param.name,
)
.span_label_mv(span, "unused type parameter")
.with_span_label(span, "unused type parameter")
.emit();
}
}

6
compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
View File

@ -934,12 +934,12 @@ fn try_fold_region(
return_span,
"return type captures more lifetimes than trait definition",
)
.span_label_mv(self.tcx.def_span(def_id), "this lifetime was captured")
.span_note_mv(
.with_span_label(self.tcx.def_span(def_id), "this lifetime was captured")
.with_span_note(
self.tcx.def_span(self.def_id),
"hidden type must only reference lifetimes captured by this impl trait",
)
.note_mv(format!("hidden type inferred to be `{}`", self.ty))
.with_note(format!("hidden type inferred to be `{}`", self.ty))
.emit()
}
_ => self.tcx.dcx().delayed_bug("should've been able to remap region"),

4
compiler/rustc_hir_analysis/src/check/dropck.rs
View File

@ -165,7 +165,7 @@ fn ensure_drop_predicates_are_implied_by_item_defn<'tcx>(
"`Drop` impl requires `{root_predicate}` \
but the {self_descr} it is implemented for does not",
)
.span_note_mv(item_span, "the implementor must specify the same requirement")
.with_span_note(item_span, "the implementor must specify the same requirement")
.emit(),
);
}
@ -197,7 +197,7 @@ fn ensure_drop_predicates_are_implied_by_item_defn<'tcx>(
"`Drop` impl requires `{outlives}` \
but the {self_descr} it is implemented for does not",
)
.span_note_mv(item_span, "the implementor must specify the same requirement")
.with_span_note(item_span, "the implementor must specify the same requirement")
.emit(),
);
}

2
compiler/rustc_hir_analysis/src/check/intrinsic.rs
View File

@ -30,7 +30,7 @@ fn equate_intrinsic_type<'tcx>(
}
_ => {
struct_span_code_err!(tcx.dcx(), it.span, E0622, "intrinsic must be a function")
.span_label_mv(it.span, "expected a function")
.with_span_label(it.span, "expected a function")
.emit();
return;
}

18
compiler/rustc_hir_analysis/src/check/intrinsicck.rs
View File

@ -156,7 +156,7 @@ fn check_asm_operand_type(
self.tcx
.dcx()
.struct_span_err(expr.span, msg)
.note_mv(
.with_note(
"only integers, floats, SIMD vectors, pointers and function pointers \
can be used as arguments for inline assembly",
)
@ -171,7 +171,7 @@ fn check_asm_operand_type(
self.tcx
.dcx()
.struct_span_err(expr.span, msg)
.note_mv(format!("`{ty}` does not implement the Copy trait"))
.with_note(format!("`{ty}` does not implement the Copy trait"))
.emit();
}
@ -191,11 +191,11 @@ fn check_asm_operand_type(
self.tcx
.dcx()
.struct_span_err(vec![in_expr.span, expr.span], msg)
.span_label_mv(in_expr.span, format!("type `{in_expr_ty}`"))
.span_label_mv(expr.span, format!("type `{ty}`"))
.note_mv(
.with_span_label(in_expr.span, format!("type `{in_expr_ty}`"))
.with_span_label(expr.span, format!("type `{ty}`"))
.with_note(
"asm inout arguments must have the same type, \
unless they are both pointers or integers of the same size",
unless they are both pointers or integers of the same size",
)
.emit();
}
@ -242,7 +242,7 @@ fn check_asm_operand_type(
self.tcx
.dcx()
.struct_span_err(expr.span, msg)
.note_mv(format!(
.with_note(format!(
"this is required to use type `{}` with register class `{}`",
ty,
reg_class.name(),
@ -459,11 +459,11 @@ pub fn check_asm(&self, asm: &hir::InlineAsm<'tcx>, enclosing_id: LocalDefId) {
self.tcx
.dcx()
.struct_span_err(*op_sp, "invalid `sym` operand")
.span_label_mv(
.with_span_label(
self.tcx.def_span(anon_const.def_id),
format!("is {} `{}`", ty.kind().article(), ty),
)
.help_mv(
.with_help(
"`sym` operands must refer to either a function or a static",
)
.emit();

25
compiler/rustc_hir_analysis/src/check/wfcheck.rs
View File

@ -202,8 +202,8 @@ fn check_item<'tcx>(tcx: TyCtxt<'tcx>, item: &'tcx hir::Item<'tcx>) -> Result<()
res = Err(tcx
.dcx()
.struct_span_err(sp, "impls of auto traits cannot be default")
.span_labels_mv(impl_.defaultness_span, "default because of this")
.span_label_mv(sp, "auto trait")
.with_span_labels(impl_.defaultness_span, "default because of this")
.with_span_label(sp, "auto trait")
.emit());
}
// We match on both `ty::ImplPolarity` and `ast::ImplPolarity` just to get the `!` span.
@ -504,19 +504,18 @@ fn check_gat_where_clauses(tcx: TyCtxt<'_>, trait_def_id: LocalDefId) {
gat_item_hir.span,
format!("missing required bound{} on `{}`", plural, gat_item_hir.ident),
)
.span_suggestion_mv(
.with_span_suggestion(
gat_item_hir.generics.tail_span_for_predicate_suggestion(),
format!("add the required where clause{plural}"),
suggestion,
Applicability::MachineApplicable,
)
.note_mv(format!(
.with_note(format!(
"{bound} currently required to ensure that impls have maximum flexibility"
))
.note_mv(
.with_note(
"we are soliciting feedback, see issue #87479 \
<https://github.com/rust-lang/rust/issues/87479> \
for more information",
<https://github.com/rust-lang/rust/issues/87479> for more information",
)
.emit();
}
@ -839,8 +838,8 @@ fn check_object_unsafe_self_trait_by_name(tcx: TyCtxt<'_>, item: &hir::TraitItem
trait_should_be_self,
"associated item referring to unboxed trait object for its own trait",
)
.span_label_mv(trait_name.span, "in this trait")
.multipart_suggestion_mv(
.with_span_label(trait_name.span, "in this trait")
.with_multipart_suggestion(
"you might have meant to use `Self` to refer to the implementing type",
sugg,
Applicability::MachineApplicable,
@ -1600,7 +1599,7 @@ fn check_method_receiver<'tcx>(
the `arbitrary_self_types` feature",
),
)
.help_mv(HELP_FOR_SELF_TYPE)
.with_help(HELP_FOR_SELF_TYPE)
.emit()
} else {
// Report error; would not have worked with `arbitrary_self_types`.
@ -1613,8 +1612,8 @@ fn check_method_receiver<'tcx>(
fn e0307(tcx: TyCtxt<'_>, span: Span, receiver_ty: Ty<'_>) -> ErrorGuaranteed {
struct_span_code_err!(tcx.dcx(), span, E0307, "invalid `self` parameter type: {receiver_ty}")
.note_mv("type of `self` must be `Self` or a type that dereferences to it")
.help_mv(HELP_FOR_SELF_TYPE)
.with_note("type of `self` must be `Self` or a type that dereferences to it")
.with_help(HELP_FOR_SELF_TYPE)
.emit()
}
@ -1923,7 +1922,7 @@ fn check_mod_type_wf(tcx: TyCtxt<'_>, module: LocalModDefId) -> Result<(), Error
fn error_392(tcx: TyCtxt<'_>, span: Span, param_name: Symbol) -> DiagnosticBuilder<'_> {
struct_span_code_err!(tcx.dcx(), span, E0392, "parameter `{param_name}` is never used")
.span_label_mv(span, "unused parameter")
.with_span_label(span, "unused parameter")
}
pub fn provide(providers: &mut Providers) {

4
compiler/rustc_hir_analysis/src/coherence/inherent_impls_overlap.rs
View File

@ -77,8 +77,8 @@ fn check_for_duplicate_items_in_impl(&self, impl_: DefId) {
"duplicate definitions with name `{}`",
ident,
)
.span_label_mv(span, format!("duplicate definitions for `{ident}`"))
.span_label_mv(*former, format!("other definition for `{ident}`"))
.with_span_label(span, format!("duplicate definitions for `{ident}`"))
.with_span_label(*former, format!("other definition for `{ident}`"))
.emit();
}
Entry::Vacant(entry) => {

2
compiler/rustc_hir_analysis/src/coherence/mod.rs
View File

@ -181,7 +181,7 @@ fn check_object_overlap<'tcx>(
trait_ref.self_ty(),
tcx.def_path_str(trait_def_id)
)
.span_label_mv(
.with_span_label(
span,
format!(
"`{}` automatically implements trait `{}`",

10
compiler/rustc_hir_analysis/src/coherence/unsafety.rs
View File

@ -25,7 +25,7 @@ pub(super) fn check_item(tcx: TyCtxt<'_>, def_id: LocalDefId) {
"implementing the trait `{}` is not unsafe",
trait_ref.print_trait_sugared()
)
.span_suggestion_verbose_mv(
.with_span_suggestion_verbose(
item.span.with_hi(item.span.lo() + rustc_span::BytePos(7)),
"remove `unsafe` from this trait implementation",
"",
@ -42,13 +42,13 @@ pub(super) fn check_item(tcx: TyCtxt<'_>, def_id: LocalDefId) {
"the trait `{}` requires an `unsafe impl` declaration",
trait_ref.print_trait_sugared()
)
.note_mv(format!(
.with_note(format!(
"the trait `{}` enforces invariants that the compiler can't check. \
Review the trait documentation and make sure this implementation \
upholds those invariants before adding the `unsafe` keyword",
trait_ref.print_trait_sugared()
))
.span_suggestion_verbose_mv(
.with_span_suggestion_verbose(
item.span.shrink_to_lo(),
"add `unsafe` to this trait implementation",
"unsafe ",
@ -65,13 +65,13 @@ pub(super) fn check_item(tcx: TyCtxt<'_>, def_id: LocalDefId) {
"requires an `unsafe impl` declaration due to `#[{}]` attribute",
attr_name
)
.note_mv(format!(
.with_note(format!(
"the trait `{}` enforces invariants that the compiler can't check. \
Review the trait documentation and make sure this implementation \
upholds those invariants before adding the `unsafe` keyword",
trait_ref.print_trait_sugared()
))
.span_suggestion_verbose_mv(
.with_span_suggestion_verbose(
item.span.shrink_to_lo(),
"add `unsafe` to this trait implementation",
"unsafe ",

2
compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
View File

@ -751,7 +751,7 @@ fn visit_ty(&mut self, ty: &'tcx hir::Ty<'tcx>) {
lifetime.ident.span,
"higher kinded lifetime bounds on nested opaque types are not supported yet",
)
.span_note_mv(self.tcx.def_span(def_id), "lifetime declared here")
.with_span_note(self.tcx.def_span(def_id), "lifetime declared here")
.emit();
self.uninsert_lifetime_on_error(lifetime, def.unwrap());
}

2
compiler/rustc_hir_analysis/src/structured_errors/wrong_number_of_generic_args.rs
View File

@ -523,7 +523,7 @@ fn create_error_message(&self) -> String {
fn start_diagnostics(&self) -> DiagnosticBuilder<'tcx> {
let span = self.path_segment.ident.span;
let msg = self.create_error_message();
self.tcx.dcx().struct_span_err(span, msg).code_mv(self.code())
self.tcx.dcx().struct_span_err(span, msg).with_code(self.code())
}
/// Builds the `expected 1 type argument / supplied 2 type arguments` message.

2
compiler/rustc_hir_typeck/src/callee.rs
View File

@ -402,7 +402,7 @@ fn confirm_builtin_call(
callee_expr.span,
format!("evaluate({predicate:?}) = {result:?}"),
)
.span_label_mv(predicate_span, "predicate")
.with_span_label(predicate_span, "predicate")
.emit();
}
}

6
compiler/rustc_hir_typeck/src/cast.rs
View File

@ -269,7 +269,7 @@ fn report_cast_error(&self, fcx: &FnCtxt<'a, 'tcx>, e: CastError) {
}
CastError::NeedViaInt => {
make_invalid_casting_error(self.span, self.expr_ty, self.cast_ty, fcx)
.help_mv("cast through an integer first")
.with_help("cast through an integer first")
.emit();
}
CastError::IllegalCast => {
@ -277,7 +277,7 @@ fn report_cast_error(&self, fcx: &FnCtxt<'a, 'tcx>, e: CastError) {
}
CastError::DifferingKinds => {
make_invalid_casting_error(self.span, self.expr_ty, self.cast_ty, fcx)
.note_mv("vtable kinds may not match")
.with_note("vtable kinds may not match")
.emit();
}
CastError::CastToBool => {
@ -512,7 +512,7 @@ fn report_cast_error(&self, fcx: &FnCtxt<'a, 'tcx>, e: CastError) {
self.cast_ty,
fcx,
)
.note_mv("cannot cast an enum with a non-exhaustive variant when it's defined in another crate")
.with_note("cannot cast an enum with a non-exhaustive variant when it's defined in another crate")
.emit();
}
}

12
compiler/rustc_hir_typeck/src/expr.rs
View File

@ -2838,7 +2838,7 @@ fn private_field_err(&self, field: Ident, base_did: DefId) -> DiagnosticBuilder<
E0616,
"field `{field}` of {kind_name} `{struct_path}` is private",
)
.span_label_mv(field.span, "private field")
.with_span_label(field.span, "private field")
}
pub(crate) fn get_field_candidates_considering_privacy(
@ -3181,7 +3181,7 @@ fn check_expr_asm_operand(&self, expr: &'tcx hir::Expr<'tcx>, is_input: bool) {
if !is_input && !expr.is_syntactic_place_expr() {
self.dcx()
.struct_span_err(expr.span, "invalid asm output")
.span_label_mv(expr.span, "cannot assign to this expression")
.with_span_label(expr.span, "cannot assign to this expression")
.emit();
}
@ -3282,7 +3282,7 @@ fn check_offset_of(
E0599,
"no variant named `{ident}` found for enum `{container}`",
)
.span_label_mv(field.span, "variant not found")
.with_span_label(field.span, "variant not found")
.emit();
break;
};
@ -3294,7 +3294,7 @@ fn check_offset_of(
E0795,
"`{ident}` is an enum variant; expected field at end of `offset_of`",
)
.span_label_mv(field.span, "enum variant")
.with_span_label(field.span, "enum variant")
.emit();
break;
};
@ -3313,8 +3313,8 @@ fn check_offset_of(
E0609,
"no field named `{subfield}` on enum variant `{container}::{ident}`",
)
.span_label_mv(field.span, "this enum variant...")
.span_label_mv(subident.span, "...does not have this field")
.with_span_label(field.span, "this enum variant...")
.with_span_label(subident.span, "...does not have this field")
.emit();
break;
};

4
compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
View File

@ -828,7 +828,7 @@ fn has_error_or_infer<'tcx>(tys: impl IntoIterator<Item = Ty<'tcx>>) -> bool {
pluralize!("was", provided_args.len())
),
)
.code_mv(DiagnosticId::Error(err_code.to_owned()))
.with_code(DiagnosticId::Error(err_code.to_owned()))
};
// As we encounter issues, keep track of what we want to provide for the suggestion
@ -1386,7 +1386,7 @@ pub fn check_struct_path(
"expected struct, variant or union type, found {}",
ty.normalized.sort_string(self.tcx)
)
.span_label_mv(path_span, "not a struct")
.with_span_label(path_span, "not a struct")
.emit(),
})
}

6
compiler/rustc_hir_typeck/src/intrinsicck.rs
View File

@ -74,9 +74,9 @@ pub fn check_transmute(&self, from: Ty<'tcx>, to: Ty<'tcx>, hir_id: HirId) {
&& size_to == Pointer(dl.instruction_address_space).size(&tcx)
{
struct_span_code_err!(tcx.dcx(), span, E0591, "can't transmute zero-sized type")
.note_mv(format!("source type: {from}"))
.note_mv(format!("target type: {to}"))
.help_mv("cast with `as` to a pointer instead")
.with_note(format!("source type: {from}"))
.with_note(format!("target type: {to}"))
.with_help("cast with `as` to a pointer instead")
.emit();
return;
}

8
compiler/rustc_hir_typeck/src/lib.rs
View File

@ -369,14 +369,14 @@ fn report_unexpected_variant_res(
let err = tcx
.dcx()
.struct_span_err(span, format!("expected {expected}, found {res_descr} `{path_str}`"))
.code_mv(DiagnosticId::Error(err_code.into()));
.with_code(DiagnosticId::Error(err_code.into()));
match res {
Res::Def(DefKind::Fn | DefKind::AssocFn, _) if err_code == "E0164" => {
let patterns_url = "https://doc.rust-lang.org/book/ch18-00-patterns.html";
err.span_label_mv(span, "`fn` calls are not allowed in patterns")
.help_mv(format!("for more information, visit {patterns_url}"))
err.with_span_label(span, "`fn` calls are not allowed in patterns")
.with_help(format!("for more information, visit {patterns_url}"))
}
_ => err.span_label_mv(span, format!("not a {expected}")),
_ => err.with_span_label(span, format!("not a {expected}")),
}
.emit()
}

10
compiler/rustc_hir_typeck/src/pat.rs
View File

@ -1547,7 +1547,7 @@ fn error_foreign_non_exhaustive_spat(&self, pat: &Pat<'_>, descr: &str, no_field
E0638,
"`..` required with {descr} marked as non-exhaustive",
)
.span_suggestion_verbose_mv(
.with_span_suggestion_verbose(
sp_comma,
"add `..` at the end of the field list to ignore all other fields",
sugg,
@ -1569,8 +1569,8 @@ fn error_field_already_bound(
"field `{}` bound multiple times in the pattern",
ident
)
.span_label_mv(span, format!("multiple uses of `{ident}` in pattern"))
.span_label_mv(other_field, format!("first use of `{ident}`"))
.with_span_label(span, format!("multiple uses of `{ident}` in pattern"))
.with_span_label(other_field, format!("first use of `{ident}`"))
.emit()
}
@ -2235,7 +2235,7 @@ fn error_scrutinee_inconsistent_length(
pluralize!(min_len),
size,
)
.span_label_mv(span, format!("expected {} element{}", size, pluralize!(size)))
.with_span_label(span, format!("expected {} element{}", size, pluralize!(size)))
.emit()
}
@ -2254,7 +2254,7 @@ fn error_scrutinee_with_rest_inconsistent_length(
pluralize!(min_len),
size,
)
.span_label_mv(
.with_span_label(
span,
format!("pattern cannot match array of {} element{}", size, pluralize!(size),),
)

4
compiler/rustc_hir_typeck/src/place_op.rs
View File

@ -336,10 +336,10 @@ pub fn convert_place_derefs_to_mutable(&self, expr: &hir::Expr<'_>) {
expr.span,
"not automatically applying `DerefMut` on `ManuallyDrop` union field",
)
.help_mv(
.with_help(
"writing to this reference calls the destructor for the old value",
)
.help_mv("add an explicit `*` if that is desired, or call `ptr::write` to not run the destructor")
.with_help("add an explicit `*` if that is desired, or call `ptr::write` to not run the destructor")
.emit();
}
}

2
compiler/rustc_infer/src/infer/error_reporting/note.rs
View File

@ -368,7 +368,7 @@ pub(super) fn report_placeholder_failure(
{
let span = *span;
self.report_concrete_failure(placeholder_origin, sub, sup)
.span_note_mv(span, "the lifetime requirement is introduced here")
.with_span_note(span, "the lifetime requirement is introduced here")
} else {
unreachable!(
"control flow ensures we have a `BindingObligation` or `ExprBindingObligation` here..."

2
compiler/rustc_middle/src/ty/opaque_types.rs
View File

@ -132,7 +132,7 @@ fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
.tcx
.dcx()
.struct_span_err(self.span, "non-defining opaque type use in defining scope")
.span_label_mv(
.with_span_label(
self.span,
format!(
"lifetime `{r}` is part of concrete type but not used in \

2
compiler/rustc_middle/src/ty/util.rs
View File

@ -369,7 +369,7 @@ pub fn calculate_dtor(
if let Some((old_item_id, _)) = dtor_candidate {
self.dcx()
.struct_span_err(self.def_span(item_id), "multiple drop impls found")
.span_note_mv(self.def_span(old_item_id), "other impl here")
.with_span_note(self.def_span(old_item_id), "other impl here")
.delay_as_bug();
}

2
compiler/rustc_middle/src/values.rs
View File

@ -318,7 +318,7 @@ pub fn recursive_type_error(
items_list,
pluralize!("has", cycle_len),
)
.multipart_suggestion_mv(
.with_multipart_suggestion(
"insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle",
suggestion,
Applicability::HasPlaceholders,

12
compiler/rustc_parse/src/lexer/mod.rs
View File

@ -250,7 +250,7 @@ fn next_token(&mut self) -> (Token, bool) {
if starts_with_number {
let span = self.mk_sp(start, self.pos);
self.dcx().struct_err("lifetimes cannot start with a number")
.span_mv(span)
.with_span(span)
.stash(span, StashKey::LifetimeIsChar);
}
let ident = Symbol::intern(lifetime_name);
@ -397,7 +397,7 @@ fn cook_lexer_literal(
if !terminated {
self.dcx()
.struct_span_fatal(self.mk_sp(start, end), "unterminated character literal")
.code_mv(error_code!(E0762))
.with_code(error_code!(E0762))
.emit()
}
self.cook_quoted(token::Char, Mode::Char, start, end, 1, 1) // ' '
@ -409,7 +409,7 @@ fn cook_lexer_literal(
self.mk_sp(start + BytePos(1), end),
"unterminated byte constant",
)
.code_mv(error_code!(E0763))
.with_code(error_code!(E0763))
.emit()
}
self.cook_quoted(token::Byte, Mode::Byte, start, end, 2, 1) // b' '
@ -421,7 +421,7 @@ fn cook_lexer_literal(
self.mk_sp(start, end),
"unterminated double quote string",
)
.code_mv(error_code!(E0765))
.with_code(error_code!(E0765))
.emit()
}
self.cook_quoted(token::Str, Mode::Str, start, end, 1, 1) // " "
@ -433,7 +433,7 @@ fn cook_lexer_literal(
self.mk_sp(start + BytePos(1), end),
"unterminated double quote byte string",
)
.code_mv(error_code!(E0766))
.with_code(error_code!(E0766))
.emit()
}
self.cook_quoted(token::ByteStr, Mode::ByteStr, start, end, 2, 1) // b" "
@ -445,7 +445,7 @@ fn cook_lexer_literal(
self.mk_sp(start + BytePos(1), end),
"unterminated C string",
)
.code_mv(error_code!(E0767))
.with_code(error_code!(E0767))
.emit()
}
self.cook_c_string(token::CStr, Mode::CStr, start, end, 2, 1) // c" "

4
compiler/rustc_parse/src/lib.rs
View File

@ -246,8 +246,8 @@ pub fn parse_cfg_attr(
match parse_in(parse_sess, tokens.clone(), "`cfg_attr` input", |p| p.parse_cfg_attr()) {
Ok(r) => return Some(r),
Err(e) => {
e.help_mv(format!("the valid syntax is `{CFG_ATTR_GRAMMAR_HELP}`"))
.note_mv(CFG_ATTR_NOTE_REF)
e.with_help(format!("the valid syntax is `{CFG_ATTR_GRAMMAR_HELP}`"))
.with_note(CFG_ATTR_NOTE_REF)
.emit();
}
}

11
compiler/rustc_parse/src/parser/attr.rs
View File

@ -204,8 +204,11 @@ pub(super) fn error_on_forbidden_inner_attr(&self, attr_sp: Span, policy: InnerA
attr_sp,
fluent::parse_inner_attr_not_permitted_after_outer_doc_comment,
)
.span_label_mv(attr_sp, fluent::parse_label_attr)
.span_label_mv(prev_doc_comment_span, fluent::parse_label_prev_doc_comment)
.with_span_label(attr_sp, fluent::parse_label_attr)
.with_span_label(
prev_doc_comment_span,
fluent::parse_label_prev_doc_comment,
)
}
Some(InnerAttrForbiddenReason::AfterOuterAttribute { prev_outer_attr_sp }) => self
.dcx()
@ -213,8 +216,8 @@ pub(super) fn error_on_forbidden_inner_attr(&self, attr_sp: Span, policy: InnerA
attr_sp,
fluent::parse_inner_attr_not_permitted_after_outer_attr,
)
.span_label_mv(attr_sp, fluent::parse_label_attr)
.span_label_mv(prev_outer_attr_sp, fluent::parse_label_prev_attr),
.with_span_label(attr_sp, fluent::parse_label_attr)
.with_span_label(prev_outer_attr_sp, fluent::parse_label_prev_attr),
Some(InnerAttrForbiddenReason::InCodeBlock) | None => {
self.dcx().struct_span_err(attr_sp, fluent::parse_inner_attr_not_permitted)
}

4
compiler/rustc_parse/src/parser/diagnostics.rs
View File

@ -2847,8 +2847,8 @@ pub(crate) fn maybe_recover_unexpected_block_label(&mut self) -> bool {
let span = label.ident.span.to(self.prev_token.span);
self.dcx()
.struct_span_err(span, "block label not supported here")
.span_label_mv(span, "not supported here")
.tool_only_span_suggestion_mv(
.with_span_label(span, "not supported here")
.with_tool_only_span_suggestion(
label.ident.span.until(self.token.span),
"remove this block label",
"",

4
compiler/rustc_parse/src/parser/expr.rs
View File

@ -1753,7 +1753,7 @@ pub(super) fn recover_unclosed_char<L>(
err: impl FnOnce(&Self) -> DiagnosticBuilder<'a>,
) -> L {
if let Some(diag) = self.dcx().steal_diagnostic(lifetime.span, StashKey::LifetimeIsChar) {
diag.span_suggestion_verbose_mv(
diag.with_span_suggestion_verbose(
lifetime.span.shrink_to_hi(),
"add `'` to close the char literal",
"'",
@ -1762,7 +1762,7 @@ pub(super) fn recover_unclosed_char<L>(
.emit();
} else {
err(self)
.span_suggestion_verbose_mv(
.with_span_suggestion_verbose(
lifetime.span.shrink_to_hi(),
"add `'` to close the char literal",
"'",

2
compiler/rustc_parse/src/parser/generics.rs
View File

@ -145,7 +145,7 @@ pub(crate) fn recover_const_param_with_mistyped_const(
mistyped_const_ident.span,
format!("`const` keyword was mistyped as `{}`", mistyped_const_ident.as_str()),
)
.span_suggestion_verbose_mv(
.with_span_suggestion_verbose(
mistyped_const_ident.span,
"use the `const` keyword",
kw::Const.as_str(),

22
compiler/rustc_parse/src/parser/item.rs
View File

@ -741,11 +741,11 @@ fn parse_item_list<T>(
Ok(Some(item)) => items.extend(item),
Err(err) => {
self.consume_block(Delimiter::Brace, ConsumeClosingDelim::Yes);
err.span_label_mv(
err.with_span_label(
open_brace_span,
"while parsing this item list starting here",
)
.span_label_mv(self.prev_token.span, "the item list ends here")
.with_span_label(self.prev_token.span, "the item list ends here")
.emit();
break;
}
@ -765,8 +765,8 @@ fn recover_doc_comment_before_brace(&mut self) -> bool {
E0584,
"found a documentation comment that doesn't document anything",
)
.span_label_mv(self.token.span, "this doc comment doesn't document anything")
.help_mv(
.with_span_label(self.token.span, "this doc comment doesn't document anything")
.with_help(
"doc comments must come before what they document, if a comment was \
intended use `//`",
)
@ -1218,7 +1218,7 @@ fn recover_const_impl(
let before_trait = trai.path.span.shrink_to_lo();
let const_up_to_impl = const_span.with_hi(impl_span.lo());
err.multipart_suggestion_mv(
err.with_multipart_suggestion(
"you might have meant to write a const trait impl",
vec![(const_up_to_impl, "".to_owned()), (before_trait, "const ".to_owned())],
Applicability::MaybeIncorrect,
@ -1457,7 +1457,7 @@ fn parse_enum_variant(&mut self, span: Span) -> PResult<'a, Option<Variant>> {
if this.token == token::Not {
if let Err(err) = this.unexpected::<()>() {
err.note_mv(fluent::parse_macro_expands_to_enum_variant).emit();
err.with_note(fluent::parse_macro_expands_to_enum_variant).emit();
}
this.bump();
@ -1855,7 +1855,7 @@ fn expect_field_ty_separator(&mut self) -> PResult<'a, ()> {
if eq_typo || semi_typo {
self.bump();
// Gracefully handle small typos.
err.span_suggestion_short_mv(
err.with_span_suggestion_short(
self.prev_token.span,
"field names and their types are separated with `:`",
":",
@ -1935,10 +1935,10 @@ fn parse_field_ident(&mut self, adt_ty: &str, lo: Span) -> PResult<'a, Ident> {
lo.to(self.prev_token.span),
format!("functions are not allowed in {adt_ty} definitions"),
)
.help_mv(
.with_help(
"unlike in C++, Java, and C#, functions are declared in `impl` blocks",
)
.help_mv("see https://doc.rust-lang.org/book/ch05-03-method-syntax.html for more information")
.with_help("see https://doc.rust-lang.org/book/ch05-03-method-syntax.html for more information")
}
Err(err) => {
err.cancel();
@ -1954,7 +1954,9 @@ fn parse_field_ident(&mut self, adt_ty: &str, lo: Span) -> PResult<'a, Ident> {
lo.with_hi(ident.span.hi()),
format!("structs are not allowed in {adt_ty} definitions"),
)
.help_mv("consider creating a new `struct` definition instead of nesting"),
.with_help(
"consider creating a new `struct` definition instead of nesting",
),
Err(err) => {
err.cancel();
self.restore_snapshot(snapshot);

4
compiler/rustc_parse/src/parser/mod.rs
View File

@ -847,7 +847,7 @@ fn parse_seq_to_before_tokens<T>(
pprust::token_to_string(&self.prev_token)
);
expect_err
.span_suggestion_verbose_mv(
.with_span_suggestion_verbose(
self.prev_token.span.shrink_to_hi().until(self.token.span),
msg,
" @ ",
@ -863,7 +863,7 @@ fn parse_seq_to_before_tokens<T>(
// Parsed successfully, therefore most probably the code only
// misses a separator.
expect_err
.span_suggestion_short_mv(
.with_span_suggestion_short(
sp,
format!("missing `{token_str}`"),
token_str,

2
compiler/rustc_parse/src/parser/pat.rs
View File

@ -464,7 +464,7 @@ fn parse_pat_with_range_pat(
self_
.dcx()
.struct_span_err(self_.token.span, msg)
.span_label_mv(self_.token.span, format!("expected {expected}"))
.with_span_label(self_.token.span, format!("expected {expected}"))
});
PatKind::Lit(self.mk_expr(lo, ExprKind::Lit(lit)))
} else {

2
compiler/rustc_parse/src/parser/path.rs
View File

@ -128,7 +128,7 @@ fn recover_colon_before_qpath_proj(&mut self) -> bool {
self.prev_token.span,
"found single colon before projection in qualified path",
)
.span_suggestion_mv(
.with_span_suggestion(
self.prev_token.span,
"use double colon",
"::",

2
compiler/rustc_parse/src/parser/ty.rs
View File

@ -1116,7 +1116,7 @@ fn recover_fn_trait_with_lifetime_params(
let before_fn_path = fn_path.span.shrink_to_lo();
self.dcx()
.struct_span_err(generic_args_span, "`Fn` traits cannot take lifetime parameters")
.multipart_suggestion_mv(
.with_multipart_suggestion(
"consider using a higher-ranked trait bound instead",
vec![(generic_args_span, "".to_owned()), (before_fn_path, snippet)],
Applicability::MaybeIncorrect,

2
compiler/rustc_parse/src/validate_attr.rs
View File

@ -208,7 +208,7 @@ fn emit_malformed_attribute(
} else {
sess.dcx
.struct_span_err(span, error_msg)
.span_suggestions_mv(
.with_span_suggestions(
span,
if suggestions.len() == 1 {
"must be of the form"

4
compiler/rustc_resolve/src/build_reduced_graph.rs
View File

@ -818,7 +818,7 @@ fn build_reduced_graph_for_extern_crate(
self.r
.dcx()
.struct_span_err(item.span, "`extern crate self;` requires renaming")
.span_suggestion_mv(
.with_span_suggestion(
item.span,
"rename the `self` crate to be able to import it",
"extern crate self as name;",
@ -999,7 +999,7 @@ fn add_macro_use_binding(
let msg = format!("`{name}` is already in scope");
let note =
"macro-expanded `#[macro_use]`s may not shadow existing macros (see RFC 1560)";
self.r.dcx().struct_span_err(span, msg).note_mv(note).emit();
self.r.dcx().struct_span_err(span, msg).with_note(note).emit();
}
}

6
compiler/rustc_resolve/src/diagnostics.rs
View File

@ -950,9 +950,9 @@ pub(crate) fn into_struct_error(
"item `{name}` is an associated {kind}, which doesn't match its trait `{trait_path}`",
),
)
.code_mv(code)
.span_label_mv(span, "does not match trait")
.span_label_mv(trait_item_span, "item in trait")
.with_code(code)
.with_span_label(span, "does not match trait")
.with_span_label(trait_item_span, "item in trait")
}
ResolutionError::TraitImplDuplicate { name, trait_item_span, old_span } => self
.dcx()

4
compiler/rustc_resolve/src/late.rs
View File

@ -2600,7 +2600,7 @@ fn with_generic_param_rib<'c, F>(
E0637,
"`'_` cannot be used here"
)
.span_label_mv(param.ident.span, "`'_` is a reserved lifetime name")
.with_span_label(param.ident.span, "`'_` is a reserved lifetime name")
.emit();
// Record lifetime res, so lowering knows there is something fishy.
self.record_lifetime_param(param.id, LifetimeRes::Error);
@ -2615,7 +2615,7 @@ fn with_generic_param_rib<'c, F>(
"invalid lifetime parameter name: `{}`",
param.ident,
)
.span_label_mv(param.ident.span, "'static is a reserved lifetime name")
.with_span_label(param.ident.span, "'static is a reserved lifetime name")
.emit();
// Record lifetime res, so lowering knows there is something fishy.
self.record_lifetime_param(param.id, LifetimeRes::Error);

14
compiler/rustc_resolve/src/late/diagnostics.rs
View File

@ -2609,8 +2609,8 @@ pub(crate) fn emit_undeclared_lifetime_error(
E0401,
"can't use generic parameters from outer item",
)
.span_label_mv(lifetime_ref.ident.span, "use of generic parameter from outer item")
.span_label_mv(outer.span, "lifetime parameter from outer item")
.with_span_label(lifetime_ref.ident.span, "use of generic parameter from outer item")
.with_span_label(outer.span, "lifetime parameter from outer item")
} else {
struct_span_code_err!(
self.r.dcx(),
@ -2619,7 +2619,7 @@ pub(crate) fn emit_undeclared_lifetime_error(
"use of undeclared lifetime name `{}`",
lifetime_ref.ident
)
.span_label_mv(lifetime_ref.ident.span, "undeclared lifetime")
.with_span_label(lifetime_ref.ident.span, "undeclared lifetime")
};
self.suggest_introducing_lifetime(
&mut err,
@ -3289,8 +3289,8 @@ pub(super) fn signal_lifetime_shadowing(sess: &Session, orig: Ident, shadower: I
"lifetime name `{}` shadows a lifetime name that is already in scope",
orig.name,
)
.span_label_mv(orig.span, "first declared here")
.span_label_mv(shadower.span, format!("lifetime `{}` already in scope", orig.name))
.with_span_label(orig.span, "first declared here")
.with_span_label(shadower.span, format!("lifetime `{}` already in scope", orig.name))
.emit();
}
@ -3322,7 +3322,7 @@ pub(super) fn signal_label_shadowing(sess: &Session, orig: Span, shadower: Ident
shadower,
format!("label name `{name}` shadows a label name that is already in scope"),
)
.span_label_mv(orig, "first declared here")
.span_label_mv(shadower, format!("label `{name}` already in scope"))
.with_span_label(orig, "first declared here")
.with_span_label(shadower, format!("label `{name}` already in scope"))
.emit();
}

8
compiler/rustc_resolve/src/macros.rs
View File

@ -128,7 +128,7 @@ pub(crate) fn registered_tools(tcx: TyCtxt<'_>, (): ()) -> RegisteredTools {
let msg = format!("{} `{}` was already registered", "tool", ident);
tcx.dcx()
.struct_span_err(ident.span, msg)
.span_label_mv(old_ident.span, "already registered here")
.with_span_label(old_ident.span, "already registered here")
.emit();
}
}
@ -137,7 +137,7 @@ pub(crate) fn registered_tools(tcx: TyCtxt<'_>, (): ()) -> RegisteredTools {
let span = nested_meta.span();
tcx.dcx()
.struct_span_err(span, msg)
.span_label_mv(span, "not an identifier")
.with_span_label(span, "not an identifier")
.emit();
}
}
@ -578,7 +578,7 @@ fn smart_resolve_macro_path(
self.dcx()
.create_err(err)
.span_label_mv(path.span, format!("not {article} {expected}"))
.with_span_label(path.span, format!("not {article} {expected}"))
.emit();
return Ok((self.dummy_ext(kind), Res::Err));
@ -954,7 +954,7 @@ pub(crate) fn compile_macro(&mut self, item: &ast::Item, edition: Edition) -> Ma
E0773,
"attempted to define built-in macro more than once"
)
.span_note_mv(span, "previously defined here")
.with_span_note(span, "previously defined here")
.emit();
}
}

4
compiler/rustc_session/src/errors.rs
View File

@ -19,8 +19,8 @@ impl<'a> IntoDiagnostic<'a> for FeatureGateError {
#[track_caller]
fn into_diagnostic(self, dcx: &'a DiagCtxt, level: Level) -> DiagnosticBuilder<'a> {
DiagnosticBuilder::new(dcx, level, self.explain)
.span_mv(self.span)
.code_mv(error_code!(E0658))
.with_span(self.span)
.with_code(error_code!(E0658))
}
}

2
compiler/rustc_session/src/session.rs
View File

@ -1488,7 +1488,7 @@ pub fn initialize_checked_jobserver(&self) {
#[allow(rustc::diagnostic_outside_of_impl)]
self.dcx
.struct_warn(err)
.note_mv("the build environment is likely misconfigured")
.with_note("the build environment is likely misconfigured")
.emit()
});
}

2
compiler/rustc_symbol_mangling/src/errors.rs
View File

@ -18,7 +18,7 @@ fn into_diagnostic(self, dcx: &'_ DiagCtxt, level: Level) -> DiagnosticBuilder<'
let TestOutput { span, kind, content } = self;
#[allow(rustc::untranslatable_diagnostic)]
DiagnosticBuilder::new(dcx, level, format!("{kind}({content})")).span_mv(span)
DiagnosticBuilder::new(dcx, level, format!("{kind}({content})")).with_span(span)
}
}

4
compiler/rustc_trait_selection/src/traits/const_evaluatable.rs
View File

@ -122,8 +122,8 @@ pub fn is_const_evaluatable<'tcx>(
if span == rustc_span::DUMMY_SP { tcx.def_span(uv.def) } else { span },
"failed to evaluate generic const expression",
)
.note_mv("the crate this constant originates from uses `#![feature(generic_const_exprs)]`")
.span_suggestion_verbose_mv(
.with_note("the crate this constant originates from uses `#![feature(generic_const_exprs)]`")
.with_span_suggestion_verbose(
rustc_span::DUMMY_SP,
"consider enabling this feature",
"#![feature(generic_const_exprs)]\n",

10
compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
View File

@ -2661,7 +2661,7 @@ fn maybe_report_ambiguity(&self, obligation: &PredicateObligation<'tcx>) {
ErrorCode::E0284,
true,
)
.note_mv(format!("cannot satisfy `{predicate}`"))
.with_note(format!("cannot satisfy `{predicate}`"))
} else {
// If we can't find a substitution, just print a generic error
struct_span_code_err!(
@ -2671,7 +2671,7 @@ fn maybe_report_ambiguity(&self, obligation: &PredicateObligation<'tcx>) {
"type annotations needed: cannot satisfy `{}`",
predicate,
)
.span_label_mv(span, format!("cannot satisfy `{predicate}`"))
.with_span_label(span, format!("cannot satisfy `{predicate}`"))
}
}
@ -2698,7 +2698,7 @@ fn maybe_report_ambiguity(&self, obligation: &PredicateObligation<'tcx>) {
"type annotations needed: cannot satisfy `{}`",
predicate,
)
.span_label_mv(span, format!("cannot satisfy `{predicate}`"))
.with_span_label(span, format!("cannot satisfy `{predicate}`"))
}
}
_ => {
@ -2712,7 +2712,7 @@ fn maybe_report_ambiguity(&self, obligation: &PredicateObligation<'tcx>) {
"type annotations needed: cannot satisfy `{}`",
predicate,
)
.span_label_mv(span, format!("cannot satisfy `{predicate}`"))
.with_span_label(span, format!("cannot satisfy `{predicate}`"))
}
};
self.note_obligation_cause(&mut err, obligation);
@ -3552,7 +3552,7 @@ fn report_not_const_evaluatable_error(
//
// Note that with `feature(generic_const_exprs)` this case should not
// be reachable.
.note_mv("this may fail depending on what value the parameter takes")
.with_note("this may fail depending on what value the parameter takes")
.emit();
return None;
}

1
compiler/rustc_trait_selection/src/traits/query/normalize.rs
View File

@ -14,6 +14,7 @@
use rustc_middle::ty::fold::{FallibleTypeFolder, TypeFoldable, TypeSuperFoldable};
use rustc_middle::ty::visit::{TypeSuperVisitable, TypeVisitable, TypeVisitableExt};
use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitor};
use rustc_span::DUMMY_SP;
use std::ops::ControlFlow;

2
compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
View File

@ -969,7 +969,7 @@ fn assemble_const_destruct_candidates(
self.tcx().def_span(impl_def_id),
"multiple drop impls found",
)
.span_note_mv(
.with_span_note(
self.tcx().def_span(old_impl_def_id),
"other impl here",
)

2
src/librustdoc/clean/mod.rs
View File

@ -3001,7 +3001,7 @@ fn clean_use_statement_inner<'tcx>(
E0780,
"anonymous imports cannot be inlined"
)
.span_label_mv(import.span, "anonymous import")
.with_span_label(import.span, "anonymous import")
.emit();
}

10
src/librustdoc/config.rs
View File

@ -577,13 +577,13 @@ fn println_condition(condition: Condition) {
{
if !theme_file.is_file() {
dcx.struct_err(format!("invalid argument: \"{theme_s}\""))
.help_mv("arguments to --theme must be files")
.with_help("arguments to --theme must be files")
.emit();
return Err(1);
}
if theme_file.extension() != Some(OsStr::new("css")) {
dcx.struct_err(format!("invalid argument: \"{theme_s}\""))
.help_mv("arguments to --theme must have a .css extension")
.with_help("arguments to --theme must have a .css extension")
.emit();
return Err(1);
}
@ -595,8 +595,8 @@ fn println_condition(condition: Condition) {
dcx.struct_warn(format!(
"theme file \"{theme_s}\" is missing CSS rules from the default theme",
))
.warn_mv("the theme may appear incorrect when loaded")
.help_mv(format!(
.with_warn("the theme may appear incorrect when loaded")
.with_help(format!(
"to see what rules are missing, call `rustdoc --check-theme \"{theme_s}\"`",
))
.emit();
@ -809,7 +809,7 @@ fn check_deprecated_options(matches: &getopts::Matches, dcx: &rustc_errors::Diag
for &flag in deprecated_flags.iter() {
if matches.opt_present(flag) {
dcx.struct_warn(format!("the `{flag}` flag is deprecated"))
.note_mv(
.with_note(
"see issue #44136 <https://github.com/rust-lang/rust/issues/44136> \
for more information",
)

6
src/librustdoc/core.rs
View File

@ -501,9 +501,9 @@ fn visit_path(&mut self, path: &Path<'tcx>, _id: HirId) {
E0433,
"failed to resolve: {label}",
)
.span_label_mv(path.span, label)
.note_mv("this error was originally ignored because you are running `rustdoc`")
.note_mv("try running again with `rustc` or `cargo check` and you may get a more detailed error")
.with_span_label(path.span, label)
.with_note("this error was originally ignored because you are running `rustdoc`")
.with_note("try running again with `rustc` or `cargo check` and you may get a more detailed error")
.emit();
}
// We could have an outer resolution that succeeded,

2
src/librustdoc/passes/collect_intra_doc_links.rs
View File

@ -1228,7 +1228,7 @@ fn report_rawptr_assoc_feature_gate(
span,
"linking to associated items of raw pointers is experimental",
)
.note_mv("rustdoc does not allow disambiguating between `*const` and `*mut`, and pointers are unstable until it does")
.with_note("rustdoc does not allow disambiguating between `*const` and `*mut`, and pointers are unstable until it does")
.emit();
}

2
src/tools/clippy/clippy_config/src/msrvs.rs
View File

@ -109,7 +109,7 @@ fn parse_attr(sess: &Session, attrs: &[Attribute]) -> Option<RustcVersion> {
if let Some(duplicate) = msrv_attrs.last() {
sess.dcx()
.struct_span_err(duplicate.span, "`clippy::msrv` is defined multiple times")
.span_note_mv(msrv_attr.span, "first definition found here")
.with_span_note(msrv_attr.span, "first definition found here")
.emit();
}

2
src/tools/clippy/clippy_utils/src/attrs.rs
View File

@ -136,7 +136,7 @@ pub fn get_unique_attr<'a>(
if let Some(duplicate) = unique_attr {
sess.dcx()
.struct_span_err(attr.span, format!("`{name}` is defined multiple times"))
.span_note_mv(duplicate.span, "first definition found here")
.with_span_note(duplicate.span, "first definition found here")
.emit();
} else {
unique_attr = Some(attr);