diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs
index 35b8de64af7..737e81eb6ec 100644
--- a/compiler/rustc_ast_passes/src/feature_gate.rs
+++ b/compiler/rustc_ast_passes/src/feature_gate.rs
@@ -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();
}
}};
diff --git a/compiler/rustc_ast_passes/src/show_span.rs b/compiler/rustc_ast_passes/src/show_span.rs
index 9882f1d23ce..10590074282 100644
--- a/compiler/rustc_ast_passes/src/show_span.rs
+++ b/compiler/rustc_ast_passes/src/show_span.rs
@@ -38,21 +38,21 @@ struct ShowSpanVisitor<'a> {
impl<'a> Visitor<'a> for ShowSpanVisitor<'a> {
fn visit_expr(&mut self, e: &'a ast::Expr) {
if let Mode::Expression = self.mode {
- self.dcx.emit_warning(errors::ShowSpan { span: e.span, msg: "expression" });
+ self.dcx.emit_warn(errors::ShowSpan { span: e.span, msg: "expression" });
}
visit::walk_expr(self, e);
}
fn visit_pat(&mut self, p: &'a ast::Pat) {
if let Mode::Pattern = self.mode {
- self.dcx.emit_warning(errors::ShowSpan { span: p.span, msg: "pattern" });
+ self.dcx.emit_warn(errors::ShowSpan { span: p.span, msg: "pattern" });
}
visit::walk_pat(self, p);
}
fn visit_ty(&mut self, t: &'a ast::Ty) {
if let Mode::Type = self.mode {
- self.dcx.emit_warning(errors::ShowSpan { span: t.span, msg: "type" });
+ self.dcx.emit_warn(errors::ShowSpan { span: t.span, msg: "type" });
}
visit::walk_ty(self, t);
}
diff --git a/compiler/rustc_attr/src/builtin.rs b/compiler/rustc_attr/src/builtin.rs
index 77678dcaba9..b3f601b7595 100644
--- a/compiler/rustc_attr/src/builtin.rs
+++ b/compiler/rustc_attr/src/builtin.rs
@@ -621,7 +621,7 @@ pub fn eval_condition(
}
};
let Some(min_version) = parse_version(*min_version) else {
- dcx.emit_warning(session_diagnostics::UnknownVersionLiteral { span: *span });
+ dcx.emit_warn(session_diagnostics::UnknownVersionLiteral { span: *span });
return false;
};
diff --git a/compiler/rustc_attr/src/session_diagnostics.rs b/compiler/rustc_attr/src/session_diagnostics.rs
index 5f61a56c189..89606b81a99 100644
--- a/compiler/rustc_attr/src/session_diagnostics.rs
+++ b/compiler/rustc_attr/src/session_diagnostics.rs
@@ -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)
}
}
diff --git a/compiler/rustc_borrowck/src/borrowck_errors.rs b/compiler/rustc_borrowck/src/borrowck_errors.rs
index a9fc0a6f415..351976cdaea 100644
--- a/compiler/rustc_borrowck/src/borrowck_errors.rs
+++ b/compiler/rustc_borrowck/src/borrowck_errors.rs
@@ -1,4 +1,4 @@
-use rustc_errors::{struct_span_err, DiagCtxt, DiagnosticBuilder};
+use rustc_errors::{struct_span_code_err, DiagCtxt, DiagnosticBuilder};
use rustc_middle::ty::{self, Ty, TyCtxt};
use rustc_span::Span;
@@ -31,15 +31,15 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
borrow_span: Span,
borrow_desc: &str,
) -> DiagnosticBuilder<'tcx> {
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
span,
E0503,
"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(
@@ -52,7 +52,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
old_load_end_span: Option<Span>,
) -> DiagnosticBuilder<'tcx> {
let via = |msg: &str| if msg.is_empty() { "".to_string() } else { format!(" (via {msg})") };
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.dcx(),
new_loan_span,
E0499,
@@ -98,7 +98,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
old_loan_span: Span,
old_load_end_span: Option<Span>,
) -> DiagnosticBuilder<'tcx> {
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.dcx(),
new_loan_span,
E0524,
@@ -131,7 +131,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
old_opt_via: &str,
previous_end_span: Option<Span>,
) -> DiagnosticBuilder<'cx> {
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.dcx(),
new_loan_span,
E0500,
@@ -163,7 +163,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
previous_end_span: Option<Span>,
second_borrow_desc: &str,
) -> DiagnosticBuilder<'cx> {
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.dcx(),
new_loan_span,
E0501,
@@ -196,7 +196,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
old_load_end_span: Option<Span>,
) -> DiagnosticBuilder<'cx> {
let via = |msg: &str| if msg.is_empty() { "".to_string() } else { format!(" (via {msg})") };
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.dcx(),
span,
E0502,
@@ -236,15 +236,15 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
borrow_span: Span,
desc: &str,
) -> DiagnosticBuilder<'cx> {
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
span,
E0506,
"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(
@@ -254,11 +254,11 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
is_arg: bool,
) -> DiagnosticBuilder<'cx> {
let msg = if is_arg { "to immutable argument" } else { "twice to immutable variable" };
- struct_span_err!(self.dcx(), span, E0384, "cannot assign {} {}", msg, desc)
+ struct_span_code_err!(self.dcx(), span, E0384, "cannot assign {} {}", msg, desc)
}
pub(crate) fn cannot_assign(&self, span: Span, desc: &str) -> DiagnosticBuilder<'tcx> {
- struct_span_err!(self.dcx(), span, E0594, "cannot assign to {}", desc)
+ struct_span_code_err!(self.dcx(), span, E0594, "cannot assign to {}", desc)
}
pub(crate) fn cannot_move_out_of(
@@ -266,7 +266,13 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
move_from_span: Span,
move_from_desc: &str,
) -> DiagnosticBuilder<'cx> {
- struct_span_err!(self.dcx(), move_from_span, E0507, "cannot move out of {}", move_from_desc)
+ struct_span_code_err!(
+ self.dcx(),
+ move_from_span,
+ E0507,
+ "cannot move out of {}",
+ move_from_desc
+ )
}
/// Signal an error due to an attempt to move out of the interior
@@ -283,7 +289,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
(&ty::Slice(_), _) => "slice",
_ => span_bug!(move_from_span, "this path should not cause illegal move"),
};
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
move_from_span,
E0508,
@@ -291,7 +297,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
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(
@@ -299,14 +305,14 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
move_from_span: Span,
container_ty: Ty<'_>,
) -> DiagnosticBuilder<'cx> {
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
move_from_span,
E0509,
"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(
@@ -318,7 +324,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
) -> DiagnosticBuilder<'tcx> {
let moved_path = moved_path.map(|mp| format!(": `{mp}`")).unwrap_or_default();
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
use_span,
E0382,
@@ -335,7 +341,14 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
path: &str,
reason: &str,
) -> DiagnosticBuilder<'tcx> {
- struct_span_err!(self.dcx(), span, E0596, "cannot borrow {} as mutable{}", path, reason)
+ struct_span_code_err!(
+ self.dcx(),
+ span,
+ E0596,
+ "cannot borrow {} as mutable{}",
+ path,
+ reason
+ )
}
pub(crate) fn cannot_mutate_in_immutable_section(
@@ -346,7 +359,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
immutable_section: &str,
action: &str,
) -> DiagnosticBuilder<'tcx> {
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
mutate_span,
E0510,
@@ -355,8 +368,8 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
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(
@@ -365,20 +378,20 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
yield_span: Span,
) -> DiagnosticBuilder<'tcx> {
let coroutine_kind = self.body.coroutine.as_ref().unwrap().coroutine_kind;
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
span,
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(
&self,
borrow_span: Span,
) -> DiagnosticBuilder<'tcx> {
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
borrow_span,
E0713,
@@ -391,7 +404,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
span: Span,
path: &str,
) -> DiagnosticBuilder<'tcx> {
- struct_span_err!(self.dcx(), span, E0597, "{} does not live long enough", path,)
+ struct_span_code_err!(self.dcx(), span, E0597, "{} does not live long enough", path,)
}
pub(crate) fn cannot_return_reference_to_local(
@@ -401,7 +414,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
reference_desc: &str,
path_desc: &str,
) -> DiagnosticBuilder<'tcx> {
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
span,
E0515,
@@ -410,7 +423,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
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"),
)
@@ -424,22 +437,22 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
capture_span: Span,
scope: &str,
) -> DiagnosticBuilder<'tcx> {
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
closure_span,
E0373,
"{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(
&self,
span: Span,
) -> DiagnosticBuilder<'tcx> {
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
span,
E0712,
@@ -451,7 +464,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
&self,
span: Span,
) -> DiagnosticBuilder<'tcx> {
- struct_span_err!(self.dcx(), span, E0716, "temporary value dropped while borrowed",)
+ struct_span_code_err!(self.dcx(), span, E0716, "temporary value dropped while borrowed",)
}
}
@@ -460,7 +473,7 @@ pub(crate) fn borrowed_data_escapes_closure<'tcx>(
escape_span: Span,
escapes_from: &str,
) -> DiagnosticBuilder<'tcx> {
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
escape_span,
E0521,
diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
index 5baa108ed3c..b4a73574aa2 100644
--- a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -1,7 +1,9 @@
+// ignore-tidy-filelength
+
use either::Either;
use rustc_data_structures::captures::Captures;
use rustc_data_structures::fx::FxIndexSet;
-use rustc_errors::{struct_span_err, Applicability, Diagnostic, DiagnosticBuilder, MultiSpan};
+use rustc_errors::{struct_span_code_err, Applicability, Diagnostic, DiagnosticBuilder, MultiSpan};
use rustc_hir as hir;
use rustc_hir::def::{DefKind, Res};
use rustc_hir::intravisit::{walk_block, walk_expr, Visitor};
@@ -550,8 +552,12 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
};
let used = desired_action.as_general_verb_in_past_tense();
- let mut err =
- struct_span_err!(self.dcx(), span, E0381, "{used} binding {desc}{isnt_initialized}");
+ let mut err = struct_span_code_err!(
+ self.dcx(),
+ span,
+ E0381,
+ "{used} binding {desc}{isnt_initialized}"
+ );
use_spans.var_path_only_subdiag(&mut err, desired_action);
if let InitializationRequiringAction::PartialAssignment
@@ -2219,11 +2225,11 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
);
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))]
diff --git a/compiler/rustc_borrowck/src/diagnostics/move_errors.rs b/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
index 50dde5ce636..fb3525e8998 100644
--- a/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
@@ -334,9 +334,9 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
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 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
);
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"),
)
diff --git a/compiler/rustc_borrowck/src/diagnostics/region_errors.rs b/compiler/rustc_borrowck/src/diagnostics/region_errors.rs
index 020429c1914..8c8ca1ead40 100644
--- a/compiler/rustc_borrowck/src/diagnostics/region_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/region_errors.rs
@@ -27,7 +27,7 @@ use rustc_middle::ty::TypeVisitor;
use rustc_middle::ty::{self, RegionVid, Ty};
use rustc_middle::ty::{Region, TyCtxt};
use rustc_span::symbol::{kw, Ident};
-use rustc_span::{Span, DUMMY_SP};
+use rustc_span::Span;
use crate::borrowck_errors;
use crate::session_diagnostics::{
@@ -84,7 +84,7 @@ impl<'tcx> RegionErrors<'tcx> {
#[track_caller]
pub fn push(&mut self, val: impl Into<RegionErrorKind<'tcx>>) {
let val = val.into();
- self.1.sess.dcx().span_delayed_bug(DUMMY_SP, format!("{val:?}"));
+ self.1.sess.dcx().delayed_bug(format!("{val:?}"));
self.0.push(val);
}
pub fn is_empty(&self) -> bool {
diff --git a/compiler/rustc_borrowck/src/region_infer/opaque_types.rs b/compiler/rustc_borrowck/src/region_infer/opaque_types.rs
index 5f427a5ac80..462b5c8da42 100644
--- a/compiler/rustc_borrowck/src/region_infer/opaque_types.rs
+++ b/compiler/rustc_borrowck/src/region_infer/opaque_types.rs
@@ -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());
}
}
diff --git a/compiler/rustc_builtin_macros/src/asm.rs b/compiler/rustc_builtin_macros/src/asm.rs
index d0e13fa3c0f..0b2e63b403b 100644
--- a/compiler/rustc_builtin_macros/src/asm.rs
+++ b/compiler/rustc_builtin_macros/src/asm.rs
@@ -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} */\"`"
))
diff --git a/compiler/rustc_builtin_macros/src/errors.rs b/compiler/rustc_builtin_macros/src/errors.rs
index 13e5a40ca9e..d6dfd0efaf9 100644
--- a/compiler/rustc_builtin_macros/src/errors.rs
+++ b/compiler/rustc_builtin_macros/src/errors.rs
@@ -817,9 +817,9 @@ impl<'a, G: EmissionGuarantee> IntoDiagnostic<'a, G> for AsmClobberNoReg {
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)
}
}
diff --git a/compiler/rustc_builtin_macros/src/proc_macro_harness.rs b/compiler/rustc_builtin_macros/src/proc_macro_harness.rs
index 9fb6da6e012..477e5c8bec5 100644
--- a/compiler/rustc_builtin_macros/src/proc_macro_harness.rs
+++ b/compiler/rustc_builtin_macros/src/proc_macro_harness.rs
@@ -194,7 +194,7 @@ impl<'a> Visitor<'a> for CollectProcMacros<'a> {
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;
diff --git a/compiler/rustc_builtin_macros/src/source_util.rs b/compiler/rustc_builtin_macros/src/source_util.rs
index caebb12919f..e7d7b4a7012 100644
--- a/compiler/rustc_builtin_macros/src/source_util.rs
+++ b/compiler/rustc_builtin_macros/src/source_util.rs
@@ -155,7 +155,7 @@ pub fn expand_include<'cx>(
if self.p.token != token::Eof {
let token = pprust::token_to_string(&self.p.token);
let msg = format!("expected item, found `{token}`");
- self.p.dcx().struct_span_err(self.p.token.span, msg).emit();
+ self.p.dcx().span_err(self.p.token.span, msg);
}
break;
diff --git a/compiler/rustc_builtin_macros/src/test.rs b/compiler/rustc_builtin_macros/src/test.rs
index 717f5d9c38a..298bdc557ab 100644
--- a/compiler/rustc_builtin_macros/src/test.rs
+++ b/compiler/rustc_builtin_macros/src/test.rs
@@ -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",
diff --git a/compiler/rustc_codegen_gcc/src/gcc_util.rs b/compiler/rustc_codegen_gcc/src/gcc_util.rs
index df917d527ce..4babe5bfb81 100644
--- a/compiler/rustc_codegen_gcc/src/gcc_util.rs
+++ b/compiler/rustc_codegen_gcc/src/gcc_util.rs
@@ -52,7 +52,7 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri
Some(c @ ('+' | '-')) => c,
Some(_) => {
if diagnostics {
- sess.dcx().emit_warning(UnknownCTargetFeaturePrefix { feature: s });
+ sess.dcx().emit_warn(UnknownCTargetFeaturePrefix { feature: s });
}
return None;
}
@@ -79,7 +79,7 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri
else {
UnknownCTargetFeature { feature, rust_feature: PossibleFeature::None }
};
- sess.dcx().emit_warning(unknown_feature);
+ sess.dcx().emit_warn(unknown_feature);
}
if diagnostics {
diff --git a/compiler/rustc_codegen_gcc/src/lib.rs b/compiler/rustc_codegen_gcc/src/lib.rs
index f69f850c1d4..03f8f43ff16 100644
--- a/compiler/rustc_codegen_gcc/src/lib.rs
+++ b/compiler/rustc_codegen_gcc/src/lib.rs
@@ -191,7 +191,7 @@ impl CodegenBackend for GccCodegenBackend {
#[cfg(feature="master")]
gccjit::set_global_personality_function_name(b"rust_eh_personality\0");
if sess.lto() == Lto::Thin {
- sess.dcx().emit_warning(LTONotSupported {});
+ sess.dcx().emit_warn(LTONotSupported {});
}
#[cfg(not(feature="master"))]
diff --git a/compiler/rustc_codegen_llvm/src/back/write.rs b/compiler/rustc_codegen_llvm/src/back/write.rs
index 45be85934b4..deffb10c759 100644
--- a/compiler/rustc_codegen_llvm/src/back/write.rs
+++ b/compiler/rustc_codegen_llvm/src/back/write.rs
@@ -245,12 +245,12 @@ pub fn target_machine_factory(
match sess.opts.debuginfo_compression {
rustc_session::config::DebugInfoCompression::Zlib => {
if !unsafe { LLVMRustLLVMHasZlibCompressionForDebugSymbols() } {
- sess.dcx().emit_warning(UnknownCompression { algorithm: "zlib" });
+ sess.dcx().emit_warn(UnknownCompression { algorithm: "zlib" });
}
}
rustc_session::config::DebugInfoCompression::Zstd => {
if !unsafe { LLVMRustLLVMHasZstdCompressionForDebugSymbols() } {
- sess.dcx().emit_warning(UnknownCompression { algorithm: "zstd" });
+ sess.dcx().emit_warn(UnknownCompression { algorithm: "zstd" });
}
}
rustc_session::config::DebugInfoCompression::None => {}
@@ -457,7 +457,7 @@ unsafe extern "C" fn diagnostic_handler(info: &DiagnosticInfo, user: *mut c_void
llvm::LLVMRustWriteDiagnosticInfoToString(diagnostic_ref, s)
})
.expect("non-UTF8 diagnostic");
- dcx.emit_warning(FromLlvmDiag { message });
+ dcx.emit_warn(FromLlvmDiag { message });
}
llvm::diagnostic::Unsupported(diagnostic_ref) => {
let message = llvm::build_string(|s| {
diff --git a/compiler/rustc_codegen_llvm/src/errors.rs b/compiler/rustc_codegen_llvm/src/errors.rs
index 6e2c0dc21ad..697ce602298 100644
--- a/compiler/rustc_codegen_llvm/src/errors.rs
+++ b/compiler/rustc_codegen_llvm/src/errors.rs
@@ -106,7 +106,7 @@ impl<G: EmissionGuarantee> IntoDiagnostic<'_, G> for ParseTargetMachineConfig<'_
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 @@ impl<G: EmissionGuarantee> IntoDiagnostic<'_, G> for WithLlvmError<'_> {
};
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)
}
}
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index 03b79a143cc..99f4488ac0f 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -529,7 +529,7 @@ pub(crate) fn global_llvm_features(sess: &Session, diagnostics: bool) -> Vec<Str
Some(c @ ('+' | '-')) => c,
Some(_) => {
if diagnostics {
- sess.dcx().emit_warning(UnknownCTargetFeaturePrefix { feature: s });
+ sess.dcx().emit_warn(UnknownCTargetFeaturePrefix { feature: s });
}
return None;
}
@@ -557,12 +557,12 @@ pub(crate) fn global_llvm_features(sess: &Session, diagnostics: bool) -> Vec<Str
} else {
UnknownCTargetFeature { feature, rust_feature: PossibleFeature::None }
};
- sess.dcx().emit_warning(unknown_feature);
+ sess.dcx().emit_warn(unknown_feature);
} else if feature_state
.is_some_and(|(_name, feature_gate)| !feature_gate.is_stable())
{
// An unstable feature. Warn about using it.
- sess.dcx().emit_warning(UnstableCTargetFeature { feature });
+ sess.dcx().emit_warn(UnstableCTargetFeature { feature });
}
}
diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index 215649f33ff..70fda982b01 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -1016,7 +1016,7 @@ fn link_natively<'a>(
if !prog.status.success() {
let mut output = prog.stderr.clone();
output.extend_from_slice(&prog.stdout);
- sess.dcx().emit_warning(errors::ProcessingDymutilFailed {
+ sess.dcx().emit_warn(errors::ProcessingDymutilFailed {
status: prog.status,
output: escape_string(&output),
});
@@ -1091,7 +1091,7 @@ fn strip_symbols_with_external_utility<'a>(
if !prog.status.success() {
let mut output = prog.stderr.clone();
output.extend_from_slice(&prog.stdout);
- sess.dcx().emit_warning(errors::StrippingDebugInfoFailed {
+ sess.dcx().emit_warn(errors::StrippingDebugInfoFailed {
util,
status: prog.status,
output: escape_string(&output),
@@ -2406,7 +2406,7 @@ fn collect_natvis_visualizers(
visualizer_paths.push(visualizer_out_file);
}
Err(error) => {
- sess.dcx().emit_warning(errors::UnableToWriteDebuggerVisualizer {
+ sess.dcx().emit_warn(errors::UnableToWriteDebuggerVisualizer {
path: visualizer_out_file,
error,
});
diff --git a/compiler/rustc_codegen_ssa/src/back/linker.rs b/compiler/rustc_codegen_ssa/src/back/linker.rs
index 695aeb0b2fb..90f5027c264 100644
--- a/compiler/rustc_codegen_ssa/src/back/linker.rs
+++ b/compiler/rustc_codegen_ssa/src/back/linker.rs
@@ -446,11 +446,11 @@ impl<'a> Linker for GccLinker<'a> {
// FIXME(81490): ld64 doesn't support these flags but macOS 11
// has -needed-l{} / -needed_library {}
// but we have no way to detect that here.
- self.sess.dcx().emit_warning(errors::Ld64UnimplementedModifier);
+ self.sess.dcx().emit_warn(errors::Ld64UnimplementedModifier);
} else if self.is_gnu && !self.sess.target.is_like_windows {
self.linker_arg("--no-as-needed");
} else {
- self.sess.dcx().emit_warning(errors::LinkerUnsupportedModifier);
+ self.sess.dcx().emit_warn(errors::LinkerUnsupportedModifier);
}
}
self.hint_dynamic();
@@ -504,7 +504,7 @@ impl<'a> Linker for GccLinker<'a> {
// FIXME(81490): ld64 as of macOS 11 supports the -needed_framework
// flag but we have no way to detect that here.
// self.cmd.arg("-needed_framework").arg(framework);
- self.sess.dcx().emit_warning(errors::Ld64UnimplementedModifier);
+ self.sess.dcx().emit_warn(errors::Ld64UnimplementedModifier);
}
self.cmd.arg("-framework").arg(framework);
}
@@ -950,7 +950,7 @@ impl<'a> Linker for MsvcLinker<'a> {
}
}
Err(error) => {
- self.sess.dcx().emit_warning(errors::NoNatvisDirectory { error });
+ self.sess.dcx().emit_warn(errors::NoNatvisDirectory { error });
}
}
}
@@ -1501,7 +1501,7 @@ impl<'a> Linker for L4Bender<'a> {
fn export_symbols(&mut self, _: &Path, _: CrateType, _: &[String]) {
// ToDo, not implemented, copy from GCC
- self.sess.dcx().emit_warning(errors::L4BenderExportingSymbolsUnimplemented);
+ self.sess.dcx().emit_warn(errors::L4BenderExportingSymbolsUnimplemented);
return;
}
diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index d2c6b6e0c7b..6c066e61a58 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -573,11 +573,11 @@ fn produce_final_output_artifacts(
if crate_output.outputs.contains_key(&output_type) {
// 2) Multiple codegen units, with `--emit foo=some_name`. We have
// no good solution for this case, so warn the user.
- sess.dcx().emit_warning(errors::IgnoringEmitPath { extension });
+ sess.dcx().emit_warn(errors::IgnoringEmitPath { extension });
} else if crate_output.single_output_file.is_some() {
// 3) Multiple codegen units, with `-o some_name`. We have
// no good solution for this case, so warn the user.
- sess.dcx().emit_warning(errors::IgnoringOutput { extension });
+ sess.dcx().emit_warn(errors::IgnoringOutput { extension });
} else {
// 4) Multiple codegen units, but no explicit name. We
// just leave the `foo.0.x` files in place.
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index f53067d194a..36d7234a6ea 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -1,6 +1,6 @@
use rustc_ast::{ast, attr, MetaItemKind, NestedMetaItem};
use rustc_attr::{list_contains_name, InlineAttr, InstructionSetAttr, OptimizeAttr};
-use rustc_errors::struct_span_err;
+use rustc_errors::struct_span_code_err;
use rustc_hir as hir;
use rustc_hir::def::DefKind;
use rustc_hir::def_id::{DefId, LocalDefId, LOCAL_CRATE};
@@ -216,7 +216,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
if let Some(fn_sig) = fn_sig()
&& !matches!(fn_sig.skip_binder().abi(), abi::Abi::C { .. })
{
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
attr.span,
E0776,
@@ -225,7 +225,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
.emit();
}
if !tcx.sess.target.llvm_target.contains("thumbv8m") {
- struct_span_err!(tcx.dcx(), attr.span, E0775, "`#[cmse_nonsecure_entry]` is only valid for targets with the TrustZone-M extension")
+ struct_span_code_err!(tcx.dcx(), attr.span, E0775, "`#[cmse_nonsecure_entry]` is only valid for targets with the TrustZone-M extension")
.emit();
}
codegen_fn_attrs.flags |= CodegenFnAttrFlags::CMSE_NONSECURE_ENTRY
@@ -238,7 +238,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
&& let Some(fn_sig) = fn_sig()
&& fn_sig.skip_binder().abi() != abi::Abi::Rust
{
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
attr.span,
E0737,
@@ -265,7 +265,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
if s.as_str().contains('\0') {
// `#[export_name = ...]` will be converted to a null-terminated string,
// so it may not contain any null characters.
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
attr.span,
E0648,
@@ -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);
@@ -385,7 +385,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
match segments.as_slice() {
[sym::arm, sym::a32] | [sym::arm, sym::t32] => {
if !tcx.sess.target.has_thumb_interworking {
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
attr.span,
E0779,
@@ -402,7 +402,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
}
}
_ => {
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
attr.span,
E0779,
@@ -414,7 +414,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
}
}
[] => {
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
attr.span,
E0778,
@@ -424,7 +424,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
None
}
_ => {
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
attr.span,
E0779,
@@ -442,7 +442,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
{
rustc_attr::parse_alignment(&literal.kind)
.map_err(|msg| {
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
attr.span,
E0589,
@@ -469,15 +469,16 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
Some(MetaItemKind::List(ref items)) => {
inline_span = Some(attr.span);
if items.len() != 1 {
- struct_span_err!(tcx.dcx(), attr.span, E0534, "expected one argument").emit();
+ struct_span_code_err!(tcx.dcx(), attr.span, E0534, "expected one argument")
+ .emit();
InlineAttr::None
} else if list_contains_name(items, sym::always) {
InlineAttr::Always
} else if list_contains_name(items, sym::never) {
InlineAttr::Never
} else {
- struct_span_err!(tcx.dcx(), items[0].span(), E0535, "invalid argument")
- .help_mv("valid inline arguments are `always` and `never`")
+ struct_span_code_err!(tcx.dcx(), items[0].span(), E0535, "invalid argument")
+ .with_help("valid inline arguments are `always` and `never`")
.emit();
InlineAttr::None
@@ -492,7 +493,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
if !attr.has_name(sym::optimize) {
return ia;
}
- let err = |sp, s| struct_span_err!(tcx.dcx(), sp, E0722, "{}", s).emit();
+ let err = |sp, s| struct_span_code_err!(tcx.dcx(), sp, E0722, "{}", s).emit();
match attr.meta_kind() {
Some(MetaItemKind::Word) => {
err(attr.span, "expected one argument");
@@ -662,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
}
diff --git a/compiler/rustc_codegen_ssa/src/errors.rs b/compiler/rustc_codegen_ssa/src/errors.rs
index 7e3b69fa52f..f90e1906caf 100644
--- a/compiler/rustc_codegen_ssa/src/errors.rs
+++ b/compiler/rustc_codegen_ssa/src/errors.rs
@@ -230,25 +230,25 @@ impl<G: EmissionGuarantee> IntoDiagnostic<'_, G> for ThorinErrorWrapper {
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 @@ impl<G: EmissionGuarantee> IntoDiagnostic<'_, G> for ThorinErrorWrapper {
}
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 @@ impl<G: EmissionGuarantee> IntoDiagnostic<'_, G> for ThorinErrorWrapper {
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 @@ impl<G: EmissionGuarantee> IntoDiagnostic<'_, G> for ThorinErrorWrapper {
}
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 @@ impl<G: EmissionGuarantee> IntoDiagnostic<'_, G> for ThorinErrorWrapper {
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"),
}
diff --git a/compiler/rustc_codegen_ssa/src/target_features.rs b/compiler/rustc_codegen_ssa/src/target_features.rs
index c0ce8a54af5..0fef6bc110e 100644
--- a/compiler/rustc_codegen_ssa/src/target_features.rs
+++ b/compiler/rustc_codegen_ssa/src/target_features.rs
@@ -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();
diff --git a/compiler/rustc_const_eval/src/const_eval/machine.rs b/compiler/rustc_const_eval/src/const_eval/machine.rs
index 7fb5f10c6ca..6947ace17c5 100644
--- a/compiler/rustc_const_eval/src/const_eval/machine.rs
+++ b/compiler/rustc_const_eval/src/const_eval/machine.rs
@@ -391,10 +391,10 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
if ecx.tcx.is_ctfe_mir_available(def) {
Ok(ecx.tcx.mir_for_ctfe(def))
} else if ecx.tcx.def_kind(def) == DefKind::AssocConst {
- let guar = ecx.tcx.dcx().span_delayed_bug(
- rustc_span::DUMMY_SP,
- "This is likely a const item that is missing from its impl",
- );
+ let guar = ecx
+ .tcx
+ .dcx()
+ .delayed_bug("This is likely a const item that is missing from its impl");
throw_inval!(AlreadyReported(guar.into()));
} else {
// `find_mir_or_eval_fn` checks that this is a const fn before even calling us,
@@ -630,7 +630,7 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
// current number of evaluated terminators is a power of 2. The latter gives us a cheap
// way to implement exponential backoff.
let span = ecx.cur_span();
- ecx.tcx.dcx().emit_warning(LongRunningWarn { span, item_span: ecx.tcx.span });
+ ecx.tcx.dcx().emit_warn(LongRunningWarn { span, item_span: ecx.tcx.span });
}
}
diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index 3047f5d47e4..2e4baf26176 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -1429,7 +1429,7 @@ fn report_ice(
}
Err(err) => {
// The path ICE couldn't be written to disk, provide feedback to the user as to why.
- dcx.emit_warning(session_diagnostics::IcePathError {
+ dcx.emit_warn(session_diagnostics::IcePathError {
path: path.clone(),
error: err.to_string(),
env_var: std::env::var_os("RUSTC_ICE")
diff --git a/compiler/rustc_errors/src/diagnostic_builder.rs b/compiler/rustc_errors/src/diagnostic_builder.rs
index 3789cdaf354..a02909f29c4 100644
--- a/compiler/rustc_errors/src/diagnostic_builder.rs
+++ b/compiler/rustc_errors/src/diagnostic_builder.rs
@@ -30,7 +30,7 @@ where
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 @@ impl EmissionGuarantee for rustc_span::fatal_error::FatalError {
/// `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
}
};
@@ -265,7 +265,7 @@ impl<'a, G: EmissionGuarantee> DiagnosticBuilder<'a, G> {
/// Converts the builder to a `Diagnostic` for later emission,
/// unless dcx has disabled such buffering.
- pub fn into_diagnostic(mut self) -> Option<(Diagnostic, &'a DiagCtxt)> {
+ fn into_diagnostic(mut self) -> Option<(Diagnostic, &'a DiagCtxt)> {
if self.dcx.inner.lock().flags.treat_err_as_bug.is_some() {
self.emit();
return None;
@@ -302,21 +302,21 @@ impl<'a, G: EmissionGuarantee> DiagnosticBuilder<'a, G> {
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,110 @@ impl<'a, G: EmissionGuarantee> DiagnosticBuilder<'a, G> {
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,
+ ));
+ forward!((eager_subdiagnostic, with_eager_subdiagnostic)(
+ dcx: &DiagCtxt,
subdiagnostic: impl crate::AddToDiagnostic,
));
}
@@ -453,13 +457,13 @@ impl<G: EmissionGuarantee> Drop for DiagnosticBuilder<'_, G> {
}
#[macro_export]
-macro_rules! struct_span_err {
+macro_rules! struct_span_code_err {
($dcx:expr, $span:expr, $code:ident, $($message:tt)*) => ({
$dcx.struct_span_err(
$span,
format!($($message)*),
)
- .code_mv($crate::error_code!($code))
+ .with_code($crate::error_code!($code))
})
}
diff --git a/compiler/rustc_errors/src/diagnostic_impls.rs b/compiler/rustc_errors/src/diagnostic_impls.rs
index 58d4d2caf2e..39252dea283 100644
--- a/compiler/rustc_errors/src/diagnostic_impls.rs
+++ b/compiler/rustc_errors/src/diagnostic_impls.rs
@@ -252,40 +252,40 @@ impl<G: EmissionGuarantee> IntoDiagnostic<'_, G> for TargetDataLayoutErrors<'_>
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)
}
}
}
diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index 76b7e0d79a9..1f5ad56a42a 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -727,7 +727,7 @@ impl DiagCtxt {
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 @@ impl DiagCtxt {
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 @@ impl DiagCtxt {
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 @@ impl DiagCtxt {
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]
@@ -865,10 +865,16 @@ impl DiagCtxt {
/// For example, it can be used to create an [`ErrorGuaranteed`]
/// (but you should prefer threading through the [`ErrorGuaranteed`] from an error emission
/// directly).
- ///
- /// If no span is available, use [`DUMMY_SP`].
- ///
- /// [`DUMMY_SP`]: rustc_span::DUMMY_SP
+ #[track_caller]
+ pub fn delayed_bug(&self, msg: impl Into<DiagnosticMessage>) -> ErrorGuaranteed {
+ let treat_next_err_as_bug = self.inner.borrow().treat_next_err_as_bug();
+ if treat_next_err_as_bug {
+ self.bug(msg);
+ }
+ DiagnosticBuilder::<ErrorGuaranteed>::new(self, DelayedBug, msg).emit()
+ }
+
+ /// Like `delayed_bug`, but takes an additional span.
///
/// Note: this function used to be called `delay_span_bug`. It was renamed
/// to match similar functions like `span_err`, `span_warn`, etc.
@@ -882,9 +888,7 @@ impl DiagCtxt {
if treat_next_err_as_bug {
self.span_bug(sp, msg);
}
- let mut diagnostic = Diagnostic::new(DelayedBug, msg);
- diagnostic.span(sp);
- self.emit_diagnostic(diagnostic).unwrap()
+ DiagnosticBuilder::<ErrorGuaranteed>::new(self, DelayedBug, msg).with_span(sp).emit()
}
// FIXME(eddyb) note the comment inside `impl Drop for DiagCtxtInner`, that's
@@ -909,7 +913,7 @@ impl DiagCtxt {
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]
@@ -1086,7 +1090,7 @@ impl DiagCtxt {
}
#[track_caller]
- pub fn create_warning<'a>(
+ pub fn create_warn<'a>(
&'a self,
warning: impl IntoDiagnostic<'a, ()>,
) -> DiagnosticBuilder<'a, ()> {
@@ -1094,8 +1098,8 @@ impl DiagCtxt {
}
#[track_caller]
- pub fn emit_warning<'a>(&'a self, warning: impl IntoDiagnostic<'a, ()>) {
- self.create_warning(warning).emit()
+ pub fn emit_warn<'a>(&'a self, warning: impl IntoDiagnostic<'a, ()>) {
+ self.create_warn(warning).emit()
}
#[track_caller]
@@ -1227,7 +1231,7 @@ impl DiagCtxt {
// Note: we prefer implementing operations on `DiagCtxt`, rather than
// `DiagCtxtInner`, whenever possible. This minimizes functions where
// `DiagCtxt::foo()` just borrows `inner` and forwards a call to
-// `HanderInner::foo`.
+// `DiagCtxtInner::foo`.
impl DiagCtxtInner {
/// Emit all stashed diagnostics.
fn emit_stashed_diagnostics(&mut self) -> Option<ErrorGuaranteed> {
diff --git a/compiler/rustc_expand/src/mbe/diagnostics.rs b/compiler/rustc_expand/src/mbe/diagnostics.rs
index 2746e888b8d..eec86c36aed 100644
--- a/compiler/rustc_expand/src/mbe/diagnostics.rs
+++ b/compiler/rustc_expand/src/mbe/diagnostics.rs
@@ -180,7 +180,7 @@ impl<'a, 'cx, 'matcher> Tracker<'matcher> for CollectTrackerAndEmitter<'a, 'cx,
}
Error(err_sp, msg) => {
let span = err_sp.substitute_dummy(self.root_span);
- self.cx.dcx().struct_span_err(span, msg.clone()).emit();
+ self.cx.dcx().span_err(span, msg.clone());
self.result = Some(DummyResult::any(span));
}
ErrorReported(_) => self.result = Some(DummyResult::any(self.root_span)),
diff --git a/compiler/rustc_expand/src/mbe/macro_parser.rs b/compiler/rustc_expand/src/mbe/macro_parser.rs
index b86831b8222..ac5136539c3 100644
--- a/compiler/rustc_expand/src/mbe/macro_parser.rs
+++ b/compiler/rustc_expand/src/mbe/macro_parser.rs
@@ -680,7 +680,7 @@ impl TtParser {
// 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"
diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs
index 68296700987..a56c980791a 100644
--- a/compiler/rustc_expand/src/mbe/macro_rules.rs
+++ b/compiler/rustc_expand/src/mbe/macro_rules.rs
@@ -458,7 +458,7 @@ pub fn compile_declarative_macro(
return dummy_syn_ext();
}
Error(sp, msg) => {
- sess.dcx().struct_span_err(sp.substitute_dummy(def.span), msg).emit();
+ sess.dcx().span_err(sp.substitute_dummy(def.span), msg);
return dummy_syn_ext();
}
ErrorReported(_) => {
diff --git a/compiler/rustc_expand/src/mbe/quoted.rs b/compiler/rustc_expand/src/mbe/quoted.rs
index c3e4f40c166..889f43ed203 100644
--- a/compiler/rustc_expand/src/mbe/quoted.rs
+++ b/compiler/rustc_expand/src/mbe/quoted.rs
@@ -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
},
diff --git a/compiler/rustc_hir_analysis/src/astconv/bounds.rs b/compiler/rustc_hir_analysis/src/astconv/bounds.rs
index 38184a5dd18..1f88aaa6a4b 100644
--- a/compiler/rustc_hir_analysis/src/astconv/bounds.rs
+++ b/compiler/rustc_hir_analysis/src/astconv/bounds.rs
@@ -1,5 +1,5 @@
use rustc_data_structures::fx::FxHashMap;
-use rustc_errors::struct_span_err;
+use rustc_errors::struct_span_code_err;
use rustc_hir as hir;
use rustc_hir::def::{DefKind, Res};
use rustc_hir::def_id::{DefId, LocalDefId};
@@ -305,7 +305,7 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
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);
@@ -462,7 +462,7 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
late_bound_in_trait_ref,
late_bound_in_ty,
|br_name| {
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
binding.span,
E0582,
diff --git a/compiler/rustc_hir_analysis/src/astconv/errors.rs b/compiler/rustc_hir_analysis/src/astconv/errors.rs
index 24b55461a42..fc2ed104b3d 100644
--- a/compiler/rustc_hir_analysis/src/astconv/errors.rs
+++ b/compiler/rustc_hir_analysis/src/astconv/errors.rs
@@ -7,7 +7,7 @@ use crate::fluent_generated as fluent;
use crate::traits::error_reporting::report_object_safety_error;
use rustc_data_structures::fx::{FxHashMap, FxIndexMap, FxIndexSet};
use rustc_data_structures::unord::UnordMap;
-use rustc_errors::{pluralize, struct_span_err, Applicability, Diagnostic, ErrorGuaranteed};
+use rustc_errors::{pluralize, struct_span_code_err, Applicability, Diagnostic, ErrorGuaranteed};
use rustc_hir as hir;
use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_infer::traits::FulfillmentError;
@@ -346,7 +346,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
candidates: Vec<DefId>,
span: Span,
) -> ErrorGuaranteed {
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.tcx().dcx(),
name.span,
E0034,
@@ -445,7 +445,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
String::new()
};
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
tcx.dcx(),
name.span,
E0220,
@@ -697,7 +697,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
let names = names.join(", ");
trait_bound_spans.sort();
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
tcx.dcx(),
trait_bound_spans,
E0191,
diff --git a/compiler/rustc_hir_analysis/src/astconv/generics.rs b/compiler/rustc_hir_analysis/src/astconv/generics.rs
index adc6a9de808..e2cd4d5f21c 100644
--- a/compiler/rustc_hir_analysis/src/astconv/generics.rs
+++ b/compiler/rustc_hir_analysis/src/astconv/generics.rs
@@ -5,7 +5,7 @@ use crate::astconv::{
};
use crate::structured_errors::{GenericArgsInfo, StructuredDiagnostic, WrongNumberOfGenericArgs};
use rustc_ast::ast::ParamKindOrd;
-use rustc_errors::{struct_span_err, Applicability, Diagnostic, ErrorGuaranteed, MultiSpan};
+use rustc_errors::{struct_span_code_err, Applicability, Diagnostic, ErrorGuaranteed, MultiSpan};
use rustc_hir as hir;
use rustc_hir::def::{DefKind, Res};
use rustc_hir::def_id::DefId;
@@ -27,7 +27,7 @@ fn generic_arg_mismatch_err(
help: Option<String>,
) -> ErrorGuaranteed {
let sess = tcx.sess;
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
tcx.dcx(),
arg.span(),
E0747,
@@ -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) => {
@@ -650,8 +650,8 @@ pub(crate) fn prohibit_explicit_late_bound_lifetimes(
if position == GenericArgPosition::Value
&& args.num_lifetime_params() != param_counts.lifetimes
{
- struct_span_err!(tcx.dcx(), span, E0794, "{}", msg)
- .span_note_mv(span_late, note)
+ struct_span_code_err!(tcx.dcx(), span, E0794, "{}", msg)
+ .with_span_note(span_late, note)
.emit();
} else {
let mut multispan = MultiSpan::from_span(span);
diff --git a/compiler/rustc_hir_analysis/src/astconv/lint.rs b/compiler/rustc_hir_analysis/src/astconv/lint.rs
index 6675f517cfa..3761d529517 100644
--- a/compiler/rustc_hir_analysis/src/astconv/lint.rs
+++ b/compiler/rustc_hir_analysis/src/astconv/lint.rs
@@ -213,7 +213,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
let msg = "trait objects must include the `dyn` keyword";
let label = "add `dyn` keyword before this trait";
let mut diag =
- rustc_errors::struct_span_err!(tcx.dcx(), self_ty.span, E0782, "{}", msg);
+ rustc_errors::struct_span_code_err!(tcx.dcx(), self_ty.span, E0782, "{}", msg);
if self_ty.span.can_be_used_for_suggestions()
&& !self.maybe_lint_impl_trait(self_ty, &mut diag)
{
diff --git a/compiler/rustc_hir_analysis/src/astconv/mod.rs b/compiler/rustc_hir_analysis/src/astconv/mod.rs
index cdfb4c6389e..1f47564649e 100644
--- a/compiler/rustc_hir_analysis/src/astconv/mod.rs
+++ b/compiler/rustc_hir_analysis/src/astconv/mod.rs
@@ -18,8 +18,8 @@ use crate::require_c_abi_if_c_variadic;
use rustc_ast::TraitObjectSyntax;
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_errors::{
- error_code, struct_span_err, Applicability, Diagnostic, DiagnosticBuilder, ErrorGuaranteed,
- FatalError, MultiSpan,
+ error_code, struct_span_code_err, Applicability, Diagnostic, DiagnosticBuilder,
+ ErrorGuaranteed, FatalError, MultiSpan,
};
use rustc_hir as hir;
use rustc_hir::def::{CtorOf, DefKind, Namespace, Res};
@@ -866,7 +866,8 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
traits: &[String],
name: Symbol,
) -> ErrorGuaranteed {
- let mut err = struct_span_err!(self.tcx().dcx(), span, E0223, "ambiguous associated type");
+ let mut err =
+ struct_span_code_err!(self.tcx().dcx(), span, E0223, "ambiguous associated type");
if self
.tcx()
.resolutions(())
@@ -1313,7 +1314,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
let msg = format!("expected type, found variant `{assoc_ident}`");
tcx.dcx().span_err(span, msg)
} else if qself_ty.is_enum() {
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
tcx.dcx(),
assoc_ident.span,
E0599,
@@ -1354,7 +1355,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
reported
} else if let ty::Alias(ty::Opaque, alias_ty) = qself_ty.kind() {
// `<impl Trait as OtherTrait>::Assoc` makes no sense.
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
tcx.def_span(alias_ty.def_id),
E0667,
@@ -1617,9 +1618,9 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
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);
@@ -1850,7 +1851,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
};
let last_span = *arg_spans.last().unwrap();
let span: MultiSpan = arg_spans.into();
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.tcx().dcx(),
span,
E0109,
@@ -2601,7 +2602,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
let late_bound_in_ret = tcx.collect_referenced_late_bound_regions(&output);
self.validate_late_bound_regions(late_bound_in_args, late_bound_in_ret, |br_name| {
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
decl.output.span(),
E0581,
diff --git a/compiler/rustc_hir_analysis/src/astconv/object_safety.rs b/compiler/rustc_hir_analysis/src/astconv/object_safety.rs
index 703e0bdc40e..ea2f5f50b5c 100644
--- a/compiler/rustc_hir_analysis/src/astconv/object_safety.rs
+++ b/compiler/rustc_hir_analysis/src/astconv/object_safety.rs
@@ -2,7 +2,7 @@ use crate::astconv::{GenericArgCountMismatch, GenericArgCountResult, OnlySelfBou
use crate::bounds::Bounds;
use crate::errors::TraitObjectDeclaredWithNoTraits;
use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
-use rustc_errors::struct_span_err;
+use rustc_errors::struct_span_code_err;
use rustc_hir as hir;
use rustc_hir::def::{DefKind, Res};
use rustc_hir::def_id::DefId;
@@ -89,7 +89,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
if regular_traits.len() > 1 {
let first_trait = ®ular_traits[0];
let additional_trait = ®ular_traits[1];
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
tcx.dcx(),
additional_trait.bottom().1,
E0225,
@@ -290,7 +290,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
if references_self {
let def_id = i.bottom().0.def_id();
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
i.bottom().1,
E0038,
@@ -298,7 +298,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
tcx.def_descr(def_id),
tcx.item_name(def_id),
)
- .note_mv(
+ .with_note(
rustc_middle::traits::ObjectSafetyViolation::SupertraitSelf(smallvec![])
.error_msg(),
)
@@ -375,7 +375,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
self.ast_region_to_region(lifetime, None)
} else {
self.re_infer(None, span).unwrap_or_else(|| {
- let err = struct_span_err!(
+ let err = struct_span_code_err!(
tcx.dcx(),
span,
E0228,
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index 7f23c04ce2d..6265ddafef0 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -37,7 +37,7 @@ pub fn check_abi(tcx: TyCtxt<'_>, hir_id: hir::HirId, span: Span, abi: Abi) {
match tcx.sess.target.is_abi_supported(abi) {
Some(true) => (),
Some(false) => {
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
span,
E0570,
@@ -58,7 +58,7 @@ pub fn check_abi(tcx: TyCtxt<'_>, hir_id: hir::HirId, span: Span, abi: Abi) {
// This ABI is only allowed on function pointers
if abi == Abi::CCmseNonSecureCall {
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
span,
E0781,
@@ -560,14 +560,14 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) {
(0, _) => ("const", "consts", None),
_ => ("type or const", "types or consts", None),
};
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
item.span,
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!(
@@ -659,10 +659,7 @@ pub(super) fn check_specialization_validity<'tcx>(
if !tcx.is_impl_trait_in_trait(impl_item) {
report_forbidden_specialization(tcx, impl_item, parent_impl);
} else {
- tcx.dcx().span_delayed_bug(
- DUMMY_SP,
- format!("parent item: {parent_impl:?} not marked as default"),
- );
+ tcx.dcx().delayed_bug(format!("parent item: {parent_impl:?} not marked as default"));
}
}
}
@@ -687,7 +684,7 @@ fn check_impl_items_against_trait<'tcx>(
ty::ImplPolarity::Negative => {
if let [first_item_ref, ..] = impl_item_refs {
let first_item_span = tcx.def_span(first_item_ref);
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
first_item_span,
E0749,
@@ -804,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();
}
@@ -840,13 +836,13 @@ pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: LocalDefId) {
{
let fields = &def.non_enum_variant().fields;
if fields.is_empty() {
- struct_span_err!(tcx.dcx(), sp, E0075, "SIMD vector cannot be empty").emit();
+ struct_span_code_err!(tcx.dcx(), sp, E0075, "SIMD vector cannot be empty").emit();
return;
}
let e = fields[FieldIdx::from_u32(0)].ty(tcx, args);
if !fields.iter().all(|f| f.ty(tcx, args) == e) {
- struct_span_err!(tcx.dcx(), sp, E0076, "SIMD vector should be homogeneous")
- .span_label_mv(sp, "SIMD elements must have the same type")
+ struct_span_code_err!(tcx.dcx(), sp, E0076, "SIMD vector should be homogeneous")
+ .with_span_label(sp, "SIMD elements must have the same type")
.emit();
return;
}
@@ -858,10 +854,10 @@ pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: LocalDefId) {
};
if let Some(len) = len {
if len == 0 {
- struct_span_err!(tcx.dcx(), sp, E0075, "SIMD vector cannot be empty").emit();
+ struct_span_code_err!(tcx.dcx(), sp, E0075, "SIMD vector cannot be empty").emit();
return;
} else if len > MAX_SIMD_LANES {
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
sp,
E0075,
@@ -884,7 +880,7 @@ pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: LocalDefId) {
if matches!(t.kind(), ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::RawPtr(_)) =>
{ /* struct([f32; 4]) is ok */ }
_ => {
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
sp,
E0077,
@@ -907,7 +903,7 @@ pub(super) fn check_packed(tcx: TyCtxt<'_>, sp: Span, def: ty::AdtDef<'_>) {
&& let Some(repr_pack) = repr.pack
&& pack as u64 != repr_pack.bytes()
{
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
sp,
E0634,
@@ -918,7 +914,7 @@ pub(super) fn check_packed(tcx: TyCtxt<'_>, sp: Span, def: ty::AdtDef<'_>) {
}
}
if repr.align.is_some() {
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
sp,
E0587,
@@ -927,7 +923,7 @@ pub(super) fn check_packed(tcx: TyCtxt<'_>, sp: Span, def: ty::AdtDef<'_>) {
.emit();
} else {
if let Some(def_spans) = check_packed_inner(tcx, def.did(), &mut vec![]) {
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
tcx.dcx(),
sp,
E0588,
@@ -1117,13 +1113,13 @@ fn check_enum(tcx: TyCtxt<'_>, def_id: LocalDefId) {
if def.variants().is_empty() {
if let Some(attr) = tcx.get_attrs(def_id, sym::repr).next() {
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
attr.span,
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();
}
}
@@ -1156,7 +1152,7 @@ fn check_enum(tcx: TyCtxt<'_>, def_id: LocalDefId) {
let disr_non_unit = def.variants().iter().any(|var| !is_unit(var) && has_disr(var));
if disr_non_unit || (disr_units && has_non_units) {
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
tcx.def_span(def_id),
E0732,
@@ -1242,7 +1238,7 @@ fn detect_discriminant_duplicate<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
if discrs[i].1.val == discrs[o].1.val {
let err = error.get_or_insert_with(|| {
- let mut ret = struct_span_err!(
+ let mut ret = struct_span_code_err!(
tcx.dcx(),
tcx.def_span(adt.did()),
E0081,
@@ -1309,9 +1305,15 @@ pub(super) fn check_type_params_are_used<'tcx>(
&& let ty::GenericParamDefKind::Type { .. } = param.kind
{
let span = tcx.def_span(param.def_id);
- struct_span_err!(tcx.dcx(), span, E0091, "type parameter `{}` is unused", param.name,)
- .span_label_mv(span, "unused type parameter")
- .emit();
+ struct_span_code_err!(
+ tcx.dcx(),
+ span,
+ E0091,
+ "type parameter `{}` is unused",
+ param.name,
+ )
+ .with_span_label(span, "unused type parameter")
+ .emit();
}
}
}
@@ -1329,7 +1331,7 @@ fn opaque_type_cycle_error(
opaque_def_id: LocalDefId,
span: Span,
) -> ErrorGuaranteed {
- let mut err = struct_span_err!(tcx.dcx(), span, E0720, "cannot resolve opaque type");
+ let mut err = struct_span_code_err!(tcx.dcx(), span, E0720, "cannot resolve opaque type");
let mut label = false;
if let Some((def_id, visitor)) = get_owner_return_paths(tcx, opaque_def_id) {
diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
index 46b5c1a94de..469e7a6a13c 100644
--- a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
+++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
@@ -2,7 +2,7 @@ use super::potentially_plural_count;
use crate::errors::LifetimesOrBoundsMismatchOnTrait;
use hir::def_id::{DefId, DefIdMap, LocalDefId};
use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexSet};
-use rustc_errors::{pluralize, struct_span_err, Applicability, DiagnosticId, ErrorGuaranteed};
+use rustc_errors::{pluralize, struct_span_code_err, Applicability, DiagnosticId, ErrorGuaranteed};
use rustc_hir as hir;
use rustc_hir::def::{DefKind, Res};
use rustc_hir::intravisit;
@@ -19,7 +19,7 @@ use rustc_middle::ty::{
self, GenericArgs, Ty, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitableExt,
};
use rustc_middle::ty::{GenericParamDefKind, TyCtxt};
-use rustc_span::{Span, DUMMY_SP};
+use rustc_span::Span;
use rustc_trait_selection::traits::error_reporting::TypeErrCtxtExt;
use rustc_trait_selection::traits::outlives_bounds::InferCtxtExt as _;
use rustc_trait_selection::traits::{
@@ -625,7 +625,7 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
match ocx.eq(&cause, param_env, trait_return_ty, impl_return_ty) {
Ok(()) => {}
Err(terr) => {
- let mut diag = struct_span_err!(
+ let mut diag = struct_span_code_err!(
tcx.dcx(),
cause.span(),
E0053,
@@ -934,17 +934,15 @@ impl<'tcx> ty::FallibleTypeFolder<TyCtxt<'tcx>> for RemapHiddenTyRegions<'tcx> {
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().span_delayed_bug(DUMMY_SP, "should've been able to remap region")
- }
+ _ => self.tcx.dcx().delayed_bug("should've been able to remap region"),
};
return Err(guar);
};
@@ -972,7 +970,7 @@ fn report_trait_method_mismatch<'tcx>(
let (impl_err_span, trait_err_span) =
extract_spans_for_error_reporting(infcx, terr, &cause, impl_m, trait_m);
- let mut diag = struct_span_err!(
+ let mut diag = struct_span_code_err!(
tcx.dcx(),
impl_err_span,
E0053,
@@ -1217,7 +1215,7 @@ fn compare_self_type<'tcx>(
(false, true) => {
let self_descr = self_string(impl_m);
let impl_m_span = tcx.def_span(impl_m.def_id);
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
tcx.dcx(),
impl_m_span,
E0185,
@@ -1237,7 +1235,7 @@ fn compare_self_type<'tcx>(
(true, false) => {
let self_descr = self_string(trait_m);
let impl_m_span = tcx.def_span(impl_m.def_id);
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
tcx.dcx(),
impl_m_span,
E0186,
@@ -1303,8 +1301,7 @@ fn compare_number_of_generics<'tcx>(
// inheriting the generics from will also have mismatched arguments, and
// we'll report an error for that instead. Delay a bug for safety, though.
if trait_.is_impl_trait_in_trait() {
- return Err(tcx.dcx().span_delayed_bug(
- rustc_span::DUMMY_SP,
+ return Err(tcx.dcx().delayed_bug(
"errors comparing numbers of generics of trait/impl functions were not emitted",
));
}
@@ -1463,7 +1460,7 @@ fn compare_number_of_method_arguments<'tcx>(
})
.unwrap_or_else(|| tcx.def_span(impl_m.def_id));
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
tcx.dcx(),
impl_span,
E0050,
@@ -1530,7 +1527,7 @@ fn compare_synthetic_generics<'tcx>(
let impl_def_id = impl_def_id.expect_local();
let impl_span = tcx.def_span(impl_def_id);
let trait_span = tcx.def_span(trait_def_id);
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
tcx.dcx(),
impl_span,
E0643,
@@ -1689,7 +1686,7 @@ fn compare_generic_param_kinds<'tcx>(
let param_impl_span = tcx.def_span(param_impl.def_id);
let param_trait_span = tcx.def_span(param_trait.def_id);
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
tcx.dcx(),
param_impl_span,
E0053,
@@ -1836,7 +1833,7 @@ fn compare_const_predicate_entailment<'tcx>(
let (ty, _) = tcx.hir().expect_impl_item(impl_ct_def_id).expect_const();
cause.span = ty.span;
- let mut diag = struct_span_err!(
+ let mut diag = struct_span_code_err!(
tcx.dcx(),
cause.span,
E0326,
diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs
index fd1571426c8..f7fc0c81b95 100644
--- a/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs
+++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs
@@ -7,7 +7,7 @@ use rustc_middle::traits::{ObligationCause, Reveal};
use rustc_middle::ty::{
self, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperVisitable, TypeVisitable, TypeVisitor,
};
-use rustc_span::{Span, DUMMY_SP};
+use rustc_span::Span;
use rustc_trait_selection::traits::{
elaborate, normalize_param_env_or_error, outlives_bounds::InferCtxtExt, ObligationCtxt,
};
@@ -153,10 +153,7 @@ pub(super) fn check_refining_return_position_impl_trait_in_trait<'tcx>(
trait_m_sig.inputs_and_output,
));
if !ocx.select_all_or_error().is_empty() {
- tcx.dcx().span_delayed_bug(
- DUMMY_SP,
- "encountered errors when checking RPITIT refinement (selection)",
- );
+ tcx.dcx().delayed_bug("encountered errors when checking RPITIT refinement (selection)");
return;
}
let outlives_env = OutlivesEnvironment::with_bounds(
@@ -165,18 +162,12 @@ pub(super) fn check_refining_return_position_impl_trait_in_trait<'tcx>(
);
let errors = infcx.resolve_regions(&outlives_env);
if !errors.is_empty() {
- tcx.dcx().span_delayed_bug(
- DUMMY_SP,
- "encountered errors when checking RPITIT refinement (regions)",
- );
+ tcx.dcx().delayed_bug("encountered errors when checking RPITIT refinement (regions)");
return;
}
// Resolve any lifetime variables that may have been introduced during normalization.
let Ok((trait_bounds, impl_bounds)) = infcx.fully_resolve((trait_bounds, impl_bounds)) else {
- tcx.dcx().span_delayed_bug(
- DUMMY_SP,
- "encountered errors when checking RPITIT refinement (resolution)",
- );
+ tcx.dcx().delayed_bug("encountered errors when checking RPITIT refinement (resolution)");
return;
};
diff --git a/compiler/rustc_hir_analysis/src/check/dropck.rs b/compiler/rustc_hir_analysis/src/check/dropck.rs
index ff78d040aca..3275a81c3dd 100644
--- a/compiler/rustc_hir_analysis/src/check/dropck.rs
+++ b/compiler/rustc_hir_analysis/src/check/dropck.rs
@@ -2,7 +2,7 @@
//
// We don't do any drop checking during hir typeck.
use rustc_data_structures::fx::FxHashSet;
-use rustc_errors::{struct_span_err, ErrorGuaranteed};
+use rustc_errors::{struct_span_code_err, ErrorGuaranteed};
use rustc_infer::infer::outlives::env::OutlivesEnvironment;
use rustc_infer::infer::{RegionResolutionError, TyCtxtInferExt};
use rustc_middle::ty::util::CheckRegions;
@@ -88,8 +88,12 @@ fn ensure_drop_params_and_item_params_correspond<'tcx>(
let drop_impl_span = tcx.def_span(drop_impl_did);
let item_span = tcx.def_span(self_type_did);
let self_descr = tcx.def_descr(self_type_did);
- let mut err =
- struct_span_err!(tcx.dcx(), drop_impl_span, E0366, "`Drop` impls cannot be specialized");
+ let mut err = struct_span_code_err!(
+ tcx.dcx(),
+ drop_impl_span,
+ E0366,
+ "`Drop` impls cannot be specialized"
+ );
match arg {
ty::util::NotUniqueParam::DuplicateParam(arg) => {
err.note(format!("`{arg}` is mentioned multiple times"))
@@ -154,14 +158,14 @@ fn ensure_drop_predicates_are_implied_by_item_defn<'tcx>(
let item_span = tcx.def_span(adt_def_id);
let self_descr = tcx.def_descr(adt_def_id.to_def_id());
guar = Some(
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
error.root_obligation.cause.span,
E0367,
"`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(),
);
}
@@ -186,14 +190,14 @@ fn ensure_drop_predicates_are_implied_by_item_defn<'tcx>(
}
};
guar = Some(
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
error.origin().span(),
E0367,
"`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(),
);
}
diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
index a5aedeb33ae..7c3e296dfce 100644
--- a/compiler/rustc_hir_analysis/src/check/intrinsic.rs
+++ b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
@@ -8,7 +8,7 @@ use crate::errors::{
};
use hir::def_id::DefId;
-use rustc_errors::{struct_span_err, DiagnosticMessage};
+use rustc_errors::{struct_span_code_err, DiagnosticMessage};
use rustc_hir as hir;
use rustc_middle::traits::{ObligationCause, ObligationCauseCode};
use rustc_middle::ty::{self, Ty, TyCtxt};
@@ -29,8 +29,8 @@ fn equate_intrinsic_type<'tcx>(
(own_counts, generics.span)
}
_ => {
- struct_span_err!(tcx.dcx(), it.span, E0622, "intrinsic must be a function")
- .span_label_mv(it.span, "expected a function")
+ struct_span_code_err!(tcx.dcx(), it.span, E0622, "intrinsic must be a function")
+ .with_span_label(it.span, "expected a function")
.emit();
return;
}
@@ -552,7 +552,7 @@ pub fn check_platform_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>)
sym::simd_shuffle_generic => (2, 1, vec![param(0), param(0)], param(1)),
_ => {
let msg = format!("unrecognized platform-specific intrinsic function: `{name}`");
- tcx.dcx().struct_span_err(it.span, msg).emit();
+ tcx.dcx().span_err(it.span, msg);
return;
}
};
diff --git a/compiler/rustc_hir_analysis/src/check/intrinsicck.rs b/compiler/rustc_hir_analysis/src/check/intrinsicck.rs
index 1979f52eda9..db619d5169e 100644
--- a/compiler/rustc_hir_analysis/src/check/intrinsicck.rs
+++ b/compiler/rustc_hir_analysis/src/check/intrinsicck.rs
@@ -4,7 +4,7 @@ use rustc_hir as hir;
use rustc_middle::ty::{self, Article, FloatTy, IntTy, Ty, TyCtxt, TypeVisitableExt, UintTy};
use rustc_session::lint;
use rustc_span::def_id::LocalDefId;
-use rustc_span::{Symbol, DUMMY_SP};
+use rustc_span::Symbol;
use rustc_target::abi::FieldIdx;
use rustc_target::asm::{InlineAsmReg, InlineAsmRegClass, InlineAsmRegOrRegClass, InlineAsmType};
@@ -156,7 +156,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
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 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
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 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
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 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
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(),
@@ -294,7 +294,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
pub fn check_asm(&self, asm: &hir::InlineAsm<'tcx>, enclosing_id: LocalDefId) {
let target_features = self.tcx.asm_target_features(enclosing_id.to_def_id());
let Some(asm_arch) = self.tcx.sess.asm_arch else {
- self.tcx.dcx().span_delayed_bug(DUMMY_SP, "target architecture does not support asm");
+ self.tcx.dcx().delayed_bug("target architecture does not support asm");
return;
};
for (idx, (op, op_sp)) in asm.operands.iter().enumerate() {
@@ -325,7 +325,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
op.is_clobber(),
) {
let msg = format!("cannot use register `{}`: {}", reg.name(), msg);
- self.tcx.dcx().struct_span_err(*op_sp, msg).emit();
+ self.tcx.dcx().span_err(*op_sp, msg);
continue;
}
}
@@ -364,7 +364,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
reg_class.name(),
feature
);
- self.tcx.dcx().struct_span_err(*op_sp, msg).emit();
+ self.tcx.dcx().span_err(*op_sp, msg);
// register isn't enabled, don't do more checks
continue;
}
@@ -378,7 +378,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
.intersperse(", ")
.collect::<String>(),
);
- self.tcx.dcx().struct_span_err(*op_sp, msg).emit();
+ self.tcx.dcx().span_err(*op_sp, msg);
// register isn't enabled, don't do more checks
continue;
}
@@ -459,11 +459,11 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
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();
diff --git a/compiler/rustc_hir_analysis/src/check/mod.rs b/compiler/rustc_hir_analysis/src/check/mod.rs
index ac0c715c6b3..3b05eaedf34 100644
--- a/compiler/rustc_hir_analysis/src/check/mod.rs
+++ b/compiler/rustc_hir_analysis/src/check/mod.rs
@@ -78,7 +78,7 @@ use std::num::NonZeroU32;
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_errors::ErrorGuaranteed;
-use rustc_errors::{pluralize, struct_span_err, Diagnostic, DiagnosticBuilder};
+use rustc_errors::{pluralize, struct_span_code_err, Diagnostic, DiagnosticBuilder};
use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_hir::intravisit::Visitor;
use rustc_index::bit_set::BitSet;
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index 67ec2c3e5ea..59c72227144 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -3,7 +3,9 @@ use crate::constrained_generic_params::{identify_constrained_generic_params, Par
use rustc_ast as ast;
use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexSet};
-use rustc_errors::{pluralize, struct_span_err, Applicability, DiagnosticBuilder, ErrorGuaranteed};
+use rustc_errors::{
+ pluralize, struct_span_code_err, Applicability, DiagnosticBuilder, ErrorGuaranteed,
+};
use rustc_hir as hir;
use rustc_hir::def_id::{DefId, LocalDefId, LocalModDefId};
use rustc_hir::lang_items::LangItem;
@@ -200,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.
@@ -217,7 +219,7 @@ fn check_item<'tcx>(tcx: TyCtxt<'tcx>, item: &'tcx hir::Item<'tcx>) -> Result<()
if let hir::Defaultness::Default { .. } = impl_.defaultness {
let mut spans = vec![span];
spans.extend(impl_.defaultness_span);
- res = Err(struct_span_err!(
+ res = Err(struct_span_code_err!(
tcx.dcx(),
spans,
E0750,
@@ -502,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();
}
@@ -837,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,
@@ -1116,7 +1117,7 @@ fn check_trait(tcx: TyCtxt<'_>, item: &hir::Item<'_>) -> Result<(), ErrorGuarant
|| matches!(trait_def.specialization_kind, TraitSpecializationKind::Marker)
{
for associated_def_id in &*tcx.associated_item_def_ids(def_id) {
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
tcx.def_span(*associated_def_id),
E0714,
@@ -1598,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`.
@@ -1610,9 +1611,9 @@ fn check_method_receiver<'tcx>(
}
fn e0307(tcx: TyCtxt<'_>, span: Span, receiver_ty: Ty<'_>) -> ErrorGuaranteed {
- struct_span_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)
+ struct_span_code_err!(tcx.dcx(), span, E0307, "invalid `self` parameter type: {receiver_ty}")
+ .with_note("type of `self` must be `Self` or a type that dereferences to it")
+ .with_help(HELP_FOR_SELF_TYPE)
.emit()
}
@@ -1920,8 +1921,8 @@ fn check_mod_type_wf(tcx: TyCtxt<'_>, module: LocalModDefId) -> Result<(), Error
}
fn error_392(tcx: TyCtxt<'_>, span: Span, param_name: Symbol) -> DiagnosticBuilder<'_> {
- struct_span_err!(tcx.dcx(), span, E0392, "parameter `{param_name}` is never used")
- .span_label_mv(span, "unused parameter")
+ struct_span_code_err!(tcx.dcx(), span, E0392, "parameter `{param_name}` is never used")
+ .with_span_label(span, "unused parameter")
}
pub fn provide(providers: &mut Providers) {
diff --git a/compiler/rustc_hir_analysis/src/coherence/inherent_impls_overlap.rs b/compiler/rustc_hir_analysis/src/coherence/inherent_impls_overlap.rs
index 8f54bf00528..4c3455c7240 100644
--- a/compiler/rustc_hir_analysis/src/coherence/inherent_impls_overlap.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/inherent_impls_overlap.rs
@@ -1,5 +1,5 @@
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-use rustc_errors::struct_span_err;
+use rustc_errors::struct_span_code_err;
use rustc_hir as hir;
use rustc_hir::def::DefKind;
use rustc_hir::def_id::DefId;
@@ -70,15 +70,15 @@ impl<'tcx> InherentOverlapChecker<'tcx> {
match seen_items.entry(norm_ident) {
Entry::Occupied(entry) => {
let former = entry.get();
- struct_span_err!(
+ struct_span_code_err!(
self.tcx.dcx(),
span,
E0592,
"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) => {
@@ -104,7 +104,7 @@ impl<'tcx> InherentOverlapChecker<'tcx> {
if let Some(item2) = collision {
let name = item1.ident(self.tcx).normalize_to_macros_2_0();
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.tcx.dcx(),
self.tcx.def_span(item1.def_id),
E0592,
diff --git a/compiler/rustc_hir_analysis/src/coherence/mod.rs b/compiler/rustc_hir_analysis/src/coherence/mod.rs
index 3d56f8fd44e..561a254e89e 100644
--- a/compiler/rustc_hir_analysis/src/coherence/mod.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/mod.rs
@@ -6,7 +6,7 @@
// mappings. That mapping code resides here.
use crate::errors;
-use rustc_errors::{error_code, struct_span_err};
+use rustc_errors::{error_code, struct_span_code_err};
use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_middle::query::Providers;
use rustc_middle::ty::{self, TyCtxt, TypeVisitableExt};
@@ -45,7 +45,7 @@ fn enforce_trait_manually_implementable(
// Disallow *all* explicit impls of traits marked `#[rustc_deny_explicit_impl]`
if tcx.trait_def(trait_def_id).deny_explicit_impl {
let trait_name = tcx.item_name(trait_def_id);
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
tcx.dcx(),
impl_header_span,
E0322,
@@ -88,7 +88,7 @@ fn enforce_empty_impls_for_marker_traits(
return;
}
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
tcx.def_span(impl_def_id),
E0715,
@@ -173,7 +173,7 @@ fn check_object_overlap<'tcx>(
let mut supertrait_def_ids = traits::supertrait_def_ids(tcx, component_def_id);
if supertrait_def_ids.any(|d| d == trait_def_id) {
let span = tcx.def_span(impl_def_id);
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
span,
E0371,
@@ -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 `{}`",
diff --git a/compiler/rustc_hir_analysis/src/coherence/unsafety.rs b/compiler/rustc_hir_analysis/src/coherence/unsafety.rs
index 272c13b4c1c..7b146573a1b 100644
--- a/compiler/rustc_hir_analysis/src/coherence/unsafety.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/unsafety.rs
@@ -1,7 +1,7 @@
//! Unsafety checker: every impl either implements a trait defined in this
//! crate or pertains to a type defined in this crate.
-use rustc_errors::struct_span_err;
+use rustc_errors::struct_span_code_err;
use rustc_hir as hir;
use rustc_hir::Unsafety;
use rustc_middle::ty::TyCtxt;
@@ -18,14 +18,14 @@ pub(super) fn check_item(tcx: TyCtxt<'_>, def_id: LocalDefId) {
impl_.generics.params.iter().find(|p| p.pure_wrt_drop).map(|_| "may_dangle");
match (trait_def.unsafety, unsafe_attr, impl_.unsafety, impl_.polarity) {
(Unsafety::Normal, None, Unsafety::Unsafe, hir::ImplPolarity::Positive) => {
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
tcx.def_span(def_id),
E0199,
"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",
"",
@@ -35,20 +35,20 @@ pub(super) fn check_item(tcx: TyCtxt<'_>, def_id: LocalDefId) {
}
(Unsafety::Unsafe, _, Unsafety::Normal, hir::ImplPolarity::Positive) => {
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
tcx.def_span(def_id),
E0200,
"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 ",
@@ -58,20 +58,20 @@ pub(super) fn check_item(tcx: TyCtxt<'_>, def_id: LocalDefId) {
}
(Unsafety::Normal, Some(attr_name), Unsafety::Normal, hir::ImplPolarity::Positive) => {
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
tcx.def_span(def_id),
E0569,
"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 ",
diff --git a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
index 61bb4235139..3d8390d1946 100644
--- a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
+++ b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
@@ -8,7 +8,7 @@
use rustc_ast::walk_list;
use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
-use rustc_errors::struct_span_err;
+use rustc_errors::struct_span_code_err;
use rustc_hir as hir;
use rustc_hir::def::{DefKind, Res};
use rustc_hir::def_id::LocalDefId;
@@ -22,7 +22,7 @@ use rustc_middle::ty::{self, TyCtxt, TypeSuperVisitable, TypeVisitor};
use rustc_session::lint;
use rustc_span::def_id::DefId;
use rustc_span::symbol::{sym, Ident};
-use rustc_span::{Span, DUMMY_SP};
+use rustc_span::Span;
use std::fmt;
use crate::errors;
@@ -335,13 +335,10 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
// though this may happen when we call `poly_trait_ref_binder_info` with
// an (erroneous, #113423) associated return type bound in an impl header.
if !supertrait_bound_vars.is_empty() {
- self.tcx.dcx().span_delayed_bug(
- DUMMY_SP,
- format!(
- "found supertrait lifetimes without a binder to append \
+ self.tcx.dcx().delayed_bug(format!(
+ "found supertrait lifetimes without a binder to append \
them to: {supertrait_bound_vars:?}"
- ),
- );
+ ));
}
break (vec![], BinderScopeType::Normal);
}
@@ -737,7 +734,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
// Ensure that the parent of the def is an item, not HRTB
let parent_id = self.tcx.hir().parent_id(hir_id);
if !parent_id.is_owner() {
- struct_span_err!(
+ struct_span_code_err!(
self.tcx.dcx(),
lifetime.ident.span,
E0657,
@@ -754,7 +751,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, '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());
}
diff --git a/compiler/rustc_hir_analysis/src/impl_wf_check.rs b/compiler/rustc_hir_analysis/src/impl_wf_check.rs
index ff5fff9363f..3f9b1f384d7 100644
--- a/compiler/rustc_hir_analysis/src/impl_wf_check.rs
+++ b/compiler/rustc_hir_analysis/src/impl_wf_check.rs
@@ -12,7 +12,7 @@ use crate::constrained_generic_params as cgp;
use min_specialization::check_min_specialization;
use rustc_data_structures::fx::FxHashSet;
-use rustc_errors::struct_span_err;
+use rustc_errors::struct_span_code_err;
use rustc_hir::def::DefKind;
use rustc_hir::def_id::{LocalDefId, LocalModDefId};
use rustc_middle::query::Providers;
@@ -170,7 +170,7 @@ fn enforce_impl_params_are_constrained(tcx: TyCtxt<'_>, impl_def_id: LocalDefId)
}
fn report_unused_parameter(tcx: TyCtxt<'_>, span: Span, kind: &str, name: Symbol) {
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
tcx.dcx(),
span,
E0207,
diff --git a/compiler/rustc_hir_analysis/src/structured_errors/wrong_number_of_generic_args.rs b/compiler/rustc_hir_analysis/src/structured_errors/wrong_number_of_generic_args.rs
index 04c42b4b2e6..6657e3fd872 100644
--- a/compiler/rustc_hir_analysis/src/structured_errors/wrong_number_of_generic_args.rs
+++ b/compiler/rustc_hir_analysis/src/structured_errors/wrong_number_of_generic_args.rs
@@ -523,7 +523,7 @@ impl<'a, 'tcx> WrongNumberOfGenericArgs<'a, 'tcx> {
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.
diff --git a/compiler/rustc_hir_typeck/src/callee.rs b/compiler/rustc_hir_typeck/src/callee.rs
index fc61467df01..1a4e03d50ca 100644
--- a/compiler/rustc_hir_typeck/src/callee.rs
+++ b/compiler/rustc_hir_typeck/src/callee.rs
@@ -402,7 +402,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
callee_expr.span,
format!("evaluate({predicate:?}) = {result:?}"),
)
- .span_label_mv(predicate_span, "predicate")
+ .with_span_label(predicate_span, "predicate")
.emit();
}
}
diff --git a/compiler/rustc_hir_typeck/src/cast.rs b/compiler/rustc_hir_typeck/src/cast.rs
index 0a9f2a27cb8..a720a858f3c 100644
--- a/compiler/rustc_hir_typeck/src/cast.rs
+++ b/compiler/rustc_hir_typeck/src/cast.rs
@@ -269,7 +269,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
}
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 @@ impl<'a, 'tcx> CastCheck<'tcx> {
}
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 @@ impl<'a, 'tcx> CastCheck<'tcx> {
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();
}
}
diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
index 1aa25a5bd7f..0b266202b26 100644
--- a/compiler/rustc_hir_typeck/src/coercion.rs
+++ b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -36,7 +36,7 @@
//! ```
use crate::FnCtxt;
-use rustc_errors::{struct_span_err, Applicability, Diagnostic, DiagnosticBuilder, MultiSpan};
+use rustc_errors::{struct_span_code_err, Applicability, Diagnostic, DiagnosticBuilder, MultiSpan};
use rustc_hir as hir;
use rustc_hir::def_id::DefId;
use rustc_hir::intravisit::{self, Visitor};
@@ -1571,7 +1571,7 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
let mut visitor = CollectRetsVisitor { ret_exprs: vec![] };
match *cause.code() {
ObligationCauseCode::ReturnNoExpression => {
- err = struct_span_err!(
+ err = struct_span_code_err!(
fcx.dcx(),
cause.span,
E0069,
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index 7617f03fcf2..fdad998c451 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -25,7 +25,7 @@ use rustc_ast as ast;
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_data_structures::stack::ensure_sufficient_stack;
use rustc_errors::{
- pluralize, struct_span_err, AddToDiagnostic, Applicability, Diagnostic, DiagnosticBuilder,
+ pluralize, struct_span_code_err, AddToDiagnostic, Applicability, Diagnostic, DiagnosticBuilder,
DiagnosticId, ErrorGuaranteed, StashKey,
};
use rustc_hir as hir;
@@ -1760,7 +1760,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// Make sure the programmer specified correct number of fields.
if adt_kind == AdtKind::Union {
if ast_fields.len() != 1 {
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
span,
E0784,
@@ -1967,7 +1967,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
};
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.dcx(),
span,
E0063,
@@ -2194,7 +2194,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let mut err = self.err_ctxt().type_error_struct_with_diag(
field.ident.span,
|actual| match ty.kind() {
- ty::Adt(adt, ..) if adt.is_enum() => struct_span_err!(
+ ty::Adt(adt, ..) if adt.is_enum() => struct_span_code_err!(
self.dcx(),
field.ident.span,
E0559,
@@ -2204,7 +2204,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
variant.name,
field.ident
),
- _ => struct_span_err!(
+ _ => struct_span_code_err!(
self.dcx(),
field.ident.span,
E0560,
@@ -2832,13 +2832,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
fn private_field_err(&self, field: Ident, base_did: DefId) -> DiagnosticBuilder<'_> {
let struct_path = self.tcx().def_path_str(base_did);
let kind_name = self.tcx().def_descr(base_did);
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
field.span,
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 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
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 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
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 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
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 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
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;
};
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index da6f2042c11..8cd5ed3494b 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -6,7 +6,8 @@ use crate::method::MethodCallee;
use crate::TupleArgumentsFlag::*;
use crate::{errors, Expectation::*};
use crate::{
- struct_span_err, BreakableCtxt, Diverges, Expectation, FnCtxt, Needs, RawTy, TupleArgumentsFlag,
+ struct_span_code_err, BreakableCtxt, Diverges, Expectation, FnCtxt, Needs, RawTy,
+ TupleArgumentsFlag,
};
use rustc_ast as ast;
use rustc_data_structures::fx::FxIndexSet;
@@ -204,7 +205,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
_ => {
// Otherwise, there's a mismatch, so clear out what we're expecting, and set
// our input types to err_args so we don't blow up the error messages
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
call_span,
E0059,
@@ -807,7 +808,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
let mut err = if formal_and_expected_inputs.len() == provided_args.len() {
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
full_call_span,
E0308,
@@ -827,7 +828,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
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
@@ -1378,14 +1379,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// (issue #88844).
guar
}
- _ => struct_span_err!(
+ _ => struct_span_code_err!(
self.dcx(),
path_span,
E0071,
"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(),
})
}
diff --git a/compiler/rustc_hir_typeck/src/intrinsicck.rs b/compiler/rustc_hir_typeck/src/intrinsicck.rs
index 8bffd2dfc70..e087733130e 100644
--- a/compiler/rustc_hir_typeck/src/intrinsicck.rs
+++ b/compiler/rustc_hir_typeck/src/intrinsicck.rs
@@ -1,5 +1,5 @@
use hir::HirId;
-use rustc_errors::struct_span_err;
+use rustc_errors::struct_span_code_err;
use rustc_hir as hir;
use rustc_index::Idx;
use rustc_middle::ty::layout::{LayoutError, SizeSkeleton};
@@ -73,10 +73,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
if let (&ty::FnDef(..), SizeSkeleton::Known(size_to)) = (from.kind(), sk_to)
&& size_to == Pointer(dl.instruction_address_space).size(&tcx)
{
- struct_span_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")
+ struct_span_code_err!(tcx.dcx(), span, E0591, "can't transmute zero-sized type")
+ .with_note(format!("source type: {from}"))
+ .with_note(format!("target type: {to}"))
+ .with_help("cast with `as` to a pointer instead")
.emit();
return;
}
@@ -112,7 +112,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
Err(err) => err.to_string(),
};
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
tcx.dcx(),
span,
E0512,
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index ffae08d0f27..6dd4c8654f2 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -52,7 +52,7 @@ use crate::expectation::Expectation;
use crate::fn_ctxt::RawTy;
use crate::gather_locals::GatherLocalsVisitor;
use rustc_data_structures::unord::UnordSet;
-use rustc_errors::{struct_span_err, DiagnosticId, ErrorGuaranteed};
+use rustc_errors::{struct_span_code_err, DiagnosticId, ErrorGuaranteed};
use rustc_hir as hir;
use rustc_hir::def::{DefKind, Res};
use rustc_hir::intravisit::Visitor;
@@ -72,7 +72,7 @@ rustc_fluent_macro::fluent_messages! { "../messages.ftl" }
#[macro_export]
macro_rules! type_error_struct {
($dcx:expr, $span:expr, $typ:expr, $code:ident, $($message:tt)*) => ({
- let mut err = rustc_errors::struct_span_err!($dcx, $span, $code, $($message)*);
+ let mut err = rustc_errors::struct_span_code_err!($dcx, $span, $code, $($message)*);
if $typ.references_error() {
err.downgrade_to_delayed_bug();
@@ -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()
}
diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index 58db2f10bd0..1f01c6b7406 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -13,7 +13,7 @@ use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
use rustc_data_structures::unord::UnordSet;
use rustc_errors::StashKey;
use rustc_errors::{
- pluralize, struct_span_err, Applicability, Diagnostic, DiagnosticBuilder, MultiSpan,
+ pluralize, struct_span_code_err, Applicability, Diagnostic, DiagnosticBuilder, MultiSpan,
};
use rustc_hir as hir;
use rustc_hir::def::DefKind;
@@ -148,7 +148,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
MethodError::Ambiguity(mut sources) => {
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.dcx(),
item_name.span,
E0034,
@@ -171,7 +171,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
MethodError::PrivateMatch(kind, def_id, out_of_scope_traits) => {
let kind = self.tcx.def_kind_descr(kind, def_id);
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.dcx(),
item_name.span,
E0624,
@@ -263,8 +263,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
) -> DiagnosticBuilder<'_> {
let mut file = None;
let ty_str = self.tcx.short_ty_string(rcvr_ty, &mut file);
- let mut err =
- struct_span_err!(self.dcx(), rcvr_expr.span, E0599, "cannot write into `{}`", ty_str);
+ let mut err = struct_span_code_err!(
+ self.dcx(),
+ rcvr_expr.span,
+ E0599,
+ "cannot write into `{}`",
+ ty_str
+ );
err.span_note(
rcvr_expr.span,
"must implement `io::Write`, `fmt::Write`, or have a `write_fmt` method",
@@ -1836,7 +1841,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
&& !actual.has_concrete_skeleton()
&& let SelfSource::MethodCall(expr) = source
{
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
tcx.dcx(),
span,
E0689,
diff --git a/compiler/rustc_hir_typeck/src/op.rs b/compiler/rustc_hir_typeck/src/op.rs
index 3b5226c6414..ee411f8ed5f 100644
--- a/compiler/rustc_hir_typeck/src/op.rs
+++ b/compiler/rustc_hir_typeck/src/op.rs
@@ -4,7 +4,7 @@ use super::method::MethodCallee;
use super::{has_expected_num_generic_args, FnCtxt};
use crate::Expectation;
use rustc_ast as ast;
-use rustc_errors::{struct_span_err, Applicability, Diagnostic, DiagnosticBuilder};
+use rustc_errors::{struct_span_code_err, Applicability, Diagnostic, DiagnosticBuilder};
use rustc_hir as hir;
use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
use rustc_infer::traits::ObligationCauseCode;
@@ -306,7 +306,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
.map(|def_id| with_no_trimmed_paths!(self.tcx.def_path_str(def_id)));
let (mut err, output_def_id) = match is_assign {
IsAssign::Yes => {
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.dcx(),
expr.span,
E0368,
@@ -370,7 +370,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
})
.cloned()
});
- let mut err = struct_span_err!(self.dcx(), op.span, E0369, "{message}");
+ let mut err =
+ struct_span_code_err!(self.dcx(), op.span, E0369, "{message}");
if !lhs_expr.span.eq(&rhs_expr.span) {
err.span_label(lhs_expr.span, lhs_ty.to_string());
err.span_label(rhs_expr.span, rhs_ty.to_string());
@@ -788,7 +789,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
Err(errors) => {
let actual = self.resolve_vars_if_possible(operand_ty);
let guar = actual.error_reported().err().unwrap_or_else(|| {
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.dcx(),
ex.span,
E0600,
diff --git a/compiler/rustc_hir_typeck/src/pat.rs b/compiler/rustc_hir_typeck/src/pat.rs
index 4ac85cce292..95813cb68a6 100644
--- a/compiler/rustc_hir_typeck/src/pat.rs
+++ b/compiler/rustc_hir_typeck/src/pat.rs
@@ -3,7 +3,7 @@ use crate::{errors, FnCtxt, RawTy};
use rustc_ast as ast;
use rustc_data_structures::fx::FxHashMap;
use rustc_errors::{
- pluralize, struct_span_err, Applicability, Diagnostic, DiagnosticBuilder, ErrorGuaranteed,
+ pluralize, struct_span_code_err, Applicability, Diagnostic, DiagnosticBuilder, ErrorGuaranteed,
MultiSpan,
};
use rustc_hir as hir;
@@ -546,7 +546,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
(_, Some((true, _, sp))) => sp,
_ => span_bug!(span, "emit_err_pat_range: no side failed or exists but still error?"),
};
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.dcx(),
span,
E0029,
@@ -837,7 +837,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// This is "x = SomeTrait" being reduced from
// "let &x = &SomeTrait" or "let box x = Box<SomeTrait>", an error.
let type_str = self.ty_to_string(expected);
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.dcx(),
span,
E0033,
@@ -1171,7 +1171,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
};
let last_field_def_span = *field_def_spans.last().unwrap();
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.dcx(),
MultiSpan::from_spans(subpat_spans),
E0023,
@@ -1516,7 +1516,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let has_shorthand_field_name = field_patterns.iter().any(|field| field.is_shorthand);
if has_shorthand_field_name {
let path = rustc_hir_pretty::qpath_to_string(qpath);
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.dcx(),
pat.span,
E0769,
@@ -1541,13 +1541,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let sp_comma = sm.end_point(pat.span.with_hi(sp_brace.hi()));
let sugg = if no_fields || sp_brace != sp_comma { ".. }" } else { ", .. }" };
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
pat.span,
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,
@@ -1562,15 +1562,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
ident: Ident,
other_field: Span,
) -> ErrorGuaranteed {
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
span,
E0025,
"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()
}
@@ -1601,7 +1601,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
)
};
let spans = inexistent_fields.iter().map(|field| field.ident.span).collect::<Vec<_>>();
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
tcx.dcx(),
spans,
E0026,
@@ -1698,7 +1698,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
let path = rustc_hir_pretty::qpath_to_string(qpath);
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.dcx(),
pat.span,
E0769,
@@ -1876,7 +1876,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
.join(", ");
format!("fields {fields}{inaccessible}")
};
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.dcx(),
pat.span,
E0027,
@@ -2226,7 +2226,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
min_len: u64,
size: u64,
) -> ErrorGuaranteed {
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
span,
E0527,
@@ -2235,7 +2235,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
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()
}
@@ -2245,7 +2245,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
min_len: u64,
size: u64,
) -> ErrorGuaranteed {
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
span,
E0528,
@@ -2254,7 +2254,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
pluralize!(min_len),
size,
)
- .span_label_mv(
+ .with_span_label(
span,
format!("pattern cannot match array of {} element{}", size, pluralize!(size),),
)
@@ -2262,7 +2262,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
fn error_scrutinee_unfixed_length(&self, span: Span) -> ErrorGuaranteed {
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
span,
E0730,
@@ -2277,7 +2277,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
expected_ty: Ty<'tcx>,
ti: TopInfo<'tcx>,
) -> ErrorGuaranteed {
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.dcx(),
span,
E0529,
diff --git a/compiler/rustc_hir_typeck/src/place_op.rs b/compiler/rustc_hir_typeck/src/place_op.rs
index 3825c513ef3..d6261763772 100644
--- a/compiler/rustc_hir_typeck/src/place_op.rs
+++ b/compiler/rustc_hir_typeck/src/place_op.rs
@@ -336,10 +336,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
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();
}
}
diff --git a/compiler/rustc_incremental/src/persist/fs.rs b/compiler/rustc_incremental/src/persist/fs.rs
index 2c6ae91786d..e18b1365d9c 100644
--- a/compiler/rustc_incremental/src/persist/fs.rs
+++ b/compiler/rustc_incremental/src/persist/fs.rs
@@ -273,7 +273,7 @@ pub(crate) fn prepare_session_directory(
debug!("successfully copied data from: {}", source_directory.display());
if !allows_links {
- sess.dcx().emit_warning(errors::HardLinkFailed { path: &session_dir });
+ sess.dcx().emit_warn(errors::HardLinkFailed { path: &session_dir });
}
sess.init_incr_comp_session(session_dir, directory_lock);
@@ -288,7 +288,7 @@ pub(crate) fn prepare_session_directory(
// Try to remove the session directory we just allocated. We don't
// know if there's any garbage in it from the failed copy action.
if let Err(err) = safe_remove_dir_all(&session_dir) {
- sess.dcx().emit_warning(errors::DeletePartial { path: &session_dir, err });
+ sess.dcx().emit_warn(errors::DeletePartial { path: &session_dir, err });
}
delete_session_dir_lock_file(sess, &lock_file_path);
@@ -322,7 +322,7 @@ pub fn finalize_session_directory(sess: &Session, svh: Option<Svh>) {
);
if let Err(err) = safe_remove_dir_all(&*incr_comp_session_dir) {
- sess.dcx().emit_warning(errors::DeleteFull { path: &incr_comp_session_dir, err });
+ sess.dcx().emit_warn(errors::DeleteFull { path: &incr_comp_session_dir, err });
}
let lock_file_path = lock_file_path(&*incr_comp_session_dir);
@@ -365,7 +365,7 @@ pub fn finalize_session_directory(sess: &Session, svh: Option<Svh>) {
}
Err(e) => {
// Warn about the error. However, no need to abort compilation now.
- sess.dcx().emit_warning(errors::Finalize { path: &incr_comp_session_dir, err: e });
+ sess.dcx().emit_warn(errors::Finalize { path: &incr_comp_session_dir, err: e });
debug!("finalize_session_directory() - error, marking as invalid");
// Drop the file lock, so we can garage collect
@@ -500,7 +500,7 @@ fn lock_directory(
fn delete_session_dir_lock_file(sess: &Session, lock_file_path: &Path) {
if let Err(err) = safe_remove_file(lock_file_path) {
- sess.dcx().emit_warning(errors::DeleteLock { path: lock_file_path, err });
+ sess.dcx().emit_warn(errors::DeleteLock { path: lock_file_path, err });
}
}
@@ -724,7 +724,7 @@ pub(crate) fn garbage_collect_session_directories(sess: &Session) -> io::Result<
if !lock_file_to_session_dir.items().any(|(_, dir)| *dir == directory_name) {
let path = crate_directory.join(directory_name);
if let Err(err) = safe_remove_dir_all(&path) {
- sess.dcx().emit_warning(errors::InvalidGcFailed { path: &path, err });
+ sess.dcx().emit_warn(errors::InvalidGcFailed { path: &path, err });
}
}
}
@@ -830,7 +830,7 @@ pub(crate) fn garbage_collect_session_directories(sess: &Session) -> io::Result<
debug!("garbage_collect_session_directories() - deleting `{}`", path.display());
if let Err(err) = safe_remove_dir_all(&path) {
- sess.dcx().emit_warning(errors::FinalizedGcFailed { path: &path, err });
+ sess.dcx().emit_warn(errors::FinalizedGcFailed { path: &path, err });
} else {
delete_session_dir_lock_file(sess, &lock_file_path(&path));
}
@@ -848,7 +848,7 @@ fn delete_old(sess: &Session, path: &Path) {
debug!("garbage_collect_session_directories() - deleting `{}`", path.display());
if let Err(err) = safe_remove_dir_all(path) {
- sess.dcx().emit_warning(errors::SessionGcFailed { path: path, err });
+ sess.dcx().emit_warn(errors::SessionGcFailed { path: path, err });
} else {
delete_session_dir_lock_file(sess, &lock_file_path(path));
}
diff --git a/compiler/rustc_incremental/src/persist/load.rs b/compiler/rustc_incremental/src/persist/load.rs
index ce8f5bb69ae..96bfe766c20 100644
--- a/compiler/rustc_incremental/src/persist/load.rs
+++ b/compiler/rustc_incremental/src/persist/load.rs
@@ -51,7 +51,7 @@ impl<T: Default> LoadResult<T> {
match self {
LoadResult::LoadDepGraph(path, err) => {
- sess.dcx().emit_warning(errors::LoadDepGraph { path, err });
+ sess.dcx().emit_warn(errors::LoadDepGraph { path, err });
Default::default()
}
LoadResult::DataOutOfDate => {
diff --git a/compiler/rustc_incremental/src/persist/work_product.rs b/compiler/rustc_incremental/src/persist/work_product.rs
index 1450d8a99ab..906233ef53e 100644
--- a/compiler/rustc_incremental/src/persist/work_product.rs
+++ b/compiler/rustc_incremental/src/persist/work_product.rs
@@ -30,7 +30,7 @@ pub fn copy_cgu_workproduct_to_incr_comp_cache_dir(
let _ = saved_files.insert(ext.to_string(), file_name);
}
Err(err) => {
- sess.dcx().emit_warning(errors::CopyWorkProductToCache {
+ sess.dcx().emit_warn(errors::CopyWorkProductToCache {
from: path,
to: &path_in_incr_dir,
err,
@@ -50,7 +50,7 @@ pub(crate) fn delete_workproduct_files(sess: &Session, work_product: &WorkProduc
for (_, path) in work_product.saved_files.items().into_sorted_stable_ord() {
let path = in_incr_comp_dir_sess(sess, path);
if let Err(err) = std_fs::remove_file(&path) {
- sess.dcx().emit_warning(errors::DeleteWorkProduct { path: &path, err });
+ sess.dcx().emit_warn(errors::DeleteWorkProduct { path: &path, err });
}
}
}
diff --git a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
index c156c13c962..e4b37f05b77 100644
--- a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
+++ b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
@@ -192,10 +192,10 @@ impl CanonicalizeMode for CanonicalizeQueryResponse {
// rust-lang/rust#57464: `impl Trait` can leak local
// scopes (in manner violating typeck). Therefore, use
// `span_delayed_bug` to allow type error over an ICE.
- canonicalizer.tcx.dcx().span_delayed_bug(
- rustc_span::DUMMY_SP,
- format!("unexpected region in query response: `{r:?}`"),
- );
+ canonicalizer
+ .tcx
+ .dcx()
+ .delayed_bug(format!("unexpected region in query response: `{r:?}`"));
r
}
}
diff --git a/compiler/rustc_infer/src/infer/error_reporting/mod.rs b/compiler/rustc_infer/src/infer/error_reporting/mod.rs
index b1c360b61cb..b81cc6edaf2 100644
--- a/compiler/rustc_infer/src/infer/error_reporting/mod.rs
+++ b/compiler/rustc_infer/src/infer/error_reporting/mod.rs
@@ -60,8 +60,8 @@ use crate::traits::{
use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
use rustc_errors::{
- error_code, pluralize, struct_span_err, Applicability, DiagCtxt, Diagnostic, DiagnosticBuilder,
- DiagnosticStyledString, ErrorGuaranteed, IntoDiagnosticArg,
+ error_code, pluralize, struct_span_code_err, Applicability, DiagCtxt, Diagnostic,
+ DiagnosticBuilder, DiagnosticStyledString, ErrorGuaranteed, IntoDiagnosticArg,
};
use rustc_hir as hir;
use rustc_hir::def::DefKind;
@@ -2780,7 +2780,7 @@ impl<'tcx> InferCtxt<'tcx> {
infer::Nll(..) => bug!("NLL variable found in lexical phase"),
};
- struct_span_err!(
+ struct_span_code_err!(
self.tcx.dcx(),
var_origin.span(),
E0495,
diff --git a/compiler/rustc_infer/src/infer/error_reporting/note.rs b/compiler/rustc_infer/src/infer/error_reporting/note.rs
index 77a0accf80b..02200d6a4aa 100644
--- a/compiler/rustc_infer/src/infer/error_reporting/note.rs
+++ b/compiler/rustc_infer/src/infer/error_reporting/note.rs
@@ -368,7 +368,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
{
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..."
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
index fa694f09f17..fcc94687ed2 100644
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -38,7 +38,7 @@ use rustc_middle::ty::{self, GenericParamDefKind, InferConst, InferTy, Ty, TyCtx
use rustc_middle::ty::{ConstVid, EffectVid, FloatVid, IntVid, TyVid};
use rustc_middle::ty::{GenericArg, GenericArgKind, GenericArgs, GenericArgsRef};
use rustc_span::symbol::Symbol;
-use rustc_span::{Span, DUMMY_SP};
+use rustc_span::Span;
use std::cell::{Cell, RefCell};
use std::fmt;
@@ -1434,10 +1434,8 @@ impl<'tcx> InferCtxt<'tcx> {
bug!("`{value:?}` is not fully resolved");
}
if value.has_infer_regions() {
- let guar = self
- .tcx
- .dcx()
- .span_delayed_bug(DUMMY_SP, format!("`{value:?}` is not fully resolved"));
+ let guar =
+ self.tcx.dcx().delayed_bug(format!("`{value:?}` is not fully resolved"));
Ok(self.tcx.fold_regions(value, |re, _| {
if re.is_var() { ty::Region::new_error(self.tcx, guar) } else { re }
}))
diff --git a/compiler/rustc_infer/src/infer/opaque_types/table.rs b/compiler/rustc_infer/src/infer/opaque_types/table.rs
index c91eb7eddd8..6a684dba8de 100644
--- a/compiler/rustc_infer/src/infer/opaque_types/table.rs
+++ b/compiler/rustc_infer/src/infer/opaque_types/table.rs
@@ -1,6 +1,5 @@
use rustc_data_structures::undo_log::UndoLogs;
use rustc_middle::ty::{self, OpaqueHiddenType, OpaqueTypeKey, Ty};
-use rustc_span::DUMMY_SP;
use crate::infer::{InferCtxtUndoLogs, UndoLog};
@@ -40,9 +39,7 @@ impl<'tcx> OpaqueTypeStorage<'tcx> {
impl<'tcx> Drop for OpaqueTypeStorage<'tcx> {
fn drop(&mut self) {
if !self.opaque_types.is_empty() {
- ty::tls::with(|tcx| {
- tcx.dcx().span_delayed_bug(DUMMY_SP, format!("{:?}", self.opaque_types))
- });
+ ty::tls::with(|tcx| tcx.dcx().delayed_bug(format!("{:?}", self.opaque_types)));
}
}
}
diff --git a/compiler/rustc_infer/src/infer/outlives/verify.rs b/compiler/rustc_infer/src/infer/outlives/verify.rs
index dd364312cad..7a85268492b 100644
--- a/compiler/rustc_infer/src/infer/outlives/verify.rs
+++ b/compiler/rustc_infer/src/infer/outlives/verify.rs
@@ -175,10 +175,9 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
// ignore this, we presume it will yield an error
// later, since if a type variable is not resolved by
// this point it never will be
- self.tcx.dcx().span_delayed_bug(
- rustc_span::DUMMY_SP,
- format!("unresolved inference variable in outlives: {v:?}"),
- );
+ self.tcx
+ .dcx()
+ .delayed_bug(format!("unresolved inference variable in outlives: {v:?}"));
// add a bound that never holds
VerifyBound::AnyBound(vec![])
}
diff --git a/compiler/rustc_infer/src/infer/relate/combine.rs b/compiler/rustc_infer/src/infer/relate/combine.rs
index 8b31a1118cb..6634b192811 100644
--- a/compiler/rustc_infer/src/infer/relate/combine.rs
+++ b/compiler/rustc_infer/src/infer/relate/combine.rs
@@ -180,10 +180,9 @@ impl<'tcx> InferCtxt<'tcx> {
&mut OriginalQueryValues::default(),
);
self.tcx.check_tys_might_be_eq(canonical).map_err(|_| {
- self.tcx.dcx().span_delayed_bug(
- DUMMY_SP,
- format!("cannot relate consts of different types (a={a:?}, b={b:?})",),
- )
+ self.tcx.dcx().delayed_bug(format!(
+ "cannot relate consts of different types (a={a:?}, b={b:?})",
+ ))
})
});
diff --git a/compiler/rustc_infer/src/traits/error_reporting/mod.rs b/compiler/rustc_infer/src/traits/error_reporting/mod.rs
index e91411ffc7a..6f218019dee 100644
--- a/compiler/rustc_infer/src/traits/error_reporting/mod.rs
+++ b/compiler/rustc_infer/src/traits/error_reporting/mod.rs
@@ -2,7 +2,7 @@ use super::ObjectSafetyViolation;
use crate::infer::InferCtxt;
use rustc_data_structures::fx::FxIndexSet;
-use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder, MultiSpan};
+use rustc_errors::{struct_span_code_err, Applicability, DiagnosticBuilder, MultiSpan};
use rustc_hir as hir;
use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_hir::intravisit::Map;
@@ -20,7 +20,7 @@ impl<'tcx> InferCtxt<'tcx> {
trait_item_def_id: DefId,
requirement: &dyn fmt::Display,
) -> DiagnosticBuilder<'tcx> {
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.tcx.dcx(),
error_span,
E0276,
@@ -52,7 +52,7 @@ pub fn report_object_safety_error<'tcx>(
hir::Node::Item(item) => Some(item.ident.span),
_ => None,
});
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
tcx.dcx(),
span,
E0038,
diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
index ce76c2cba93..97956404120 100644
--- a/compiler/rustc_interface/src/passes.rs
+++ b/compiler/rustc_interface/src/passes.rs
@@ -254,7 +254,7 @@ fn configure_and_expand(
}
if is_proc_macro_crate && sess.panic_strategy() == PanicStrategy::Abort {
- sess.dcx().emit_warning(errors::ProcMacroCratePanicAbort);
+ sess.dcx().emit_warn(errors::ProcMacroCratePanicAbort);
}
sess.time("maybe_create_a_macro_crate", || {
diff --git a/compiler/rustc_interface/src/queries.rs b/compiler/rustc_interface/src/queries.rs
index 9da806e0779..e66ea6f2ca9 100644
--- a/compiler/rustc_interface/src/queries.rs
+++ b/compiler/rustc_interface/src/queries.rs
@@ -213,9 +213,8 @@ impl<'tcx> Queries<'tcx> {
// Some other attribute.
Some(_) => {
- tcx.dcx().emit_warning(RustcErrorUnexpectedAnnotation {
- span: tcx.def_span(def_id),
- });
+ tcx.dcx()
+ .emit_warn(RustcErrorUnexpectedAnnotation { span: tcx.def_span(def_id) });
}
}
}
diff --git a/compiler/rustc_interface/src/util.rs b/compiler/rustc_interface/src/util.rs
index 92a6445ed09..9fd44e46b31 100644
--- a/compiler/rustc_interface/src/util.rs
+++ b/compiler/rustc_interface/src/util.rs
@@ -431,7 +431,7 @@ pub fn collect_crate_types(session: &Session, attrs: &[ast::Attribute]) -> Vec<C
base.retain(|crate_type| {
if output::invalid_output_for_target(session, *crate_type) {
- session.dcx().emit_warning(errors::UnsupportedCrateTypeForTarget {
+ session.dcx().emit_warn(errors::UnsupportedCrateTypeForTarget {
crate_type: *crate_type,
target_triple: &session.opts.target_triple,
});
@@ -507,16 +507,16 @@ pub fn build_output_filenames(attrs: &[ast::Attribute], sess: &Session) -> Outpu
let unnamed_output_types =
sess.opts.output_types.values().filter(|a| a.is_none()).count();
let ofile = if unnamed_output_types > 1 {
- sess.dcx().emit_warning(errors::MultipleOutputTypesAdaption);
+ sess.dcx().emit_warn(errors::MultipleOutputTypesAdaption);
None
} else {
if !sess.opts.cg.extra_filename.is_empty() {
- sess.dcx().emit_warning(errors::IgnoringExtraFilename);
+ sess.dcx().emit_warn(errors::IgnoringExtraFilename);
}
Some(out_file.clone())
};
if sess.io.output_dir != None {
- sess.dcx().emit_warning(errors::IgnoringOutDir);
+ sess.dcx().emit_warn(errors::IgnoringOutDir);
}
let out_filestem =
diff --git a/compiler/rustc_middle/src/mir/interpret/allocation.rs b/compiler/rustc_middle/src/mir/interpret/allocation.rs
index a92b85a716f..4047891d769 100644
--- a/compiler/rustc_middle/src/mir/interpret/allocation.rs
+++ b/compiler/rustc_middle/src/mir/interpret/allocation.rs
@@ -14,7 +14,6 @@ use either::{Left, Right};
use rustc_ast::Mutability;
use rustc_data_structures::intern::Interned;
-use rustc_span::DUMMY_SP;
use rustc_target::abi::{Align, HasDataLayout, Size};
use super::{
@@ -314,9 +313,7 @@ impl<Prov: Provenance, Bytes: AllocBytes> Allocation<Prov, (), Bytes> {
/// available to the compiler to do so.
pub fn try_uninit<'tcx>(size: Size, align: Align) -> InterpResult<'tcx, Self> {
Self::uninit_inner(size, align, || {
- ty::tls::with(|tcx| {
- tcx.dcx().span_delayed_bug(DUMMY_SP, "exhausted memory during interpretation")
- });
+ ty::tls::with(|tcx| tcx.dcx().delayed_bug("exhausted memory during interpretation"));
InterpError::ResourceExhaustion(ResourceExhaustionInfo::MemoryExhausted).into()
})
}
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index 414d4c8d949..a41d4f1ad58 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -551,7 +551,7 @@ macro_rules! define_feedable {
// We have an inconsistency. This can happen if one of the two
// results is tainted by errors. In this case, delay a bug to
// ensure compilation is doomed, and keep the `old` value.
- tcx.dcx().span_delayed_bug(DUMMY_SP, format!(
+ tcx.dcx().delayed_bug(format!(
"Trying to feed an already recorded value for query {} key={key:?}:\n\
old value: {old:?}\nnew value: {value:?}",
stringify!($name),
diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
index 5cc0ce87c9b..25473f52c03 100644
--- a/compiler/rustc_middle/src/ty/layout.rs
+++ b/compiler/rustc_middle/src/ty/layout.rs
@@ -284,7 +284,7 @@ impl<'tcx> LayoutCalculator for LayoutCx<'tcx, TyCtxt<'tcx>> {
type TargetDataLayoutRef = &'tcx TargetDataLayout;
fn delayed_bug(&self, txt: String) {
- self.tcx.dcx().span_delayed_bug(DUMMY_SP, txt);
+ self.tcx.dcx().delayed_bug(txt);
}
fn current_data_layout(&self) -> Self::TargetDataLayoutRef {
diff --git a/compiler/rustc_middle/src/ty/opaque_types.rs b/compiler/rustc_middle/src/ty/opaque_types.rs
index d9bcd8d3ae7..5ca88ec3102 100644
--- a/compiler/rustc_middle/src/ty/opaque_types.rs
+++ b/compiler/rustc_middle/src/ty/opaque_types.rs
@@ -132,7 +132,7 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for ReverseMapper<'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 \
diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
index 7285cdb830e..372f11a5acc 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -369,7 +369,7 @@ impl<'tcx> TyCtxt<'tcx> {
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();
}
diff --git a/compiler/rustc_middle/src/values.rs b/compiler/rustc_middle/src/values.rs
index 27d04dbe331..6a03bf243eb 100644
--- a/compiler/rustc_middle/src/values.rs
+++ b/compiler/rustc_middle/src/values.rs
@@ -1,7 +1,7 @@
use crate::dep_graph::dep_kinds;
use crate::query::plumbing::CyclePlaceholder;
use rustc_data_structures::fx::FxHashSet;
-use rustc_errors::{pluralize, struct_span_err, Applicability, MultiSpan};
+use rustc_errors::{pluralize, struct_span_code_err, Applicability, MultiSpan};
use rustc_hir as hir;
use rustc_hir::def::{DefKind, Res};
use rustc_middle::ty::Representability;
@@ -175,7 +175,7 @@ impl<'tcx, T> Value<TyCtxt<'tcx>> for Result<T, &'_ ty::layout::LayoutError<'_>>
} else {
tcx.def_span(def_id)
};
- let mut diag = struct_span_err!(
+ let mut diag = struct_span_code_err!(
tcx.sess.dcx(),
span,
E0733,
@@ -309,7 +309,7 @@ pub fn recursive_type_error(
}
s
};
- struct_span_err!(
+ struct_span_code_err!(
tcx.dcx(),
err_span,
E0072,
@@ -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,
diff --git a/compiler/rustc_mir_build/src/build/expr/as_constant.rs b/compiler/rustc_mir_build/src/build/expr/as_constant.rs
index e77e82d9954..5721957037e 100644
--- a/compiler/rustc_mir_build/src/build/expr/as_constant.rs
+++ b/compiler/rustc_mir_build/src/build/expr/as_constant.rs
@@ -9,7 +9,6 @@ use rustc_middle::thir::*;
use rustc_middle::ty::{
self, CanonicalUserType, CanonicalUserTypeAnnotation, TyCtxt, UserTypeAnnotationIndex,
};
-use rustc_span::DUMMY_SP;
use rustc_target::abi::Size;
impl<'a, 'tcx> Builder<'a, 'tcx> {
@@ -111,15 +110,15 @@ fn lit_to_mir_constant<'tcx>(
let LitToConstInput { lit, ty, neg } = lit_input;
let trunc = |n| {
let param_ty = ty::ParamEnv::reveal_all().and(ty);
- let width = tcx
- .layout_of(param_ty)
- .map_err(|_| {
- LitToConstError::Reported(tcx.dcx().span_delayed_bug(
- DUMMY_SP,
- format!("couldn't compute width of literal: {:?}", lit_input.lit),
- ))
- })?
- .size;
+ let width =
+ tcx.layout_of(param_ty)
+ .map_err(|_| {
+ LitToConstError::Reported(tcx.dcx().delayed_bug(format!(
+ "couldn't compute width of literal: {:?}",
+ lit_input.lit
+ )))
+ })?
+ .size;
trace!("trunc {} with size {} and shift {}", n, width.bits(), 128 - width.bits());
let result = width.truncate(n);
trace!("trunc result: {}", result);
@@ -158,16 +157,16 @@ fn lit_to_mir_constant<'tcx>(
}
(ast::LitKind::Float(n, _), ty::Float(fty)) => parse_float_into_constval(*n, *fty, neg)
.ok_or_else(|| {
- LitToConstError::Reported(tcx.dcx().span_delayed_bug(
- DUMMY_SP,
- format!("couldn't parse float literal: {:?}", lit_input.lit),
- ))
+ LitToConstError::Reported(
+ tcx.dcx()
+ .delayed_bug(format!("couldn't parse float literal: {:?}", lit_input.lit)),
+ )
})?,
(ast::LitKind::Bool(b), ty::Bool) => ConstValue::Scalar(Scalar::from_bool(*b)),
(ast::LitKind::Char(c), ty::Char) => ConstValue::Scalar(Scalar::from_char(*c)),
(ast::LitKind::Err, _) => {
return Err(LitToConstError::Reported(
- tcx.dcx().span_delayed_bug(DUMMY_SP, "encountered LitKind::Err during mir build"),
+ tcx.dcx().delayed_bug("encountered LitKind::Err during mir build"),
));
}
_ => return Err(LitToConstError::TypeError),
diff --git a/compiler/rustc_mir_build/src/thir/constant.rs b/compiler/rustc_mir_build/src/thir/constant.rs
index 3a56b03948e..8d5e6cd4f41 100644
--- a/compiler/rustc_mir_build/src/thir/constant.rs
+++ b/compiler/rustc_mir_build/src/thir/constant.rs
@@ -1,7 +1,6 @@
use rustc_ast as ast;
use rustc_middle::mir::interpret::{LitToConstError, LitToConstInput};
use rustc_middle::ty::{self, ParamEnv, ScalarInt, TyCtxt};
-use rustc_span::DUMMY_SP;
use crate::build::parse_float_into_scalar;
@@ -13,15 +12,15 @@ pub(crate) fn lit_to_const<'tcx>(
let trunc = |n| {
let param_ty = ParamEnv::reveal_all().and(ty);
- let width = tcx
- .layout_of(param_ty)
- .map_err(|_| {
- LitToConstError::Reported(tcx.dcx().span_delayed_bug(
- DUMMY_SP,
- format!("couldn't compute width of literal: {:?}", lit_input.lit),
- ))
- })?
- .size;
+ let width =
+ tcx.layout_of(param_ty)
+ .map_err(|_| {
+ LitToConstError::Reported(tcx.dcx().delayed_bug(format!(
+ "couldn't compute width of literal: {:?}",
+ lit_input.lit
+ )))
+ })?
+ .size;
trace!("trunc {} with size {} and shift {}", n, width.bits(), 128 - width.bits());
let result = width.truncate(n);
trace!("trunc result: {}", result);
@@ -60,20 +59,21 @@ pub(crate) fn lit_to_const<'tcx>(
}
(ast::LitKind::Bool(b), ty::Bool) => ty::ValTree::from_scalar_int((*b).into()),
(ast::LitKind::Float(n, _), ty::Float(fty)) => {
- let bits = parse_float_into_scalar(*n, *fty, neg)
- .ok_or_else(|| {
- LitToConstError::Reported(tcx.dcx().span_delayed_bug(
- DUMMY_SP,
- format!("couldn't parse float literal: {:?}", lit_input.lit),
- ))
- })?
- .assert_int();
+ let bits =
+ parse_float_into_scalar(*n, *fty, neg)
+ .ok_or_else(|| {
+ LitToConstError::Reported(tcx.dcx().delayed_bug(format!(
+ "couldn't parse float literal: {:?}",
+ lit_input.lit
+ )))
+ })?
+ .assert_int();
ty::ValTree::from_scalar_int(bits)
}
(ast::LitKind::Char(c), ty::Char) => ty::ValTree::from_scalar_int((*c).into()),
(ast::LitKind::Err, _) => {
return Err(LitToConstError::Reported(
- tcx.dcx().span_delayed_bug(DUMMY_SP, "encountered LitKind::Err during mir build"),
+ tcx.dcx().delayed_bug("encountered LitKind::Err during mir build"),
));
}
_ => return Err(LitToConstError::TypeError),
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
index e9da12d118e..619e7d39268 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -11,7 +11,9 @@ use rustc_arena::{DroplessArena, TypedArena};
use rustc_ast::Mutability;
use rustc_data_structures::fx::FxIndexSet;
use rustc_data_structures::stack::ensure_sufficient_stack;
-use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder, ErrorGuaranteed, MultiSpan};
+use rustc_errors::{
+ struct_span_code_err, Applicability, DiagnosticBuilder, ErrorGuaranteed, MultiSpan,
+};
use rustc_hir as hir;
use rustc_hir::def::*;
use rustc_hir::def_id::LocalDefId;
@@ -55,7 +57,7 @@ pub(crate) fn check_match(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(), Err
}
fn create_e0004(sess: &Session, sp: Span, error_message: String) -> DiagnosticBuilder<'_> {
- struct_span_err!(sess.dcx(), sp, E0004, "{}", &error_message)
+ struct_span_code_err!(sess.dcx(), sp, E0004, "{}", &error_message)
}
#[derive(Debug, Copy, Clone, PartialEq)]
diff --git a/compiler/rustc_monomorphize/src/partitioning.rs b/compiler/rustc_monomorphize/src/partitioning.rs
index 08e62840839..2c40cd4d8f2 100644
--- a/compiler/rustc_monomorphize/src/partitioning.rs
+++ b/compiler/rustc_monomorphize/src/partitioning.rs
@@ -1093,7 +1093,7 @@ fn collect_and_partition_mono_items(tcx: TyCtxt<'_>, (): ()) -> (&DefIdSet, &[Co
MonoItemCollectionMode::Eager
} else {
if mode != "lazy" {
- tcx.dcx().emit_warning(UnknownCguCollectionMode { mode });
+ tcx.dcx().emit_warn(UnknownCguCollectionMode { mode });
}
MonoItemCollectionMode::Lazy
diff --git a/compiler/rustc_parse/src/lexer/mod.rs b/compiler/rustc_parse/src/lexer/mod.rs
index a45bc581240..7db9291921f 100644
--- a/compiler/rustc_parse/src/lexer/mod.rs
+++ b/compiler/rustc_parse/src/lexer/mod.rs
@@ -250,7 +250,7 @@ impl<'a> StringReader<'a> {
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 @@ impl<'a> StringReader<'a> {
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 @@ impl<'a> StringReader<'a> {
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 @@ impl<'a> StringReader<'a> {
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 @@ impl<'a> StringReader<'a> {
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 @@ impl<'a> StringReader<'a> {
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" "
diff --git a/compiler/rustc_parse/src/lexer/unescape_error_reporting.rs b/compiler/rustc_parse/src/lexer/unescape_error_reporting.rs
index 775082adbe8..fbc77f28780 100644
--- a/compiler/rustc_parse/src/lexer/unescape_error_reporting.rs
+++ b/compiler/rustc_parse/src/lexer/unescape_error_reporting.rs
@@ -264,14 +264,14 @@ pub(crate) fn emit_unescape_error(
}
EscapeError::UnskippedWhitespaceWarning => {
let (c, char_span) = last_char();
- dcx.emit_warning(UnescapeError::UnskippedWhitespace {
+ dcx.emit_warn(UnescapeError::UnskippedWhitespace {
span: err_span,
ch: escaped_char(c),
char_span,
});
}
EscapeError::MultipleSkippedLinesWarning => {
- dcx.emit_warning(UnescapeError::MultipleSkippedLinesWarning(err_span));
+ dcx.emit_warn(UnescapeError::MultipleSkippedLinesWarning(err_span));
}
}
}
diff --git a/compiler/rustc_parse/src/lib.rs b/compiler/rustc_parse/src/lib.rs
index d7604d7cebc..b93f08a21e3 100644
--- a/compiler/rustc_parse/src/lib.rs
+++ b/compiler/rustc_parse/src/lib.rs
@@ -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();
}
}
diff --git a/compiler/rustc_parse/src/parser/attr.rs b/compiler/rustc_parse/src/parser/attr.rs
index cec657f7b67..02dab95233a 100644
--- a/compiler/rustc_parse/src/parser/attr.rs
+++ b/compiler/rustc_parse/src/parser/attr.rs
@@ -204,8 +204,11 @@ impl<'a> Parser<'a> {
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 @@ impl<'a> Parser<'a> {
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)
}
diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
index a9cf26d991c..720a610fdf5 100644
--- a/compiler/rustc_parse/src/parser/diagnostics.rs
+++ b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -2847,8 +2847,8 @@ impl<'a> Parser<'a> {
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",
"",
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index db777266b59..8ca02452342 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -1753,7 +1753,7 @@ impl<'a> Parser<'a> {
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 @@ impl<'a> Parser<'a> {
.emit();
} else {
err(self)
- .span_suggestion_verbose_mv(
+ .with_span_suggestion_verbose(
lifetime.span.shrink_to_hi(),
"add `'` to close the char literal",
"'",
@@ -2150,7 +2150,7 @@ impl<'a> Parser<'a> {
if [sym::i32, sym::u32, sym::isize, sym::usize].contains(&suffix) {
// #59553: warn instead of reject out of hand to allow the fix to percolate
// through the ecosystem when people fix their macros
- self.dcx().emit_warning(errors::InvalidLiteralSuffixOnTupleIndex {
+ self.dcx().emit_warn(errors::InvalidLiteralSuffixOnTupleIndex {
span,
suffix,
exception: Some(()),
diff --git a/compiler/rustc_parse/src/parser/generics.rs b/compiler/rustc_parse/src/parser/generics.rs
index 66aa8cbcda4..48cf04f7790 100644
--- a/compiler/rustc_parse/src/parser/generics.rs
+++ b/compiler/rustc_parse/src/parser/generics.rs
@@ -145,7 +145,7 @@ impl<'a> Parser<'a> {
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(),
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
index fed3c83a81d..bcff820da79 100644
--- a/compiler/rustc_parse/src/parser/item.rs
+++ b/compiler/rustc_parse/src/parser/item.rs
@@ -10,7 +10,7 @@ use rustc_ast::tokenstream::{DelimSpan, TokenStream, TokenTree};
use rustc_ast::util::case::Case;
use rustc_ast::{self as ast};
use rustc_ast_pretty::pprust;
-use rustc_errors::{struct_span_err, Applicability, PResult, StashKey};
+use rustc_errors::{struct_span_code_err, Applicability, PResult, StashKey};
use rustc_span::edit_distance::edit_distance;
use rustc_span::edition::Edition;
use rustc_span::source_map;
@@ -741,11 +741,11 @@ impl<'a> Parser<'a> {
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;
}
@@ -759,14 +759,14 @@ impl<'a> Parser<'a> {
if let token::DocComment(..) = self.token.kind {
if self.look_ahead(1, |tok| tok == &token::CloseDelim(Delimiter::Brace)) {
// FIXME: merge with `DocCommentDoesNotDocumentAnything` (E0585)
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
self.token.span,
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 @@ impl<'a> Parser<'a> {
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 @@ impl<'a> Parser<'a> {
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 @@ impl<'a> Parser<'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 @@ impl<'a> Parser<'a> {
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 @@ impl<'a> Parser<'a> {
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);
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index c13adfb0532..ff2fb6271a8 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -847,7 +847,7 @@ impl<'a> Parser<'a> {
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 @@ impl<'a> Parser<'a> {
// 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,
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
index 00dc307ab60..7918e03750c 100644
--- a/compiler/rustc_parse/src/parser/pat.rs
+++ b/compiler/rustc_parse/src/parser/pat.rs
@@ -464,7 +464,7 @@ impl<'a> Parser<'a> {
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 {
diff --git a/compiler/rustc_parse/src/parser/path.rs b/compiler/rustc_parse/src/parser/path.rs
index 5ad17a30980..e7cad74b4dd 100644
--- a/compiler/rustc_parse/src/parser/path.rs
+++ b/compiler/rustc_parse/src/parser/path.rs
@@ -128,7 +128,7 @@ impl<'a> Parser<'a> {
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",
"::",
diff --git a/compiler/rustc_parse/src/parser/ty.rs b/compiler/rustc_parse/src/parser/ty.rs
index 61d72857c36..a4fb92c67ac 100644
--- a/compiler/rustc_parse/src/parser/ty.rs
+++ b/compiler/rustc_parse/src/parser/ty.rs
@@ -1116,7 +1116,7 @@ impl<'a> Parser<'a> {
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,
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index 724d574349a..2fafbd6d97b 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -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"
diff --git a/compiler/rustc_passes/src/check_const.rs b/compiler/rustc_passes/src/check_const.rs
index 3e5fb1a6b47..3e3f2771f5f 100644
--- a/compiler/rustc_passes/src/check_const.rs
+++ b/compiler/rustc_passes/src/check_const.rs
@@ -122,7 +122,7 @@ impl<'tcx> CheckConstVisitor<'tcx> {
// corresponding feature gate. This encourages nightly users to use feature gates when
// possible.
None if tcx.sess.opts.unstable_opts.unleash_the_miri_inside_of_you => {
- tcx.dcx().emit_warning(SkippingConstChecks { span });
+ tcx.dcx().emit_warn(SkippingConstChecks { span });
return;
}
diff --git a/compiler/rustc_passes/src/hir_id_validator.rs b/compiler/rustc_passes/src/hir_id_validator.rs
index 0727bad7c5a..02f56ecb10b 100644
--- a/compiler/rustc_passes/src/hir_id_validator.rs
+++ b/compiler/rustc_passes/src/hir_id_validator.rs
@@ -31,7 +31,7 @@ pub fn check_crate(tcx: TyCtxt<'_>) {
if !errors.is_empty() {
let message = errors.iter().fold(String::new(), |s1, s2| s1 + "\n" + s2);
- tcx.dcx().span_delayed_bug(rustc_span::DUMMY_SP, message);
+ tcx.dcx().delayed_bug(message);
}
}
}
diff --git a/compiler/rustc_passes/src/liveness.rs b/compiler/rustc_passes/src/liveness.rs
index aba08e8b5ca..92687c705ae 100644
--- a/compiler/rustc_passes/src/liveness.rs
+++ b/compiler/rustc_passes/src/liveness.rs
@@ -98,7 +98,6 @@ use rustc_middle::query::Providers;
use rustc_middle::ty::{self, RootVariableMinCaptureList, Ty, TyCtxt};
use rustc_session::lint;
use rustc_span::symbol::{kw, sym, Symbol};
-use rustc_span::DUMMY_SP;
use rustc_span::{BytePos, Span};
use std::io;
@@ -560,7 +559,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
match self.successors[ln] {
Some(successor) => self.assigned_on_entry(successor, var),
None => {
- self.ir.tcx.dcx().span_delayed_bug(DUMMY_SP, "no successor");
+ self.ir.tcx.dcx().delayed_bug("no successor");
true
}
}
diff --git a/compiler/rustc_query_system/src/query/plumbing.rs b/compiler/rustc_query_system/src/query/plumbing.rs
index c5a0cc753a8..3bb2cc5634f 100644
--- a/compiler/rustc_query_system/src/query/plumbing.rs
+++ b/compiler/rustc_query_system/src/query/plumbing.rs
@@ -431,17 +431,14 @@ where
// We have an inconsistency. This can happen if one of the two
// results is tainted by errors. In this case, delay a bug to
// ensure compilation is doomed.
- qcx.dep_context().sess().dcx().span_delayed_bug(
- DUMMY_SP,
- format!(
- "Computed query value for {:?}({:?}) is inconsistent with fed value,\n\
+ qcx.dep_context().sess().dcx().delayed_bug(format!(
+ "Computed query value for {:?}({:?}) is inconsistent with fed value,\n\
computed={:#?}\nfed={:#?}",
- query.dep_kind(),
- key,
- formatter(&result),
- formatter(&cached_result),
- ),
- );
+ query.dep_kind(),
+ key,
+ formatter(&result),
+ formatter(&cached_result),
+ ));
}
}
}
diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index e176b8b4043..9ccfde5e3c6 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -19,7 +19,7 @@ use rustc_ast::{self as ast, AssocItem, AssocItemKind, MetaItemKind, StmtKind};
use rustc_ast::{Block, Fn, ForeignItem, ForeignItemKind, Impl, Item, ItemKind, NodeId};
use rustc_attr as attr;
use rustc_data_structures::sync::Lrc;
-use rustc_errors::{struct_span_err, Applicability};
+use rustc_errors::{struct_span_code_err, Applicability};
use rustc_expand::expand::AstFragment;
use rustc_hir::def::{self, *};
use rustc_hir::def_id::{DefId, LocalDefId, CRATE_DEF_ID};
@@ -818,7 +818,7 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
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 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
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();
}
}
@@ -1010,7 +1010,7 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
for attr in &item.attrs {
if attr.has_name(sym::macro_use) {
if self.parent_scope.module.parent.is_some() {
- struct_span_err!(
+ struct_span_code_err!(
self.r.dcx(),
item.span,
E0468,
@@ -1024,7 +1024,7 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
}
}
let ill_formed = |span| {
- struct_span_err!(self.r.dcx(), span, E0466, "bad macro import").emit();
+ struct_span_code_err!(self.r.dcx(), span, E0466, "bad macro import").emit();
};
match attr.meta() {
Some(meta) => match meta.kind {
@@ -1095,8 +1095,13 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
allow_shadowing,
);
} else {
- struct_span_err!(self.r.dcx(), ident.span, E0469, "imported macro not found")
- .emit();
+ struct_span_code_err!(
+ self.r.dcx(),
+ ident.span,
+ E0469,
+ "imported macro not found"
+ )
+ .emit();
}
}
}
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index 57f23200e79..0d744238eeb 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -6,7 +6,7 @@ use rustc_ast::{MetaItemKind, NestedMetaItem};
use rustc_ast_pretty::pprust;
use rustc_data_structures::fx::FxHashSet;
use rustc_errors::{
- pluralize, report_ambiguity_error, struct_span_err, Applicability, DiagCtxt, Diagnostic,
+ pluralize, report_ambiguity_error, struct_span_code_err, Applicability, DiagCtxt, Diagnostic,
DiagnosticBuilder, ErrorGuaranteed, MultiSpan, SuggestionStyle,
};
use rustc_feature::BUILTIN_ATTRIBUTES;
@@ -153,7 +153,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
BuiltinLintDiagnostics::AmbiguousGlobImports { diag },
);
} else {
- let mut err = struct_span_err!(self.dcx(), diag.span, E0659, "{}", &diag.msg);
+ let mut err = struct_span_code_err!(self.dcx(), diag.span, E0659, "{}", &diag.msg);
report_ambiguity_error(&mut err, diag);
err.emit();
}
@@ -254,15 +254,15 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
let msg = format!("the name `{name}` is defined multiple times");
let mut err = match (old_binding.is_extern_crate(), new_binding.is_extern_crate()) {
- (true, true) => struct_span_err!(self.dcx(), span, E0259, "{}", msg),
+ (true, true) => struct_span_code_err!(self.dcx(), span, E0259, "{}", msg),
(true, _) | (_, true) => match new_binding.is_import() && old_binding.is_import() {
- true => struct_span_err!(self.dcx(), span, E0254, "{}", msg),
- false => struct_span_err!(self.dcx(), span, E0260, "{}", msg),
+ true => struct_span_code_err!(self.dcx(), span, E0254, "{}", msg),
+ false => struct_span_code_err!(self.dcx(), span, E0260, "{}", msg),
},
_ => match (old_binding.is_import_user_facing(), new_binding.is_import_user_facing()) {
- (false, false) => struct_span_err!(self.dcx(), span, E0428, "{}", msg),
- (true, true) => struct_span_err!(self.dcx(), span, E0252, "{}", msg),
- _ => struct_span_err!(self.dcx(), span, E0255, "{}", msg),
+ (false, false) => struct_span_code_err!(self.dcx(), span, E0428, "{}", msg),
+ (true, true) => struct_span_code_err!(self.dcx(), span, E0252, "{}", msg),
+ _ => struct_span_code_err!(self.dcx(), span, E0255, "{}", msg),
},
};
@@ -659,7 +659,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
let origin_sp = origin.iter().copied().collect::<Vec<_>>();
let msp = MultiSpan::from_spans(target_sp.clone());
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.dcx(),
msp,
E0408,
@@ -788,7 +788,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
}
ResolutionError::FailedToResolve { last_segment, label, suggestion, module } => {
let mut err =
- struct_span_err!(self.dcx(), span, E0433, "failed to resolve: {}", &label);
+ struct_span_code_err!(self.dcx(), span, E0433, "failed to resolve: {}", &label);
err.span_label(span, label);
if let Some((suggestions, msg, applicability)) = suggestion {
@@ -950,9 +950,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
"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()
@@ -1702,8 +1702,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
// Print the primary message.
let descr = get_descr(binding);
- let mut err =
- struct_span_err!(self.dcx(), ident.span, E0603, "{} `{}` is private", descr, ident);
+ let mut err = struct_span_code_err!(
+ self.dcx(),
+ ident.span,
+ E0603,
+ "{} `{}` is private",
+ descr,
+ ident
+ );
err.span_label(ident.span, format!("private {descr}"));
let mut not_publicly_reexported = false;
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index c5bd7ffa038..2ebf4c20562 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -17,7 +17,7 @@ use crate::{NameBinding, NameBindingData, NameBindingKind, PathResult};
use rustc_ast::NodeId;
use rustc_data_structures::fx::FxHashSet;
use rustc_data_structures::intern::Interned;
-use rustc_errors::{pluralize, struct_span_err, Applicability, MultiSpan};
+use rustc_errors::{pluralize, struct_span_code_err, Applicability, MultiSpan};
use rustc_hir::def::{self, DefKind, PartialRes};
use rustc_middle::metadata::ModChild;
use rustc_middle::metadata::Reexport;
@@ -686,7 +686,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
.collect::<Vec<_>>();
let msg = format!("unresolved import{} {}", pluralize!(paths.len()), paths.join(", "),);
- let mut diag = struct_span_err!(self.dcx(), span, E0432, "{}", &msg);
+ let mut diag = struct_span_code_err!(self.dcx(), span, E0432, "{}", &msg);
if let Some((_, UnresolvedImportError { note: Some(note), .. })) = errors.iter().last() {
diag.note(note.clone());
@@ -1371,12 +1371,12 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
let ImportKind::Glob { id, is_prelude, .. } = import.kind else { unreachable!() };
let ModuleOrUniformRoot::Module(module) = import.imported_module.get().unwrap() else {
- self.dcx().create_err(CannotGlobImportAllCrates { span: import.span }).emit();
+ self.dcx().emit_err(CannotGlobImportAllCrates { span: import.span });
return;
};
if module.is_trait() {
- self.dcx().create_err(ItemsInTraitsAreNotImportable { span: import.span }).emit();
+ self.dcx().emit_err(ItemsInTraitsAreNotImportable { span: import.span });
return;
} else if module == import.parent_scope.module {
return;
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index 059ccaebc82..4a3c8dfe3d7 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -1664,7 +1664,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
} else {
("`'_` cannot be used here", "`'_` is a reserved lifetime name")
};
- let mut diag = rustc_errors::struct_span_err!(
+ let mut diag = rustc_errors::struct_span_code_err!(
self.r.dcx(),
lifetime.ident.span,
E0637,
@@ -1853,7 +1853,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
LifetimeRibKind::AnonymousCreateParameter { report_in_path: true, .. }
| LifetimeRibKind::AnonymousWarn(_) => {
let sess = self.r.tcx.sess;
- let mut err = rustc_errors::struct_span_err!(
+ let mut err = rustc_errors::struct_span_code_err!(
sess.dcx(),
path_span,
E0726,
@@ -2301,7 +2301,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
let report_error = |this: &Self, ns| {
if this.should_report_errs() {
let what = if ns == TypeNS { "type parameters" } else { "local variables" };
- this.r.dcx().create_err(ImportsCannotReferTo { span: ident.span, what }).emit();
+ this.r.dcx().emit_err(ImportsCannotReferTo { span: ident.span, what });
}
};
@@ -2594,13 +2594,13 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
}
if param.ident.name == kw::UnderscoreLifetime {
- rustc_errors::struct_span_err!(
+ rustc_errors::struct_span_code_err!(
self.r.dcx(),
param.ident.span,
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);
@@ -2608,14 +2608,14 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
}
if param.ident.name == kw::StaticLifetime {
- rustc_errors::struct_span_err!(
+ rustc_errors::struct_span_code_err!(
self.r.dcx(),
param.ident.span,
E0262,
"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);
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index a36d1377ab5..2f476ae6cbc 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -16,7 +16,7 @@ use rustc_ast::{
use rustc_ast_pretty::pprust::where_bound_predicate_to_string;
use rustc_data_structures::fx::FxHashSet;
use rustc_errors::{
- pluralize, struct_span_err, Applicability, Diagnostic, DiagnosticBuilder, ErrorGuaranteed,
+ pluralize, struct_span_code_err, Applicability, Diagnostic, DiagnosticBuilder, ErrorGuaranteed,
MultiSpan, SuggestionStyle,
};
use rustc_hir as hir;
@@ -2603,23 +2603,23 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
) {
debug_assert_ne!(lifetime_ref.ident.name, kw::UnderscoreLifetime);
let mut err = if let Some(outer) = outer_lifetime_ref {
- struct_span_err!(
+ struct_span_code_err!(
self.r.dcx(),
lifetime_ref.ident.span,
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_err!(
+ struct_span_code_err!(
self.r.dcx(),
lifetime_ref.ident.span,
E0261,
"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,
@@ -2777,7 +2777,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
let num_lifetimes: usize = lifetime_refs.iter().map(|lt| lt.count).sum();
let spans: Vec<_> = lifetime_refs.iter().map(|lt| lt.span).collect();
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.r.dcx(),
spans,
E0106,
@@ -3282,15 +3282,15 @@ fn mk_where_bound_predicate(
/// Report lifetime/lifetime shadowing as an error.
pub(super) fn signal_lifetime_shadowing(sess: &Session, orig: Ident, shadower: Ident) {
- struct_span_err!(
+ struct_span_code_err!(
sess.dcx(),
shadower.span,
E0496,
"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();
}
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
index fc55481cb01..66ecaeb4449 100644
--- a/compiler/rustc_resolve/src/macros.rs
+++ b/compiler/rustc_resolve/src/macros.rs
@@ -15,7 +15,7 @@ use rustc_ast_pretty::pprust;
use rustc_attr::StabilityLevel;
use rustc_data_structures::intern::Interned;
use rustc_data_structures::sync::Lrc;
-use rustc_errors::{struct_span_err, Applicability};
+use rustc_errors::{struct_span_code_err, Applicability};
use rustc_expand::base::{Annotatable, DeriveResolutions, Indeterminate, ResolverExpand};
use rustc_expand::base::{SyntaxExtension, SyntaxExtensionKind};
use rustc_expand::compile_declarative_macro;
@@ -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 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
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));
@@ -948,13 +948,13 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
rule_spans = Vec::new();
}
BuiltinMacroState::AlreadySeen(span) => {
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
item.span,
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();
}
}
diff --git a/compiler/rustc_session/src/errors.rs b/compiler/rustc_session/src/errors.rs
index 8baa5d892a5..b672e760feb 100644
--- a/compiler/rustc_session/src/errors.rs
+++ b/compiler/rustc_session/src/errors.rs
@@ -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))
}
}
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
index 720599f6095..210dc9e0145 100644
--- a/compiler/rustc_session/src/session.rs
+++ b/compiler/rustc_session/src/session.rs
@@ -263,7 +263,7 @@ impl Session {
if !unleashed_features.is_empty() {
let mut must_err = false;
// Create a diagnostic pointing at where things got unleashed.
- self.dcx().emit_warning(errors::SkippingConstChecks {
+ self.dcx().emit_warn(errors::SkippingConstChecks {
unleashed_features: unleashed_features
.iter()
.map(|(span, gate)| {
@@ -341,10 +341,7 @@ impl Session {
if self.dcx().err_count() == old_count {
Ok(result)
} else {
- Err(self.dcx().span_delayed_bug(
- rustc_span::DUMMY_SP,
- "`self.err_count()` changed but an error was not emitted",
- ))
+ Err(self.dcx().delayed_bug("`self.err_count()` changed but an error was not emitted"))
}
}
@@ -574,7 +571,7 @@ impl Session {
// We only call `msg` in case we can actually emit warnings.
// Otherwise, this could cause a `good_path_delayed_bug` to
// trigger (issue #79546).
- self.dcx().emit_warning(errors::OptimisationFuelExhausted { msg: msg() });
+ self.dcx().emit_warn(errors::OptimisationFuelExhausted { msg: msg() });
}
fuel.out_of_fuel = true;
} else if fuel.remaining > 0 {
@@ -1129,7 +1126,7 @@ pub fn build_session(
match profiler {
Ok(profiler) => Some(Arc::new(profiler)),
Err(e) => {
- dcx.emit_warning(errors::FailedToCreateProfiler { err: e.to_string() });
+ dcx.emit_warn(errors::FailedToCreateProfiler { err: e.to_string() });
None
}
}
@@ -1341,7 +1338,7 @@ fn validate_commandline_args_with_session_available(sess: &Session) {
if sess.opts.unstable_opts.stack_protector != StackProtector::None {
if !sess.target.options.supports_stack_protector {
- sess.dcx().emit_warning(errors::StackProtectorNotSupportedForTarget {
+ sess.dcx().emit_warn(errors::StackProtectorNotSupportedForTarget {
stack_protector: sess.opts.unstable_opts.stack_protector,
target_triple: &sess.opts.target_triple,
});
@@ -1447,7 +1444,7 @@ impl EarlyDiagCtxt {
#[allow(rustc::untranslatable_diagnostic)]
#[allow(rustc::diagnostic_outside_of_impl)]
pub fn early_note(&self, msg: impl Into<DiagnosticMessage>) {
- self.dcx.struct_note(msg).emit()
+ self.dcx.note(msg)
}
#[allow(rustc::untranslatable_diagnostic)]
@@ -1460,13 +1457,13 @@ impl EarlyDiagCtxt {
#[allow(rustc::diagnostic_outside_of_impl)]
#[must_use = "ErrorGuaranteed must be returned from `run_compiler` in order to exit with a non-zero status code"]
pub fn early_err(&self, msg: impl Into<DiagnosticMessage>) -> ErrorGuaranteed {
- self.dcx.struct_err(msg).emit()
+ self.dcx.err(msg)
}
#[allow(rustc::untranslatable_diagnostic)]
#[allow(rustc::diagnostic_outside_of_impl)]
pub fn early_fatal(&self, msg: impl Into<DiagnosticMessage>) -> ! {
- self.dcx.struct_fatal(msg).emit()
+ self.dcx.fatal(msg)
}
#[allow(rustc::untranslatable_diagnostic)]
@@ -1481,7 +1478,7 @@ impl EarlyDiagCtxt {
#[allow(rustc::untranslatable_diagnostic)]
#[allow(rustc::diagnostic_outside_of_impl)]
pub fn early_warn(&self, msg: impl Into<DiagnosticMessage>) {
- self.dcx.struct_warn(msg).emit()
+ self.dcx.warn(msg)
}
pub fn initialize_checked_jobserver(&self) {
@@ -1491,7 +1488,7 @@ impl EarlyDiagCtxt {
#[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()
});
}
diff --git a/compiler/rustc_symbol_mangling/src/errors.rs b/compiler/rustc_symbol_mangling/src/errors.rs
index 746783ab7e3..2d076f7b225 100644
--- a/compiler/rustc_symbol_mangling/src/errors.rs
+++ b/compiler/rustc_symbol_mangling/src/errors.rs
@@ -18,7 +18,7 @@ impl<G: EmissionGuarantee> IntoDiagnostic<'_, G> for TestOutput {
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)
}
}
diff --git a/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs b/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs
index e119ddeb4c6..522c645253a 100644
--- a/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs
+++ b/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs
@@ -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",
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/infer_ctxt_ext.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/infer_ctxt_ext.rs
index 90e2c1531b4..864580afe62 100644
--- a/compiler/rustc_trait_selection/src/traits/error_reporting/infer_ctxt_ext.rs
+++ b/compiler/rustc_trait_selection/src/traits/error_reporting/infer_ctxt_ext.rs
@@ -1,7 +1,7 @@
use crate::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
use crate::infer::InferCtxt;
use crate::traits::{Obligation, ObligationCause, ObligationCtxt};
-use rustc_errors::{pluralize, struct_span_err, Applicability, DiagnosticBuilder};
+use rustc_errors::{pluralize, struct_span_code_err, Applicability, DiagnosticBuilder};
use rustc_hir as hir;
use rustc_hir::Node;
use rustc_middle::ty::{self, Ty};
@@ -140,7 +140,7 @@ impl<'tcx> InferCtxtExt<'tcx> for InferCtxt<'tcx> {
let expected_str = args_str(&expected_args, &found_args);
let found_str = args_str(&found_args, &expected_args);
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.dcx(),
span,
E0593,
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/on_unimplemented.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/on_unimplemented.rs
index c9e8b30c4c4..100c9a70aaa 100644
--- a/compiler/rustc_trait_selection/src/traits/error_reporting/on_unimplemented.rs
+++ b/compiler/rustc_trait_selection/src/traits/error_reporting/on_unimplemented.rs
@@ -6,7 +6,7 @@ use rustc_ast::AttrKind;
use rustc_ast::{Attribute, MetaItem, NestedMetaItem};
use rustc_attr as attr;
use rustc_data_structures::fx::FxHashMap;
-use rustc_errors::{struct_span_err, ErrorGuaranteed};
+use rustc_errors::{struct_span_code_err, ErrorGuaranteed};
use rustc_hir as hir;
use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_middle::ty::GenericArgsRef;
@@ -14,7 +14,7 @@ use rustc_middle::ty::{self, GenericParamDefKind, TyCtxt};
use rustc_parse_format::{ParseMode, Parser, Piece, Position};
use rustc_session::lint::builtin::UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES;
use rustc_span::symbol::{kw, sym, Symbol};
-use rustc_span::{Span, DUMMY_SP};
+use rustc_span::Span;
use std::iter;
use crate::errors::{
@@ -657,9 +657,7 @@ impl<'tcx> OnUnimplementedDirective {
Ok(None)
} else {
- let reported = tcx
- .dcx()
- .span_delayed_bug(DUMMY_SP, "of_item: neither meta_item_list nor value_str");
+ let reported = tcx.dcx().delayed_bug("of_item: neither meta_item_list nor value_str");
return Err(reported);
};
debug!("of_item({:?}) = {:?}", item_def_id, result);
@@ -797,7 +795,7 @@ impl<'tcx> OnUnimplementedFormatString {
},
);
} else {
- result = Err(struct_span_err!(
+ result = Err(struct_span_code_err!(
tcx.dcx(),
self.span,
E0230,
@@ -816,7 +814,7 @@ impl<'tcx> OnUnimplementedFormatString {
}
// `{:1}` and `{}` are not to be used
Position::ArgumentIs(..) | Position::ArgumentImplicitlyIs(_) => {
- let reported = struct_span_err!(
+ let reported = struct_span_code_err!(
tcx.dcx(),
self.span,
E0231,
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
index 4a6ef27e7ba..6c0909d2853 100644
--- a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
@@ -13,7 +13,7 @@ use hir::def::CtorOf;
use rustc_data_structures::fx::FxHashSet;
use rustc_data_structures::stack::ensure_sufficient_stack;
use rustc_errors::{
- error_code, pluralize, struct_span_err, Applicability, Diagnostic, DiagnosticBuilder,
+ error_code, pluralize, struct_span_code_err, Applicability, Diagnostic, DiagnosticBuilder,
MultiSpan, Style, SuggestionStyle,
};
use rustc_hir as hir;
@@ -2145,7 +2145,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
ty::Coroutine(..) => "coroutine",
_ => "function",
};
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.dcx(),
span,
E0631,
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
index b05895e4b9a..47a700805fa 100644
--- a/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
+++ b/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
@@ -19,7 +19,7 @@ use crate::traits::{
};
use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
use rustc_errors::{
- pluralize, struct_span_err, Applicability, Diagnostic, DiagnosticBuilder, ErrorGuaranteed,
+ pluralize, struct_span_code_err, Applicability, Diagnostic, DiagnosticBuilder, ErrorGuaranteed,
MultiSpan, StashKey, Style,
};
use rustc_hir as hir;
@@ -228,7 +228,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
}
}
- self.dcx().span_delayed_bug(DUMMY_SP, "expected fulfillment errors")
+ self.dcx().delayed_bug("expected fulfillment errors")
}
/// Reports that an overflow has occurred and halts compilation. We
@@ -280,7 +280,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
predicate.print(&mut cx).unwrap();
pred_str = cx.into_buffer();
}
- let mut err = struct_span_err!(
+ let mut err = struct_span_code_err!(
self.dcx(),
span,
E0275,
@@ -525,7 +525,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
(err_msg, None)
};
- let mut err = struct_span_err!(self.dcx(), span, E0277, "{}", err_msg);
+ let mut err = struct_span_code_err!(self.dcx(), span, E0277, "{}", err_msg);
let mut suggested = false;
if is_try_conversion {
@@ -1236,7 +1236,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
span_bug!(span, "const param tys cannot mention other generic parameters");
}
ty::Float(_) => {
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
span,
E0741,
@@ -1244,7 +1244,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
)
}
ty::FnPtr(_) => {
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
span,
E0741,
@@ -1252,7 +1252,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
)
}
ty::RawPtr(_) => {
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
span,
E0741,
@@ -1261,7 +1261,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
}
ty::Adt(def, _) => {
// We should probably see if we're *allowed* to derive `ConstParamTy` on the type...
- let mut diag = struct_span_err!(
+ let mut diag = struct_span_code_err!(
self.dcx(),
span,
E0741,
@@ -1293,7 +1293,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
diag
}
_ => {
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
span,
E0741,
@@ -1731,7 +1731,7 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
cx.into_buffer()
}))
});
- let mut diag = struct_span_err!(self.dcx(), obligation.cause.span, E0271, "{msg}");
+ let mut diag = struct_span_code_err!(self.dcx(), obligation.cause.span, E0271, "{msg}");
let secondary_span = (|| {
let ty::PredicateKind::Clause(ty::ClauseKind::Projection(proj)) =
@@ -2421,7 +2421,7 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
true,
)
} else {
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
span,
E0283,
@@ -2661,17 +2661,17 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, '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_err!(
+ struct_span_code_err!(
self.dcx(),
span,
E0284,
"type annotations needed: cannot satisfy `{}`",
predicate,
)
- .span_label_mv(span, format!("cannot satisfy `{predicate}`"))
+ .with_span_label(span, format!("cannot satisfy `{predicate}`"))
}
}
@@ -2691,28 +2691,28 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
err
} else {
// If we can't find a substitution, just print a generic error
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
span,
E0284,
"type annotations needed: cannot satisfy `{}`",
predicate,
)
- .span_label_mv(span, format!("cannot satisfy `{predicate}`"))
+ .with_span_label(span, format!("cannot satisfy `{predicate}`"))
}
}
_ => {
if self.dcx().has_errors().is_some() || self.tainted_by_errors().is_some() {
return;
}
- struct_span_err!(
+ struct_span_code_err!(
self.dcx(),
span,
E0284,
"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 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
//
// 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;
}
diff --git a/compiler/rustc_trait_selection/src/traits/query/normalize.rs b/compiler/rustc_trait_selection/src/traits/query/normalize.rs
index d5f98db2c93..0b73fefd2da 100644
--- a/compiler/rustc_trait_selection/src/traits/query/normalize.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/normalize.rs
@@ -286,10 +286,8 @@ impl<'cx, 'tcx> FallibleTypeFolder<TyCtxt<'tcx>> for QueryNormalizer<'cx, 'tcx>
// Rustdoc normalizes possibly not well-formed types, so only
// treat this as a bug if we're not in rustdoc.
if !tcx.sess.opts.actually_rustdoc {
- tcx.dcx().span_delayed_bug(
- DUMMY_SP,
- format!("unexpected ambiguity: {c_data:?} {result:?}"),
- );
+ tcx.dcx()
+ .delayed_bug(format!("unexpected ambiguity: {c_data:?} {result:?}"));
}
return Err(NoSolution);
}
diff --git a/compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs b/compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs
index f4baae2711f..d533e69a4fa 100644
--- a/compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs
@@ -6,7 +6,7 @@ use rustc_errors::ErrorGuaranteed;
use rustc_infer::infer::region_constraints::RegionConstraintData;
use rustc_middle::traits::query::NoSolution;
use rustc_middle::ty::{TyCtxt, TypeFoldable};
-use rustc_span::{Span, DUMMY_SP};
+use rustc_span::Span;
use std::fmt;
@@ -88,10 +88,9 @@ where
if errors.is_empty() {
Ok(value)
} else {
- Err(infcx.dcx().span_delayed_bug(
- DUMMY_SP,
- format!("errors selecting obligation during MIR typeck: {errors:?}"),
- ))
+ Err(infcx
+ .dcx()
+ .delayed_bug(format!("errors selecting obligation during MIR typeck: {errors:?}")))
}
})?;
diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
index c1145bc30c9..342b12ba498 100644
--- a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -969,7 +969,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
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",
)
diff --git a/compiler/rustc_ty_utils/src/layout.rs b/compiler/rustc_ty_utils/src/layout.rs
index db89fba2a89..b8351463c55 100644
--- a/compiler/rustc_ty_utils/src/layout.rs
+++ b/compiler/rustc_ty_utils/src/layout.rs
@@ -11,7 +11,6 @@ use rustc_middle::ty::print::with_no_trimmed_paths;
use rustc_middle::ty::{self, AdtDef, EarlyBinder, GenericArgsRef, Ty, TyCtxt, TypeVisitableExt};
use rustc_session::{DataTypeKind, FieldInfo, FieldKind, SizeKind, VariantInfo};
use rustc_span::symbol::Symbol;
-use rustc_span::DUMMY_SP;
use rustc_target::abi::*;
use std::fmt::Debug;
@@ -91,7 +90,7 @@ fn univariant_uninterned<'tcx>(
let dl = cx.data_layout();
let pack = repr.pack;
if pack.is_some() && repr.align.is_some() {
- cx.tcx.dcx().span_delayed_bug(DUMMY_SP, "struct cannot be packed and aligned");
+ cx.tcx.dcx().delayed_bug("struct cannot be packed and aligned");
return Err(cx.tcx.arena.alloc(LayoutError::Unknown(ty)));
}
@@ -344,10 +343,7 @@ fn layout_of_uncached<'tcx>(
ty::Adt(def, args) if def.repr().simd() => {
if !def.is_struct() {
// Should have yielded E0517 by now.
- tcx.dcx().span_delayed_bug(
- DUMMY_SP,
- "#[repr(simd)] was applied to an ADT that is not a struct",
- );
+ tcx.dcx().delayed_bug("#[repr(simd)] was applied to an ADT that is not a struct");
return Err(error(cx, LayoutError::Unknown(ty)));
}
@@ -374,8 +370,7 @@ fn layout_of_uncached<'tcx>(
// (should be caught by typeck)
for fi in fields {
if fi.ty(tcx, args) != f0_ty {
- tcx.dcx().span_delayed_bug(
- DUMMY_SP,
+ tcx.dcx().delayed_bug(
"#[repr(simd)] was applied to an ADT with heterogeneous field type",
);
return Err(error(cx, LayoutError::Unknown(ty)));
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 4441060de98..9c0a8634990 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -2995,13 +2995,13 @@ fn clean_use_statement_inner<'tcx>(
visibility.is_accessible_from(parent_mod, cx.tcx) && !current_mod.is_top_level_module();
if pub_underscore && let Some(ref inline) = inline_attr {
- rustc_errors::struct_span_err!(
+ rustc_errors::struct_span_code_err!(
cx.tcx.dcx(),
inline.span(),
E0780,
"anonymous imports cannot be inlined"
)
- .span_label_mv(import.span, "anonymous import")
+ .with_span_label(import.span, "anonymous import")
.emit();
}
diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs
index 614a64d4020..3f7f9270b2d 100644
--- a/src/librustdoc/config.rs
+++ b/src/librustdoc/config.rs
@@ -421,7 +421,7 @@ impl Options {
let paths = match theme::load_css_paths(content) {
Ok(p) => p,
Err(e) => {
- dcx.struct_err(e).emit();
+ dcx.err(e);
return Err(1);
}
};
@@ -452,10 +452,10 @@ impl Options {
let input = PathBuf::from(if describe_lints {
"" // dummy, this won't be used
} else if matches.free.is_empty() {
- dcx.struct_err("missing file operand").emit();
+ dcx.err("missing file operand");
return Err(1);
} else if matches.free.len() > 1 {
- dcx.struct_err("too many file operands").emit();
+ dcx.err("too many file operands");
return Err(1);
} else {
&matches.free[0]
@@ -467,7 +467,7 @@ impl Options {
let extern_html_root_urls = match parse_extern_html_roots(matches) {
Ok(ex) => ex,
Err(err) => {
- dcx.struct_err(err).emit();
+ dcx.err(err);
return Err(1);
}
};
@@ -534,7 +534,7 @@ impl Options {
let output = matches.opt_str("output").map(|s| PathBuf::from(&s));
let output = match (out_dir, output) {
(Some(_), Some(_)) => {
- dcx.struct_err("cannot use both 'out-dir' and 'output' at once").emit();
+ dcx.err("cannot use both 'out-dir' and 'output' at once");
return Err(1);
}
(Some(out_dir), None) => out_dir,
@@ -549,7 +549,7 @@ impl Options {
if let Some(ref p) = extension_css {
if !p.is_file() {
- dcx.struct_err("option --extend-css argument must be a file").emit();
+ dcx.err("option --extend-css argument must be a file");
return Err(1);
}
}
@@ -567,7 +567,7 @@ impl Options {
let paths = match theme::load_css_paths(content) {
Ok(p) => p,
Err(e) => {
- dcx.struct_err(e).emit();
+ dcx.err(e);
return Err(1);
}
};
@@ -577,26 +577,26 @@ impl Options {
{
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);
}
let (success, ret) = theme::test_theme_against(&theme_file, &paths, &dcx);
if !success {
- dcx.struct_err(format!("error loading theme file: \"{theme_s}\"")).emit();
+ dcx.err(format!("error loading theme file: \"{theme_s}\""));
return Err(1);
} else if !ret.is_empty() {
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();
@@ -626,7 +626,7 @@ impl Options {
match matches.opt_str("r").as_deref() {
Some("rust") | None => {}
Some(s) => {
- dcx.struct_err(format!("unknown input format: {s}")).emit();
+ dcx.err(format!("unknown input format: {s}"));
return Err(1);
}
}
@@ -634,7 +634,7 @@ impl Options {
let index_page = matches.opt_str("index-page").map(|s| PathBuf::from(&s));
if let Some(ref index_page) = index_page {
if !index_page.is_file() {
- dcx.struct_err("option `--index-page` argument must be a file").emit();
+ dcx.err("option `--index-page` argument must be a file");
return Err(1);
}
}
@@ -646,7 +646,7 @@ impl Options {
let crate_types = match parse_crate_types_from_list(matches.opt_strs("crate-type")) {
Ok(types) => types,
Err(e) => {
- dcx.struct_err(format!("unknown crate type: {e}")).emit();
+ dcx.err(format!("unknown crate type: {e}"));
return Err(1);
}
};
@@ -664,7 +664,7 @@ impl Options {
out_fmt
}
Err(e) => {
- dcx.struct_err(e).emit();
+ dcx.err(e);
return Err(1);
}
},
@@ -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",
)
diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs
index 40ea4346f93..fa72758c216 100644
--- a/src/librustdoc/core.rs
+++ b/src/librustdoc/core.rs
@@ -495,15 +495,15 @@ impl<'tcx> Visitor<'tcx> for EmitIgnoredResolutionErrors<'tcx> {
.intersperse("::")
.collect::<String>()
);
- rustc_errors::struct_span_err!(
+ rustc_errors::struct_span_code_err!(
self.tcx.dcx(),
path.span,
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,
diff --git a/src/librustdoc/externalfiles.rs b/src/librustdoc/externalfiles.rs
index 8bc0cdf3a95..57e82b877bf 100644
--- a/src/librustdoc/externalfiles.rs
+++ b/src/librustdoc/externalfiles.rs
@@ -96,7 +96,7 @@ pub(crate) fn load_string<P: AsRef<Path>>(
match str::from_utf8(&contents) {
Ok(s) => Ok(s.to_string()),
Err(_) => {
- dcx.struct_err(format!("error reading `{}`: not UTF-8", file_path.display())).emit();
+ dcx.err(format!("error reading `{}`: not UTF-8", file_path.display()));
Err(LoadStringError::BadUtf8)
}
}
diff --git a/src/librustdoc/html/render/context.rs b/src/librustdoc/html/render/context.rs
index aad63f8578a..fc6f51e8272 100644
--- a/src/librustdoc/html/render/context.rs
+++ b/src/librustdoc/html/render/context.rs
@@ -757,8 +757,7 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> {
// Flush pending errors.
Rc::get_mut(&mut self.shared).unwrap().fs.close();
- let nb_errors =
- self.shared.errors.iter().map(|err| self.tcx().dcx().struct_err(err).emit()).count();
+ let nb_errors = self.shared.errors.iter().map(|err| self.tcx().dcx().err(err)).count();
if nb_errors > 0 {
Err(Error::new(io::Error::new(io::ErrorKind::Other, "I/O error"), ""))
} else {
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index ad1838c53ad..d962beda4be 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -676,10 +676,7 @@ type MainResult = Result<(), ErrorGuaranteed>;
fn wrap_return(dcx: &rustc_errors::DiagCtxt, res: Result<(), String>) -> MainResult {
match res {
Ok(()) => dcx.has_errors().map_or(Ok(()), Err),
- Err(err) => {
- let reported = dcx.struct_err(err).emit();
- Err(reported)
- }
+ Err(err) => Err(dcx.err(err)),
}
}
diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
index 176494a3863..b843227d187 100644
--- a/src/librustdoc/passes/collect_intra_doc_links.rs
+++ b/src/librustdoc/passes/collect_intra_doc_links.rs
@@ -1228,7 +1228,7 @@ impl LinkCollector<'_, '_> {
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();
}
diff --git a/src/librustdoc/theme.rs b/src/librustdoc/theme.rs
index 98010b056c9..31d32e23f8e 100644
--- a/src/librustdoc/theme.rs
+++ b/src/librustdoc/theme.rs
@@ -244,7 +244,7 @@ pub(crate) fn test_theme_against<P: AsRef<Path>>(
{
Ok(c) => c,
Err(e) => {
- dcx.struct_err(e).emit();
+ dcx.err(e);
return (false, vec![]);
}
};
diff --git a/src/tools/clippy/clippy_config/src/msrvs.rs b/src/tools/clippy/clippy_config/src/msrvs.rs
index 76f3663f04f..dae9f09ec00 100644
--- a/src/tools/clippy/clippy_config/src/msrvs.rs
+++ b/src/tools/clippy/clippy_config/src/msrvs.rs
@@ -109,7 +109,7 @@ impl Msrv {
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();
}
diff --git a/src/tools/clippy/clippy_utils/src/attrs.rs b/src/tools/clippy/clippy_utils/src/attrs.rs
index 19d38903ade..ad8619f0d3d 100644
--- a/src/tools/clippy/clippy_utils/src/attrs.rs
+++ b/src/tools/clippy/clippy_utils/src/attrs.rs
@@ -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);
diff --git a/src/tools/miri/src/diagnostics.rs b/src/tools/miri/src/diagnostics.rs
index d3d4490f302..819d2018a15 100644
--- a/src/tools/miri/src/diagnostics.rs
+++ b/src/tools/miri/src/diagnostics.rs
@@ -499,14 +499,12 @@ pub fn report_msg<'tcx>(
err.note(if extra_span { "BACKTRACE (of the first span):" } else { "BACKTRACE:" });
}
- let (mut err, handler) = err.into_diagnostic().unwrap();
-
// Add backtrace
for (idx, frame_info) in stacktrace.iter().enumerate() {
let is_local = machine.is_local(frame_info);
// No span for non-local frames and the first frame (which is the error site).
if is_local && idx > 0 {
- err.eager_subdiagnostic(handler, frame_info.as_note(machine.tcx));
+ err.eager_subdiagnostic(err.dcx, frame_info.as_note(machine.tcx));
} else {
let sm = sess.source_map();
let span = sm.span_to_embeddable_string(frame_info.span);
@@ -514,7 +512,7 @@ pub fn report_msg<'tcx>(
}
}
- handler.emit_diagnostic(err);
+ err.emit();
}
impl<'mir, 'tcx> MiriMachine<'mir, 'tcx> {