nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-02-16 17:03:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #119146 - nnethercote:rm-DiagCtxt-api-duplication, r=compiler-errors

Browse Source 
Remove `DiagCtxt` API duplication

`DiagCtxt` defines the internal API for creating and emitting diagnostics: methods like `struct_err`, `struct_span_warn`, `note`, `create_fatal`, `emit_bug`. There are over 50 methods.

Some of these methods are then duplicated across several other types: `Session`, `ParseSess`, `Parser`, `ExtCtxt`, and `MirBorrowckCtxt`. `Session` duplicates the most, though half the ones it does are unused. Each duplicated method just calls forward to the corresponding method in `DiagCtxt`. So this duplication exists to (in the best case) shorten chains like `ecx.tcx.sess.parse_sess.dcx.emit_err()` to `ecx.emit_err()`.

This API duplication is ugly and has been bugging me for a while. And it's inconsistent: there's no real logic about which methods are duplicated, and the use of `#[rustc_lint_diagnostic]` and `#[track_caller]` attributes vary across the duplicates.

This PR removes the duplicated API methods and makes all diagnostic creation and emission go through `DiagCtxt`. It also adds `dcx` getter methods to several types to shorten chains. This approach scales *much* better than API duplication; indeed, the PR adds `dcx()` to numerous types that didn't have API duplication: `TyCtxt`, `LoweringCtxt`, `ConstCx`, `FnCtxt`, `TypeErrCtxt`, `InferCtxt`, `CrateLoader`, `CheckAttrVisitor`, and `Resolver`. These result in a lot of changes from `foo.tcx.sess.emit_err()` to `foo.dcx().emit_err()`. (You could do this with more types, but it gets into diminishing returns territory for types that don't emit many diagnostics.)

After all these changes, some call sites are more verbose, some are less verbose, and many are the same. The total number of lines is reduced, mostly because of the removed API duplication. And consistency is increased, because calls to `emit_err` and friends are always preceded with `.dcx()` or `.dcx`.

r? `@compiler-errors`
This commit is contained in:
bors 2023-12-26 02:24:39 +00:00
commit 2271c26e4a
347 changed files with 2334 additions and 2696 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
compiler/rustc_ast_lowering/src/asm.rs
View File

@ -32,7 +32,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
let asm_arch =
if self.tcx.sess.opts.actually_rustdoc { None } else { self.tcx.sess.asm_arch };
if asm_arch.is_none() && !self.tcx.sess.opts.actually_rustdoc {
self.tcx.sess.emit_err(InlineAsmUnsupportedTarget { span: sp });
self.dcx().emit_err(InlineAsmUnsupportedTarget { span: sp });
}
if let Some(asm_arch) = asm_arch {
// Inline assembly is currently only stable for these architectures.
@ -60,7 +60,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
&& !matches!(asm_arch, Some(asm::InlineAsmArch::X86 | asm::InlineAsmArch::X86_64))
&& !self.tcx.sess.opts.actually_rustdoc
{
self.tcx.sess.emit_err(AttSyntaxOnlyX86 { span: sp });
self.dcx().emit_err(AttSyntaxOnlyX86 { span: sp });
}
if asm.options.contains(InlineAsmOptions::MAY_UNWIND) && !self.tcx.features().asm_unwind {
feature_err(
@ -87,7 +87,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
!= source_map.span_to_snippet(*abi_span))
.then_some(());
self.tcx.sess.emit_err(AbiSpecifiedMultipleTimes {
self.dcx().emit_err(AbiSpecifiedMultipleTimes {
abi_span: *abi_span,
prev_name: *prev_name,
prev_span: *prev_sp,
@ -100,14 +100,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
}
}
Err(&[]) => {
self.tcx.sess.emit_err(ClobberAbiNotSupported { abi_span: *abi_span });
self.dcx().emit_err(ClobberAbiNotSupported { abi_span: *abi_span });
}
Err(supported_abis) => {
let mut abis = format!("`{}`", supported_abis[0]);
for m in &supported_abis[1..] {
let _ = write!(abis, ", `{m}`");
}
self.tcx.sess.emit_err(InvalidAbiClobberAbi {
self.dcx().emit_err(InvalidAbiClobberAbi {
abi_span: *abi_span,
supported_abis: abis,
});
@ -128,7 +128,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
InlineAsmRegOrRegClass::Reg(reg) => {
asm::InlineAsmRegOrRegClass::Reg(if let Some(asm_arch) = asm_arch {
asm::InlineAsmReg::parse(asm_arch, reg).unwrap_or_else(|error| {
sess.emit_err(InvalidRegister { op_span: *op_sp, reg, error });
self.dcx().emit_err(InvalidRegister {
op_span: *op_sp,
reg,
error,
});
asm::InlineAsmReg::Err
})
} else {
@ -139,7 +143,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
asm::InlineAsmRegOrRegClass::RegClass(if let Some(asm_arch) = asm_arch {
asm::InlineAsmRegClass::parse(asm_arch, reg_class).unwrap_or_else(
|error| {
sess.emit_err(InvalidRegisterClass {
self.dcx().emit_err(InvalidRegisterClass {
op_span: *op_sp,
reg_class,
error,
@ -276,7 +280,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
class_name: class.name(),
}
};
sess.emit_err(InvalidAsmTemplateModifierRegClass {
self.dcx().emit_err(InvalidAsmTemplateModifierRegClass {
placeholder_span,
op_span: op_sp,
sub,
@ -284,14 +288,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
}
}
hir::InlineAsmOperand::Const { .. } => {
sess.emit_err(InvalidAsmTemplateModifierConst {
self.dcx().emit_err(InvalidAsmTemplateModifierConst {
placeholder_span,
op_span: op_sp,
});
}
hir::InlineAsmOperand::SymFn { .. }
| hir::InlineAsmOperand::SymStatic { .. } => {
sess.emit_err(InvalidAsmTemplateModifierSym {
self.dcx().emit_err(InvalidAsmTemplateModifierSym {
placeholder_span,
op_span: op_sp,
});
@ -315,7 +319,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
// require that the operand name an explicit register, not a
// register class.
if reg_class.is_clobber_only(asm_arch.unwrap()) && !op.is_clobber() {
sess.emit_err(RegisterClassOnlyClobber {
self.dcx().emit_err(RegisterClassOnlyClobber {
op_span: op_sp,
reg_class_name: reg_class.name(),
});
@ -384,7 +388,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
}
};
sess.emit_err(RegisterConflict {
self.dcx().emit_err(RegisterConflict {
op_span1: op_sp,
op_span2: op_sp2,
reg1_name: reg_str(idx),

33
compiler/rustc_ast_lowering/src/expr.rs
View File

@ -249,7 +249,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
self.lower_expr_range(e.span, e1.as_deref(), e2.as_deref(), *lims)
}
ExprKind::Underscore => {
let guar = self.tcx.sess.emit_err(UnderscoreExprLhsAssign { span: e.span });
let guar = self.dcx().emit_err(UnderscoreExprLhsAssign { span: e.span });
hir::ExprKind::Err(guar)
}
ExprKind::Path(qself, path) => {
@ -294,8 +294,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
let rest = match &se.rest {
StructRest::Base(e) => Some(self.lower_expr(e)),
StructRest::Rest(sp) => {
let guar =
self.tcx.sess.emit_err(BaseExpressionDoubleDot { span: *sp });
let guar = self.dcx().emit_err(BaseExpressionDoubleDot { span: *sp });
Some(&*self.arena.alloc(self.expr_err(*sp, guar)))
}
StructRest::None => None,
@ -332,9 +331,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
|this| this.with_new_scopes(e.span, |this| this.lower_block_expr(block)),
),
ExprKind::Yield(opt_expr) => self.lower_expr_yield(e.span, opt_expr.as_deref()),
ExprKind::Err => hir::ExprKind::Err(
self.tcx.sess.span_delayed_bug(e.span, "lowered ExprKind::Err"),
),
ExprKind::Err => {
hir::ExprKind::Err(self.dcx().span_delayed_bug(e.span, "lowered ExprKind::Err"))
}
ExprKind::Try(sub_expr) => self.lower_expr_try(e.span, sub_expr),
ExprKind::Paren(_) | ExprKind::ForLoop { .. } => {
@ -584,13 +583,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
if self.tcx.features().never_patterns {
// If the feature is off we already emitted the error after parsing.
let suggestion = span.shrink_to_hi();
self.tcx.sess.emit_err(MatchArmWithNoBody { span, suggestion });
self.dcx().emit_err(MatchArmWithNoBody { span, suggestion });
}
} else if let Some(body) = &arm.body {
self.tcx.sess.emit_err(NeverPatternWithBody { span: body.span });
self.dcx().emit_err(NeverPatternWithBody { span: body.span });
guard = None;
} else if let Some(g) = &arm.guard {
self.tcx.sess.emit_err(NeverPatternWithGuard { span: g.span });
self.dcx().emit_err(NeverPatternWithGuard { span: g.span });
guard = None;
}
@ -902,7 +901,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
Some(hir::CoroutineKind::Coroutine)
| Some(hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::Gen, _))
| None => {
return hir::ExprKind::Err(self.tcx.sess.emit_err(AwaitOnlyInAsyncFnAndBlocks {
return hir::ExprKind::Err(self.dcx().emit_err(AwaitOnlyInAsyncFnAndBlocks {
await_kw_span,
item_span: self.current_item,
}));
@ -1129,7 +1128,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
match coroutine_kind {
Some(hir::CoroutineKind::Coroutine) => {
if decl.inputs.len() > 1 {
self.tcx.sess.emit_err(CoroutineTooManyParameters { fn_decl_span });
self.dcx().emit_err(CoroutineTooManyParameters { fn_decl_span });
}
Some(movability)
}
@ -1142,7 +1141,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
}
None => {
if movability == Movability::Static {
self.tcx.sess.emit_err(ClosureCannotBeStatic { fn_decl_span });
self.dcx().emit_err(ClosureCannotBeStatic { fn_decl_span });
}
None
}
@ -1181,7 +1180,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
};
if let &ClosureBinder::For { span, .. } = binder {
self.tcx.sess.emit_err(NotSupportedForLifetimeBinderAsyncClosure { span });
self.dcx().emit_err(NotSupportedForLifetimeBinderAsyncClosure { span });
}
let (binder_clause, generic_params) = self.lower_closure_binder(binder);
@ -1192,7 +1191,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
let body = self.with_new_scopes(fn_decl_span, |this| {
// FIXME(cramertj): allow `async` non-`move` closures with arguments.
if capture_clause == CaptureBy::Ref && !decl.inputs.is_empty() {
this.tcx.sess.emit_err(AsyncNonMoveClosureNotSupported { fn_decl_span });
this.dcx().emit_err(AsyncNonMoveClosureNotSupported { fn_decl_span });
}
// Transform `async |x: u8| -> X { ... }` into
@ -1448,7 +1447,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
);
let fields_omitted = match &se.rest {
StructRest::Base(e) => {
self.tcx.sess.emit_err(FunctionalRecordUpdateDestructuringAssignment {
self.dcx().emit_err(FunctionalRecordUpdateDestructuringAssignment {
span: e.span,
});
true
@ -1544,7 +1543,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
(None, Some(..), Closed) => hir::LangItem::RangeToInclusive,
(Some(..), Some(..), Closed) => unreachable!(),
(start, None, Closed) => {
self.tcx.sess.emit_err(InclusiveRangeWithNoEnd { span });
self.dcx().emit_err(InclusiveRangeWithNoEnd { span });
match start {
Some(..) => hir::LangItem::RangeFrom,
None => hir::LangItem::RangeFull,
@ -1653,7 +1652,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
Some(hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::AsyncGen, _)) => true,
Some(hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::Async, _)) => {
return hir::ExprKind::Err(
self.tcx.sess.emit_err(AsyncCoroutinesNotSupported { span }),
self.dcx().emit_err(AsyncCoroutinesNotSupported { span }),
);
}
Some(hir::CoroutineKind::Coroutine) | None => {

4
compiler/rustc_ast_lowering/src/format.rs
View File

@ -267,7 +267,7 @@ fn make_count<'hir>(
ctx.expr(
sp,
hir::ExprKind::Err(
ctx.tcx.sess.span_delayed_bug(sp, "lowered bad format_args count"),
ctx.dcx().span_delayed_bug(sp, "lowered bad format_args count"),
),
)
}
@ -306,7 +306,7 @@ fn make_format_spec<'hir>(
}
Err(_) => ctx.expr(
sp,
hir::ExprKind::Err(ctx.tcx.sess.span_delayed_bug(sp, "lowered bad format_args count")),
hir::ExprKind::Err(ctx.dcx().span_delayed_bug(sp, "lowered bad format_args count")),
),
};
let &FormatOptions {

12
compiler/rustc_ast_lowering/src/item.rs
View File

@ -265,7 +265,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
&ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
|this| match ty {
None => {
let guar = this.tcx.sess.span_delayed_bug(
let guar = this.dcx().span_delayed_bug(
span,
"expected to lower type alias type, but it was missing",
);
@ -879,7 +879,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
&ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
|this| match ty {
None => {
let guar = this.tcx.sess.span_delayed_bug(
let guar = this.dcx().span_delayed_bug(
i.span,
"expected to lower associated type, but it was missing",
);
@ -1012,7 +1012,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
fn lower_block_expr_opt(&mut self, span: Span, block: Option<&Block>) -> hir::Expr<'hir> {
match block {
Some(block) => self.lower_block_expr(block),
None => self.expr_err(span, self.tcx.sess.span_delayed_bug(span, "no block")),
None => self.expr_err(span, self.dcx().span_delayed_bug(span, "no block")),
}
}
@ -1022,7 +1022,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
&[],
match expr {
Some(expr) => this.lower_expr_mut(expr),
None => this.expr_err(span, this.tcx.sess.span_delayed_bug(span, "no block")),
None => this.expr_err(span, this.dcx().span_delayed_bug(span, "no block")),
},
)
})
@ -1296,7 +1296,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
.map(|s| Symbol::intern(s))
.collect::<Vec<_>>();
let suggested_name = find_best_match_for_name(&abi_names, abi.symbol_unescaped, None);
self.tcx.sess.emit_err(InvalidAbi {
self.dcx().emit_err(InvalidAbi {
abi: abi.symbol_unescaped,
span: abi.span,
explain: match err {
@ -1383,7 +1383,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
}
let is_param = *is_param.get_or_insert_with(compute_is_param);
if !is_param {
self.tcx.sess.emit_err(MisplacedRelaxTraitBound { span: bound.span() });
self.dcx().emit_err(MisplacedRelaxTraitBound { span: bound.span() });
}
}
}

37
compiler/rustc_ast_lowering/src/lib.rs
View File

@ -53,7 +53,7 @@ use rustc_data_structures::fingerprint::Fingerprint;
use rustc_data_structures::sorted_map::SortedMap;
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
use rustc_data_structures::sync::Lrc;
use rustc_errors::{DiagnosticArgFromDisplay, StashKey};
use rustc_errors::{DiagCtxt, DiagnosticArgFromDisplay, StashKey};
use rustc_hir as hir;
use rustc_hir::def::{DefKind, LifetimeRes, Namespace, PartialRes, PerNS, Res};
use rustc_hir::def_id::{LocalDefId, LocalDefIdMap, CRATE_DEF_ID, LOCAL_CRATE};
@ -183,6 +183,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
host_param_id: None,
}
}
pub(crate) fn dcx(&self) -> &'hir DiagCtxt {
self.tcx.dcx()
}
}
trait ResolverAstLoweringExt {
@ -1035,11 +1039,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
&& first_char.is_ascii_lowercase()
{
let mut err = if !data.inputs.is_empty() {
self.tcx.sess.create_err(errors::BadReturnTypeNotation::Inputs {
self.dcx().create_err(errors::BadReturnTypeNotation::Inputs {
span: data.inputs_span,
})
} else if let FnRetTy::Ty(ty) = &data.output {
self.tcx.sess.create_err(errors::BadReturnTypeNotation::Output {
self.dcx().create_err(errors::BadReturnTypeNotation::Output {
span: data.inputs_span.shrink_to_hi().to(ty.span),
})
} else {
@ -1163,7 +1167,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
hir::TypeBindingKind::Constraint { bounds }
}
DesugarKind::Error(position) => {
let guar = self.tcx.sess.emit_err(errors::MisplacedAssocTyBinding {
let guar = self.dcx().emit_err(errors::MisplacedAssocTyBinding {
span: constraint.span,
position: DiagnosticArgFromDisplay(position),
});
@ -1205,7 +1209,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
data.inputs.last().unwrap().span.shrink_to_hi().to(data.inputs_span.shrink_to_hi());
AssocTyParenthesesSub::NotEmpty { open_param, close_param }
};
self.tcx.sess.emit_err(AssocTyParentheses { span: data.span, sub });
self.dcx().emit_err(AssocTyParentheses { span: data.span, sub });
}
#[instrument(level = "debug", skip(self))]
@ -1347,20 +1351,20 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
let kind = match &t.kind {
TyKind::Infer => hir::TyKind::Infer,
TyKind::Err => {
hir::TyKind::Err(self.tcx.sess.span_delayed_bug(t.span, "TyKind::Err lowered"))
hir::TyKind::Err(self.dcx().span_delayed_bug(t.span, "TyKind::Err lowered"))
}
// FIXME(unnamed_fields): IMPLEMENTATION IN PROGRESS
#[allow(rustc::untranslatable_diagnostic)]
#[allow(rustc::diagnostic_outside_of_impl)]
TyKind::AnonStruct(ref _fields) => hir::TyKind::Err(
self.tcx.sess.span_err(t.span, "anonymous structs are unimplemented"),
),
TyKind::AnonStruct(ref _fields) => {
hir::TyKind::Err(self.dcx().span_err(t.span, "anonymous structs are unimplemented"))
}
// FIXME(unnamed_fields): IMPLEMENTATION IN PROGRESS
#[allow(rustc::untranslatable_diagnostic)]
#[allow(rustc::diagnostic_outside_of_impl)]
TyKind::AnonUnion(ref _fields) => hir::TyKind::Err(
self.tcx.sess.span_err(t.span, "anonymous unions are unimplemented"),
),
TyKind::AnonUnion(ref _fields) => {
hir::TyKind::Err(self.dcx().span_err(t.span, "anonymous unions are unimplemented"))
}
TyKind::Slice(ty) => hir::TyKind::Slice(self.lower_ty(ty, itctx)),
TyKind::Ptr(mt) => hir::TyKind::Ptr(self.lower_mt(mt, itctx)),
TyKind::Ref(region, mt) => {
@ -1518,7 +1522,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
hir::TyKind::Err(guar)
}
ImplTraitContext::Disallowed(position) => {
let guar = self.tcx.sess.emit_err(MisplacedImplTrait {
let guar = self.dcx().emit_err(MisplacedImplTrait {
span: t.span,
position: DiagnosticArgFromDisplay(position),
});
@ -1528,7 +1532,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
}
TyKind::MacCall(_) => panic!("`TyKind::MacCall` should have been expanded by now"),
TyKind::CVarArgs => {
let guar = self.tcx.sess.span_delayed_bug(
let guar = self.dcx().span_delayed_bug(
t.span,
"`TyKind::CVarArgs` should have been handled elsewhere",
);
@ -1672,8 +1676,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
if let Some(old_def_id) = self.orig_opt_local_def_id(param) {
old_def_id
} else {
self.tcx
.sess
self.dcx()
.span_delayed_bug(lifetime.ident.span, "no def-id for fresh lifetime");
continue;
}
@ -2569,7 +2572,7 @@ impl<'hir> GenericArgsCtor<'hir> {
let hir_id = lcx.next_id();
let Some(host_param_id) = lcx.host_param_id else {
lcx.tcx.sess.span_delayed_bug(
lcx.dcx().span_delayed_bug(
span,
"no host param id for call in const yet no errors reported",
);

8
compiler/rustc_ast_lowering/src/pat.rs
View File

@ -140,7 +140,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
// This is not allowed as a sub-tuple pattern
PatKind::Ident(_, ident, Some(sub)) if sub.is_rest() => {
let sp = pat.span;
self.tcx.sess.emit_err(SubTupleBinding {
self.dcx().emit_err(SubTupleBinding {
span: sp,
ident_name: ident.name,
ident: *ident,
@ -289,12 +289,12 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
/// Emit a friendly error for extra `..` patterns in a tuple/tuple struct/slice pattern.
pub(crate) fn ban_extra_rest_pat(&self, sp: Span, prev_sp: Span, ctx: &str) {
self.tcx.sess.emit_err(ExtraDoubleDot { span: sp, prev_span: prev_sp, ctx });
self.dcx().emit_err(ExtraDoubleDot { span: sp, prev_span: prev_sp, ctx });
}
/// Used to ban the `..` pattern in places it shouldn't be semantically.
fn ban_illegal_rest_pat(&self, sp: Span) -> hir::PatKind<'hir> {
self.tcx.sess.emit_err(MisplacedDoubleDot { span: sp });
self.dcx().emit_err(MisplacedDoubleDot { span: sp });
// We're not in a list context so `..` can be reasonably treated
// as `_` because it should always be valid and roughly matches the
@ -334,7 +334,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
ExprKind::Path(..) if allow_paths => {}
ExprKind::Unary(UnOp::Neg, inner) if matches!(inner.kind, ExprKind::Lit(_)) => {}
_ => {
let guar = self.tcx.sess.emit_err(ArbitraryExpressionInPattern { span: expr.span });
let guar = self.dcx().emit_err(ArbitraryExpressionInPattern { span: expr.span });
return self.arena.alloc(self.expr_err(expr.span, guar));
}
}

4
compiler/rustc_ast_lowering/src/path.rs
View File

@ -140,7 +140,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
// We should've returned in the for loop above.
self.tcx.sess.dcx().span_bug(
self.dcx().span_bug(
p.span,
format!(
"lower_qpath: no final extension segment in {}..{}",
@ -214,7 +214,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
} else {
None
};
self.tcx.sess.emit_err(GenericTypeWithParentheses { span: data.span, sub });
self.dcx().emit_err(GenericTypeWithParentheses { span: data.span, sub });
(
self.lower_angle_bracketed_parameter_data(
&data.as_angle_bracketed_args(),

56
compiler/rustc_ast_passes/src/ast_validation.rs
View File

@ -228,13 +228,13 @@ impl<'a> AstValidator<'a> {
fn check_lifetime(&self, ident: Ident) {
let valid_names = [kw::UnderscoreLifetime, kw::StaticLifetime, kw::Empty];
if !valid_names.contains(&ident.name) && ident.without_first_quote().is_reserved() {
self.session.emit_err(errors::KeywordLifetime { span: ident.span });
self.dcx().emit_err(errors::KeywordLifetime { span: ident.span });
}
}
fn check_label(&self, ident: Ident) {
if ident.without_first_quote().is_reserved() {
self.session.emit_err(errors::InvalidLabel { span: ident.span, name: ident.name });
self.dcx().emit_err(errors::InvalidLabel { span: ident.span, name: ident.name });
}
}
@ -243,7 +243,7 @@ impl<'a> AstValidator<'a> {
return;
}
self.session.emit_err(errors::VisibilityNotPermitted { span: vis.span, note });
self.dcx().emit_err(errors::VisibilityNotPermitted { span: vis.span, note });
}
fn check_decl_no_pat(decl: &FnDecl, mut report_err: impl FnMut(Span, Option<Ident>, bool)) {
@ -293,7 +293,7 @@ impl<'a> AstValidator<'a> {
fn check_trait_fn_not_const(&self, constness: Const) {
if let Const::Yes(span) = constness {
self.session.emit_err(errors::TraitFnConst { span });
self.dcx().emit_err(errors::TraitFnConst { span });
}
}
@ -310,7 +310,7 @@ impl<'a> AstValidator<'a> {
let max_num_args: usize = u16::MAX.into();
if fn_decl.inputs.len() > max_num_args {
let Param { span, .. } = fn_decl.inputs[0];
self.session.emit_fatal(errors::FnParamTooMany { span, max_num_args });
self.dcx().emit_fatal(errors::FnParamTooMany { span, max_num_args });
}
}
@ -318,13 +318,13 @@ impl<'a> AstValidator<'a> {
match &*fn_decl.inputs {
[Param { ty, span, .. }] => {
if let TyKind::CVarArgs = ty.kind {
self.session.emit_err(errors::FnParamCVarArgsOnly { span: *span });
self.dcx().emit_err(errors::FnParamCVarArgsOnly { span: *span });
}
}
[ps @ .., _] => {
for Param { ty, span, .. } in ps {
if let TyKind::CVarArgs = ty.kind {
self.session.emit_err(errors::FnParamCVarArgsNotLast { span: *span });
self.dcx().emit_err(errors::FnParamCVarArgsNotLast { span: *span });
}
}
}
@ -351,9 +351,9 @@ impl<'a> AstValidator<'a> {
})
.for_each(|attr| {
if attr.is_doc_comment() {
self.session.emit_err(errors::FnParamDocComment { span: attr.span });
self.dcx().emit_err(errors::FnParamDocComment { span: attr.span });
} else {
self.session.emit_err(errors::FnParamForbiddenAttr { span: attr.span });
self.dcx().emit_err(errors::FnParamForbiddenAttr { span: attr.span });
}
});
}
@ -361,7 +361,7 @@ impl<'a> AstValidator<'a> {
fn check_decl_self_param(&self, fn_decl: &FnDecl, self_semantic: SelfSemantic) {
if let (SelfSemantic::No, [param, ..]) = (self_semantic, &*fn_decl.inputs) {
if param.is_self() {
self.session.emit_err(errors::FnParamForbiddenSelf { span: param.span });
self.dcx().emit_err(errors::FnParamForbiddenSelf { span: param.span });
}
}
}
@ -369,7 +369,7 @@ impl<'a> AstValidator<'a> {
fn check_defaultness(&self, span: Span, defaultness: Defaultness) {
if let Defaultness::Default(def_span) = defaultness {
let span = self.session.source_map().guess_head_span(span);
self.session.emit_err(errors::ForbiddenDefault { span, def_span });
self.dcx().emit_err(errors::ForbiddenDefault { span, def_span });
}
}
@ -532,24 +532,24 @@ impl<'a> AstValidator<'a> {
return;
}
let span = self.session.source_map().guess_head_span(item_span);
self.session.emit_err(errors::NoMangleAscii { span });
self.dcx().emit_err(errors::NoMangleAscii { span });
}
fn check_mod_file_item_asciionly(&self, ident: Ident) {
if ident.name.as_str().is_ascii() {
return;
}
self.session.emit_err(errors::ModuleNonAscii { span: ident.span, name: ident.name });
self.dcx().emit_err(errors::ModuleNonAscii { span: ident.span, name: ident.name });
}
fn deny_generic_params(&self, generics: &Generics, ident: Span) {
if !generics.params.is_empty() {
self.session.emit_err(errors::AutoTraitGeneric { span: generics.span, ident });
self.dcx().emit_err(errors::AutoTraitGeneric { span: generics.span, ident });
}
}
fn emit_e0568(&self, span: Span, ident: Span) {
self.session.emit_err(errors::AutoTraitBounds { span, ident });
self.dcx().emit_err(errors::AutoTraitBounds { span, ident });
}
fn deny_super_traits(&self, bounds: &GenericBounds, ident_span: Span) {
@ -569,7 +569,7 @@ impl<'a> AstValidator<'a> {
if !trait_items.is_empty() {
let spans: Vec<_> = trait_items.iter().map(|i| i.ident.span).collect();
let total = trait_items.first().unwrap().span.to(trait_items.last().unwrap().span);
self.session.emit_err(errors::AutoTraitItems { spans, total, ident });
self.dcx().emit_err(errors::AutoTraitItems { spans, total, ident });
}
}
@ -633,7 +633,7 @@ impl<'a> AstValidator<'a> {
TyKind::BareFn(bfty) => {
self.check_fn_decl(&bfty.decl, SelfSemantic::No);
Self::check_decl_no_pat(&bfty.decl, |span, _, _| {
self.session.emit_err(errors::PatternFnPointer { span });
self.dcx().emit_err(errors::PatternFnPointer { span });
});
if let Extern::Implicit(_) = bfty.ext {
let sig_span = self.session.source_map().next_point(ty.span.shrink_to_lo());
@ -645,7 +645,7 @@ impl<'a> AstValidator<'a> {
for bound in bounds {
if let GenericBound::Outlives(lifetime) = bound {
if any_lifetime_bounds {
self.session
self.dcx()
.emit_err(errors::TraitObjectBound { span: lifetime.ident.span });
break;
}
@ -655,11 +655,11 @@ impl<'a> AstValidator<'a> {
}
TyKind::ImplTrait(_, bounds) => {
if self.is_impl_trait_banned {
self.session.emit_err(errors::ImplTraitPath { span: ty.span });
self.dcx().emit_err(errors::ImplTraitPath { span: ty.span });
}
if let Some(outer_impl_trait_sp) = self.outer_impl_trait {
self.session.emit_err(errors::NestedImplTrait {
self.dcx().emit_err(errors::NestedImplTrait {
span: ty.span,
outer: outer_impl_trait_sp,
inner: ty.span,
@ -827,7 +827,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
}
if let (&Unsafe::Yes(span), &ImplPolarity::Negative(sp)) = (unsafety, polarity)
{
this.session.emit_err(errors::UnsafeNegativeImpl {
this.dcx().emit_err(errors::UnsafeNegativeImpl {
span: sp.to(t.path.span),
negative: sp,
r#unsafe: span,
@ -902,7 +902,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
self.check_defaultness(item.span, *defaultness);
if body.is_none() {
self.session.emit_err(errors::FnWithoutBody {
self.dcx().emit_err(errors::FnWithoutBody {
span: item.span,
replace_span: self.ending_semi_or_hi(item.span),
extern_block_suggestion: match sig.header.ext {
@ -1031,14 +1031,14 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
ItemKind::Const(box ConstItem { defaultness, expr, .. }) => {
self.check_defaultness(item.span, *defaultness);
if expr.is_none() {
self.session.emit_err(errors::ConstWithoutBody {
self.dcx().emit_err(errors::ConstWithoutBody {
span: item.span,
replace_span: self.ending_semi_or_hi(item.span),
});
}
}
ItemKind::Static(box StaticItem { expr: None, .. }) => {
self.session.emit_err(errors::StaticWithoutBody {
self.dcx().emit_err(errors::StaticWithoutBody {
span: item.span,
replace_span: self.ending_semi_or_hi(item.span),
});
@ -1048,7 +1048,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
) => {
self.check_defaultness(item.span, *defaultness);
if ty.is_none() {
self.session.emit_err(errors::TyAliasWithoutBody {
self.dcx().emit_err(errors::TyAliasWithoutBody {
span: item.span,
replace_span: self.ending_semi_or_hi(item.span),
});
@ -1357,14 +1357,14 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
if ctxt == AssocCtxt::Impl {
match &item.kind {
AssocItemKind::Const(box ConstItem { expr: None, .. }) => {
self.session.emit_err(errors::AssocConstWithoutBody {
self.dcx().emit_err(errors::AssocConstWithoutBody {
span: item.span,
replace_span: self.ending_semi_or_hi(item.span),
});
}
AssocItemKind::Fn(box Fn { body, .. }) => {
if body.is_none() {
self.session.emit_err(errors::AssocFnWithoutBody {
self.dcx().emit_err(errors::AssocFnWithoutBody {
span: item.span,
replace_span: self.ending_semi_or_hi(item.span),
});
@ -1372,7 +1372,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
}
AssocItemKind::Type(box TyAlias { bounds, ty, .. }) => {
if ty.is_none() {
self.session.emit_err(errors::AssocTypeWithoutBody {
self.dcx().emit_err(errors::AssocTypeWithoutBody {
span: item.span,
replace_span: self.ending_semi_or_hi(item.span),
});

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

@ -168,7 +168,7 @@ impl<'a> PostExpansionVisitor<'a> {
for param in params {
if !param.bounds.is_empty() {
let spans: Vec<_> = param.bounds.iter().map(|b| b.span()).collect();
self.sess.emit_err(errors::ForbiddenBound { spans });
self.sess.dcx().emit_err(errors::ForbiddenBound { spans });
}
}
}
@ -226,7 +226,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
|| attr.has_name(sym::rustc_const_stable)
|| attr.has_name(sym::rustc_default_body_unstable)
{
self.sess.emit_err(errors::StabilityOutsideStd { span: attr.span });
self.sess.dcx().emit_err(errors::StabilityOutsideStd { span: attr.span });
}
}
}
@ -579,7 +579,7 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
.emit();
} else {
let suggestion = span.shrink_to_hi();
sess.emit_err(errors::MatchArmWithNoBody { span, suggestion });
sess.dcx().emit_err(errors::MatchArmWithNoBody { span, suggestion });
}
}
}
@ -587,7 +587,7 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
if !visitor.features.negative_bounds {
for &span in spans.get(&sym::negative_bounds).iter().copied().flatten() {
sess.emit_err(errors::NegativeBoundUnsupported { span });
sess.dcx().emit_err(errors::NegativeBoundUnsupported { span });
}
}
@ -677,7 +677,11 @@ fn check_incompatible_features(sess: &Session, features: &Features) {
if let Some((f2_name, f2_span)) = declared_features.clone().find(|(name, _)| name == f2)
{
let spans = vec![f1_span, f2_span];
sess.emit_err(errors::IncompatibleFeatures { spans, f1: f1_name, f2: f2_name });
sess.dcx().emit_err(errors::IncompatibleFeatures {
spans,
f1: f1_name,
f2: f2_name,
});
}
}
}

133
compiler/rustc_attr/src/builtin.rs
View File

@ -207,7 +207,8 @@ pub fn find_stability(
sym::rustc_allowed_through_unstable_modules => allowed_through_unstable_modules = true,
sym::unstable => {
if stab.is_some() {
sess.emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span });
sess.dcx()
.emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span });
break;
}
@ -217,7 +218,8 @@ pub fn find_stability(
}
sym::stable => {
if stab.is_some() {
sess.emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span });
sess.dcx()
.emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span });
break;
}
if let Some((feature, level)) = parse_stability(sess, attr) {
@ -238,7 +240,8 @@ pub fn find_stability(
_,
)) => *allowed_through_unstable_modules = true,
_ => {
sess.emit_err(session_diagnostics::RustcAllowedUnstablePairing { span: item_sp });
sess.dcx()
.emit_err(session_diagnostics::RustcAllowedUnstablePairing { span: item_sp });
}
}
}
@ -261,7 +264,8 @@ pub fn find_const_stability(
sym::rustc_promotable => promotable = true,
sym::rustc_const_unstable => {
if const_stab.is_some() {
sess.emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span });
sess.dcx()
.emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span });
break;
}
@ -272,7 +276,8 @@ pub fn find_const_stability(
}
sym::rustc_const_stable => {
if const_stab.is_some() {
sess.emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span });
sess.dcx()
.emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span });
break;
}
if let Some((feature, level)) = parse_stability(sess, attr) {
@ -288,7 +293,11 @@ pub fn find_const_stability(
if promotable {
match &mut const_stab {
Some((stab, _)) => stab.promotable = promotable,
_ => _ = sess.emit_err(session_diagnostics::RustcPromotablePairing { span: item_sp }),
_ => {
_ = sess
.dcx()
.emit_err(session_diagnostics::RustcPromotablePairing { span: item_sp })
}
}
}
@ -306,7 +315,8 @@ pub fn find_body_stability(
for attr in attrs {
if attr.has_name(sym::rustc_default_body_unstable) {
if body_stab.is_some() {
sess.emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span });
sess.dcx()
.emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span });
break;
}
@ -321,7 +331,7 @@ pub fn find_body_stability(
fn insert_or_error(sess: &Session, meta: &MetaItem, item: &mut Option<Symbol>) -> Option<()> {
if item.is_some() {
sess.emit_err(session_diagnostics::MultipleItem {
sess.dcx().emit_err(session_diagnostics::MultipleItem {
span: meta.span,
item: pprust::path_to_string(&meta.path),
});
@ -330,7 +340,7 @@ fn insert_or_error(sess: &Session, meta: &MetaItem, item: &mut Option<Symbol>) -
*item = Some(v);
Some(())
} else {
sess.emit_err(session_diagnostics::IncorrectMetaItem { span: meta.span });
sess.dcx().emit_err(session_diagnostics::IncorrectMetaItem { span: meta.span });
None
}
}
@ -345,7 +355,7 @@ fn parse_stability(sess: &Session, attr: &Attribute) -> Option<(Symbol, Stabilit
let mut since = None;
for meta in metas {
let Some(mi) = meta.meta_item() else {
sess.emit_err(session_diagnostics::UnsupportedLiteral {
sess.dcx().emit_err(session_diagnostics::UnsupportedLiteral {
span: meta.span(),
reason: UnsupportedLiteralReason::Generic,
is_bytestr: false,
@ -358,7 +368,7 @@ fn parse_stability(sess: &Session, attr: &Attribute) -> Option<(Symbol, Stabilit
sym::feature => insert_or_error(sess, mi, &mut feature)?,
sym::since => insert_or_error(sess, mi, &mut since)?,
_ => {
sess.emit_err(session_diagnostics::UnknownMetaItem {
sess.dcx().emit_err(session_diagnostics::UnknownMetaItem {
span: meta.span(),
item: pprust::path_to_string(&mi.path),
expected: &["feature", "since"],
@ -371,9 +381,9 @@ fn parse_stability(sess: &Session, attr: &Attribute) -> Option<(Symbol, Stabilit
let feature = match feature {
Some(feature) if rustc_lexer::is_ident(feature.as_str()) => Ok(feature),
Some(_bad_feature) => {
Err(sess.emit_err(session_diagnostics::NonIdentFeature { span: attr.span }))
Err(sess.dcx().emit_err(session_diagnostics::NonIdentFeature { span: attr.span }))
}
None => Err(sess.emit_err(session_diagnostics::MissingFeature { span: attr.span })),
None => Err(sess.dcx().emit_err(session_diagnostics::MissingFeature { span: attr.span })),
};
let since = if let Some(since) = since {
@ -382,11 +392,11 @@ fn parse_stability(sess: &Session, attr: &Attribute) -> Option<(Symbol, Stabilit
} else if let Some(version) = parse_version(since) {
StableSince::Version(version)
} else {
sess.emit_err(session_diagnostics::InvalidSince { span: attr.span });
sess.dcx().emit_err(session_diagnostics::InvalidSince { span: attr.span });
StableSince::Err
}
} else {
sess.emit_err(session_diagnostics::MissingSince { span: attr.span });
sess.dcx().emit_err(session_diagnostics::MissingSince { span: attr.span });
StableSince::Err
};
@ -413,7 +423,7 @@ fn parse_unstability(sess: &Session, attr: &Attribute) -> Option<(Symbol, Stabil
let mut implied_by = None;
for meta in metas {
let Some(mi) = meta.meta_item() else {
sess.emit_err(session_diagnostics::UnsupportedLiteral {
sess.dcx().emit_err(session_diagnostics::UnsupportedLiteral {
span: meta.span(),
reason: UnsupportedLiteralReason::Generic,
is_bytestr: false,
@ -435,7 +445,7 @@ fn parse_unstability(sess: &Session, attr: &Attribute) -> Option<(Symbol, Stabil
issue => match issue.parse::<NonZeroU32>() {
Ok(num) => Some(num),
Err(err) => {
sess.emit_err(
sess.dcx().emit_err(
session_diagnostics::InvalidIssueString {
span: mi.span,
cause: session_diagnostics::InvalidIssueStringCause::from_int_error_kind(
@ -451,13 +461,13 @@ fn parse_unstability(sess: &Session, attr: &Attribute) -> Option<(Symbol, Stabil
}
sym::soft => {
if !mi.is_word() {
sess.emit_err(session_diagnostics::SoftNoArgs { span: mi.span });
sess.dcx().emit_err(session_diagnostics::SoftNoArgs { span: mi.span });
}
is_soft = true;
}
sym::implied_by => insert_or_error(sess, mi, &mut implied_by)?,
_ => {
sess.emit_err(session_diagnostics::UnknownMetaItem {
sess.dcx().emit_err(session_diagnostics::UnknownMetaItem {
span: meta.span(),
item: pprust::path_to_string(&mi.path),
expected: &["feature", "reason", "issue", "soft", "implied_by"],
@ -470,13 +480,13 @@ fn parse_unstability(sess: &Session, attr: &Attribute) -> Option<(Symbol, Stabil
let feature = match feature {
Some(feature) if rustc_lexer::is_ident(feature.as_str()) => Ok(feature),
Some(_bad_feature) => {
Err(sess.emit_err(session_diagnostics::NonIdentFeature { span: attr.span }))
Err(sess.dcx().emit_err(session_diagnostics::NonIdentFeature { span: attr.span }))
}
None => Err(sess.emit_err(session_diagnostics::MissingFeature { span: attr.span })),
None => Err(sess.dcx().emit_err(session_diagnostics::MissingFeature { span: attr.span })),
};
let issue =
issue.ok_or_else(|| sess.emit_err(session_diagnostics::MissingIssue { span: attr.span }));
let issue = issue
.ok_or_else(|| sess.dcx().emit_err(session_diagnostics::MissingIssue { span: attr.span }));
match (feature, issue) {
(Ok(feature), Ok(_)) => {
@ -588,6 +598,7 @@ pub fn eval_condition(
features: Option<&Features>,
eval: &mut impl FnMut(Condition) -> bool,
) -> bool {
let dcx = &sess.dcx;
match &cfg.kind {
ast::MetaItemKind::List(mis) if cfg.name_or_empty() == sym::version => {
try_gate_cfg(sym::version, cfg.span, sess, features);
@ -599,18 +610,18 @@ pub fn eval_condition(
NestedMetaItem::Lit(MetaItemLit { span, .. })
| NestedMetaItem::MetaItem(MetaItem { span, .. }),
] => {
sess.emit_err(session_diagnostics::ExpectedVersionLiteral { span: *span });
dcx.emit_err(session_diagnostics::ExpectedVersionLiteral { span: *span });
return false;
}
[..] => {
sess.emit_err(session_diagnostics::ExpectedSingleVersionLiteral {
dcx.emit_err(session_diagnostics::ExpectedSingleVersionLiteral {
span: cfg.span,
});
return false;
}
};
let Some(min_version) = parse_version(*min_version) else {
sess.emit_warning(session_diagnostics::UnknownVersionLiteral { span: *span });
dcx.emit_warning(session_diagnostics::UnknownVersionLiteral { span: *span });
return false;
};
@ -624,7 +635,7 @@ pub fn eval_condition(
ast::MetaItemKind::List(mis) => {
for mi in mis.iter() {
if !mi.is_meta_item() {
sess.emit_err(session_diagnostics::UnsupportedLiteral {
dcx.emit_err(session_diagnostics::UnsupportedLiteral {
span: mi.span(),
reason: UnsupportedLiteralReason::Generic,
is_bytestr: false,
@ -653,9 +664,7 @@ pub fn eval_condition(
}),
sym::not => {
if mis.len() != 1 {
sess.emit_err(session_diagnostics::ExpectedOneCfgPattern {
span: cfg.span,
});
dcx.emit_err(session_diagnostics::ExpectedOneCfgPattern { span: cfg.span });
return false;
}
@ -684,7 +693,7 @@ pub fn eval_condition(
})
}
_ => {
sess.emit_err(session_diagnostics::InvalidPredicate {
dcx.emit_err(session_diagnostics::InvalidPredicate {
span: cfg.span,
predicate: pprust::path_to_string(&cfg.path),
});
@ -693,11 +702,11 @@ pub fn eval_condition(
}
}
ast::MetaItemKind::Word | MetaItemKind::NameValue(..) if cfg.path.segments.len() != 1 => {
sess.emit_err(session_diagnostics::CfgPredicateIdentifier { span: cfg.path.span });
dcx.emit_err(session_diagnostics::CfgPredicateIdentifier { span: cfg.path.span });
true
}
MetaItemKind::NameValue(lit) if !lit.kind.is_str() => {
sess.emit_err(session_diagnostics::UnsupportedLiteral {
dcx.emit_err(session_diagnostics::UnsupportedLiteral {
span: lit.span,
reason: UnsupportedLiteralReason::CfgString,
is_bytestr: lit.kind.is_bytestr(),
@ -791,7 +800,7 @@ pub fn find_deprecation(
MetaItemKind::List(list) => {
let get = |meta: &MetaItem, item: &mut Option<Symbol>| {
if item.is_some() {
sess.emit_err(session_diagnostics::MultipleItem {
sess.dcx().emit_err(session_diagnostics::MultipleItem {
span: meta.span,
item: pprust::path_to_string(&meta.path),
});
@ -802,14 +811,14 @@ pub fn find_deprecation(
true
} else {
if let Some(lit) = meta.name_value_literal() {
sess.emit_err(session_diagnostics::UnsupportedLiteral {
sess.dcx().emit_err(session_diagnostics::UnsupportedLiteral {
span: lit.span,
reason: UnsupportedLiteralReason::DeprecatedString,
is_bytestr: lit.kind.is_bytestr(),
start_point_span: sess.source_map().start_point(lit.span),
});
} else {
sess.emit_err(session_diagnostics::IncorrectMetaItem {
sess.dcx().emit_err(session_diagnostics::IncorrectMetaItem {
span: meta.span,
});
}
@ -833,11 +842,13 @@ pub fn find_deprecation(
}
sym::suggestion => {
if !features.deprecated_suggestion {
sess.emit_err(session_diagnostics::DeprecatedItemSuggestion {
span: mi.span,
is_nightly: sess.is_nightly_build().then_some(()),
details: (),
});
sess.dcx().emit_err(
session_diagnostics::DeprecatedItemSuggestion {
span: mi.span,
is_nightly: sess.is_nightly_build().then_some(()),
details: (),
},
);
}
if !get(mi, &mut suggestion) {
@ -845,7 +856,7 @@ pub fn find_deprecation(
}
}
_ => {
sess.emit_err(session_diagnostics::UnknownMetaItem {
sess.dcx().emit_err(session_diagnostics::UnknownMetaItem {
span: meta.span(),
item: pprust::path_to_string(&mi.path),
expected: if features.deprecated_suggestion {
@ -858,7 +869,7 @@ pub fn find_deprecation(
}
},
NestedMetaItem::Lit(lit) => {
sess.emit_err(session_diagnostics::UnsupportedLiteral {
sess.dcx().emit_err(session_diagnostics::UnsupportedLiteral {
span: lit.span,
reason: UnsupportedLiteralReason::DeprecatedKvPair,
is_bytestr: false,
@ -879,18 +890,18 @@ pub fn find_deprecation(
} else if let Some(version) = parse_version(since) {
DeprecatedSince::RustcVersion(version)
} else {
sess.emit_err(session_diagnostics::InvalidSince { span: attr.span });
sess.dcx().emit_err(session_diagnostics::InvalidSince { span: attr.span });
DeprecatedSince::Err
}
} else if is_rustc {
sess.emit_err(session_diagnostics::MissingSince { span: attr.span });
sess.dcx().emit_err(session_diagnostics::MissingSince { span: attr.span });
DeprecatedSince::Err
} else {
DeprecatedSince::Unspecified
};
if is_rustc && note.is_none() {
sess.emit_err(session_diagnostics::MissingNote { span: attr.span });
sess.dcx().emit_err(session_diagnostics::MissingNote { span: attr.span });
continue;
}
@ -945,7 +956,7 @@ pub fn parse_repr_attr(sess: &Session, attr: &Attribute) -> Vec<ReprAttr> {
assert!(attr.has_name(sym::repr), "expected `#[repr(..)]`, found: {attr:?}");
use ReprAttr::*;
let mut acc = Vec::new();
let diagnostic = sess.dcx();
let dcx = sess.dcx();
if let Some(items) = attr.meta_item_list() {
for item in items {
@ -958,7 +969,7 @@ pub fn parse_repr_attr(sess: &Session, attr: &Attribute) -> Vec<ReprAttr> {
sym::simd => Some(ReprSimd),
sym::transparent => Some(ReprTransparent),
sym::align => {
sess.emit_err(session_diagnostics::InvalidReprAlignNeedArg {
sess.dcx().emit_err(session_diagnostics::InvalidReprAlignNeedArg {
span: item.span(),
});
recognised = true;
@ -989,13 +1000,13 @@ pub fn parse_repr_attr(sess: &Session, attr: &Attribute) -> Vec<ReprAttr> {
|| int_type_of_word(name).is_some()
{
recognised = true;
sess.emit_err(session_diagnostics::InvalidReprHintNoParen {
sess.dcx().emit_err(session_diagnostics::InvalidReprHintNoParen {
span: item.span(),
name: name.to_ident_string(),
});
}
if let Some(literal_error) = literal_error {
sess.emit_err(session_diagnostics::InvalidReprGeneric {
sess.dcx().emit_err(session_diagnostics::InvalidReprGeneric {
span: item.span(),
repr_arg: name.to_ident_string(),
error_part: literal_error,
@ -1007,7 +1018,7 @@ pub fn parse_repr_attr(sess: &Session, attr: &Attribute) -> Vec<ReprAttr> {
if meta_item.has_name(sym::align) || meta_item.has_name(sym::packed) {
let name = meta_item.name_or_empty().to_ident_string();
recognised = true;
sess.emit_err(session_diagnostics::IncorrectReprFormatGeneric {
sess.dcx().emit_err(session_diagnostics::IncorrectReprFormatGeneric {
span: item.span(),
repr_arg: &name,
cause: IncorrectReprFormatGenericCause::from_lit_kind(
@ -1022,7 +1033,7 @@ pub fn parse_repr_attr(sess: &Session, attr: &Attribute) -> Vec<ReprAttr> {
) || int_type_of_word(meta_item.name_or_empty()).is_some()
{
recognised = true;
sess.emit_err(session_diagnostics::InvalidReprHintNoValue {
sess.dcx().emit_err(session_diagnostics::InvalidReprHintNoValue {
span: meta_item.span,
name: meta_item.name_or_empty().to_ident_string(),
});
@ -1031,12 +1042,14 @@ pub fn parse_repr_attr(sess: &Session, attr: &Attribute) -> Vec<ReprAttr> {
MetaItemKind::List(_) => {
if meta_item.has_name(sym::align) {
recognised = true;
sess.emit_err(session_diagnostics::IncorrectReprFormatAlignOneArg {
span: meta_item.span,
});
sess.dcx().emit_err(
session_diagnostics::IncorrectReprFormatAlignOneArg {
span: meta_item.span,
},
);
} else if meta_item.has_name(sym::packed) {
recognised = true;
sess.emit_err(
sess.dcx().emit_err(
session_diagnostics::IncorrectReprFormatPackedOneOrZeroArg {
span: meta_item.span,
},
@ -1047,7 +1060,7 @@ pub fn parse_repr_attr(sess: &Session, attr: &Attribute) -> Vec<ReprAttr> {
) || int_type_of_word(meta_item.name_or_empty()).is_some()
{
recognised = true;
sess.emit_err(session_diagnostics::InvalidReprHintNoParen {
sess.dcx().emit_err(session_diagnostics::InvalidReprHintNoParen {
span: meta_item.span,
name: meta_item.name_or_empty().to_ident_string(),
});
@ -1062,7 +1075,7 @@ pub fn parse_repr_attr(sess: &Session, attr: &Attribute) -> Vec<ReprAttr> {
// (e.g. if we only pretty-print the source), so we have to gate
// the `span_delayed_bug` call as follows:
if sess.opts.pretty.map_or(true, |pp| pp.needs_analysis()) {
diagnostic.span_delayed_bug(item.span(), "unrecognized representation hint");
dcx.span_delayed_bug(item.span(), "unrecognized representation hint");
}
}
}
@ -1149,7 +1162,7 @@ fn allow_unstable<'a>(
let list = attrs
.filter_map(move |attr| {
attr.meta_item_list().or_else(|| {
sess.emit_err(session_diagnostics::ExpectsFeatureList {
sess.dcx().emit_err(session_diagnostics::ExpectsFeatureList {
span: attr.span,
name: symbol.to_ident_string(),
});
@ -1161,7 +1174,7 @@ fn allow_unstable<'a>(
list.into_iter().filter_map(move |it| {
let name = it.ident().map(|ident| ident.name);
if name.is_none() {
sess.emit_err(session_diagnostics::ExpectsFeatures {
sess.dcx().emit_err(session_diagnostics::ExpectsFeatures {
span: it.span(),
name: symbol.to_ident_string(),
});

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

@ -1,10 +1,12 @@
use rustc_errors::{
struct_span_err, DiagnosticBuilder, DiagnosticId, DiagnosticMessage, MultiSpan,
};
use rustc_errors::{struct_span_err, DiagCtxt, DiagnosticBuilder};
use rustc_middle::ty::{self, Ty, TyCtxt};
use rustc_span::Span;
impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
pub fn dcx(&self) -> &'tcx DiagCtxt {
self.infcx.dcx()
}
pub(crate) fn cannot_move_when_borrowed(
&self,
span: Span,
@ -13,7 +15,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
borrow_place: &str,
value_place: &str,
) -> DiagnosticBuilder<'tcx> {
self.infcx.tcx.sess.create_err(crate::session_diagnostics::MoveBorrow {
self.dcx().create_err(crate::session_diagnostics::MoveBorrow {
place,
span,
borrow_place,
@ -30,7 +32,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
borrow_desc: &str,
) -> DiagnosticBuilder<'tcx> {
let mut err = struct_span_err!(
self,
self.dcx(),
span,
E0503,
"cannot use {} because it was mutably borrowed",
@ -53,7 +55,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
) -> DiagnosticBuilder<'tcx> {
let via = |msg: &str| if msg.is_empty() { "".to_string() } else { format!(" (via {msg})") };
let mut err = struct_span_err!(
self,
self.dcx(),
new_loan_span,
E0499,
"cannot borrow {}{} as mutable more than once at a time",
@ -99,7 +101,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
old_load_end_span: Option<Span>,
) -> DiagnosticBuilder<'tcx> {
let mut err = struct_span_err!(
self,
self.dcx(),
new_loan_span,
E0524,
"two closures require unique access to {} at the same time",
@ -132,7 +134,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
previous_end_span: Option<Span>,
) -> DiagnosticBuilder<'cx> {
let mut err = struct_span_err!(
self,
self.dcx(),
new_loan_span,
E0500,
"closure requires unique access to {} but {} is already borrowed{}",
@ -164,7 +166,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
second_borrow_desc: &str,
) -> DiagnosticBuilder<'cx> {
let mut err = struct_span_err!(
self,
self.dcx(),
new_loan_span,
E0501,
"cannot borrow {}{} as {} because previous closure requires unique access",
@ -197,7 +199,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
) -> DiagnosticBuilder<'cx> {
let via = |msg: &str| if msg.is_empty() { "".to_string() } else { format!(" (via {msg})") };
let mut err = struct_span_err!(
self,
self.dcx(),
span,
E0502,
"cannot borrow {}{} as {} because {} is also borrowed as {}{}",
@ -237,7 +239,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
desc: &str,
) -> DiagnosticBuilder<'cx> {
let mut err = struct_span_err!(
self,
self.dcx(),
span,
E0506,
"cannot assign to {} because it is borrowed",
@ -256,11 +258,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, span, E0384, "cannot assign {} {}", msg, desc)
struct_span_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, span, E0594, "cannot assign to {}", desc)
struct_span_err!(self.dcx(), span, E0594, "cannot assign to {}", desc)
}
pub(crate) fn cannot_move_out_of(
@ -268,7 +270,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
move_from_span: Span,
move_from_desc: &str,
) -> DiagnosticBuilder<'cx> {
struct_span_err!(self, move_from_span, E0507, "cannot move out of {}", move_from_desc)
struct_span_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
@ -286,7 +288,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
_ => span_bug!(move_from_span, "this path should not cause illegal move"),
};
let mut err = struct_span_err!(
self,
self.dcx(),
move_from_span,
E0508,
"cannot move out of type `{}`, a non-copy {}",
@ -303,7 +305,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
container_ty: Ty<'_>,
) -> DiagnosticBuilder<'cx> {
let mut err = struct_span_err!(
self,
self.dcx(),
move_from_span,
E0509,
"cannot move out of type `{}`, which implements the `Drop` trait",
@ -323,7 +325,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
let moved_path = moved_path.map(|mp| format!(": `{mp}`")).unwrap_or_default();
struct_span_err!(
self,
self.dcx(),
use_span,
E0382,
"{} of {}moved value{}",
@ -339,7 +341,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
path: &str,
reason: &str,
) -> DiagnosticBuilder<'tcx> {
struct_span_err!(self, span, E0596, "cannot borrow {} as mutable{}", path, reason,)
struct_span_err!(self.dcx(), span, E0596, "cannot borrow {} as mutable{}", path, reason)
}
pub(crate) fn cannot_mutate_in_immutable_section(
@ -351,7 +353,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
action: &str,
) -> DiagnosticBuilder<'tcx> {
let mut err = struct_span_err!(
self,
self.dcx(),
mutate_span,
E0510,
"cannot {} {} in {}",
@ -371,7 +373,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
) -> DiagnosticBuilder<'tcx> {
let coroutine_kind = self.body.coroutine.as_ref().unwrap().coroutine_kind;
let mut err = struct_span_err!(
self,
self.dcx(),
span,
E0626,
"borrow may still be in use when {coroutine_kind:#} yields",
@ -385,7 +387,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
borrow_span: Span,
) -> DiagnosticBuilder<'tcx> {
struct_span_err!(
self,
self.dcx(),
borrow_span,
E0713,
"borrow may still be in use when destructor runs",
@ -397,7 +399,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
span: Span,
path: &str,
) -> DiagnosticBuilder<'tcx> {
struct_span_err!(self, span, E0597, "{} does not live long enough", path,)
struct_span_err!(self.dcx(), span, E0597, "{} does not live long enough", path,)
}
pub(crate) fn cannot_return_reference_to_local(
@ -408,7 +410,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
path_desc: &str,
) -> DiagnosticBuilder<'tcx> {
let mut err = struct_span_err!(
self,
self.dcx(),
span,
E0515,
"cannot {RETURN} {REFERENCE} {LOCAL}",
@ -434,7 +436,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
scope: &str,
) -> DiagnosticBuilder<'tcx> {
let mut err = struct_span_err!(
self,
self.dcx(),
closure_span,
E0373,
"{closure_kind} may outlive the current {scope}, but it borrows {borrowed_path}, \
@ -449,25 +451,19 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
&self,
span: Span,
) -> DiagnosticBuilder<'tcx> {
struct_span_err!(self, span, E0712, "thread-local variable borrowed past end of function",)
struct_span_err!(
self.dcx(),
span,
E0712,
"thread-local variable borrowed past end of function",
)
}
pub(crate) fn temporary_value_borrowed_for_too_long(
&self,
span: Span,
) -> DiagnosticBuilder<'tcx> {
struct_span_err!(self, span, E0716, "temporary value dropped while borrowed",)
}
#[rustc_lint_diagnostics]
#[track_caller]
pub(crate) fn struct_span_err_with_code<S: Into<MultiSpan>>(
&self,
sp: S,
msg: impl Into<DiagnosticMessage>,
code: DiagnosticId,
) -> DiagnosticBuilder<'tcx> {
self.infcx.tcx.sess.struct_span_err_with_code(sp, msg, code)
struct_span_err!(self.dcx(), span, E0716, "temporary value dropped while borrowed",)
}
}
@ -477,7 +473,7 @@ pub(crate) fn borrowed_data_escapes_closure<'tcx>(
escapes_from: &str,
) -> DiagnosticBuilder<'tcx> {
struct_span_err!(
tcx.sess,
tcx.dcx(),
escape_span,
E0521,
"borrowed data escapes outside of {}",

10
compiler/rustc_borrowck/src/diagnostics/bound_region_errors.rs
View File

@ -77,7 +77,7 @@ impl<'tcx> UniverseInfo<'tcx> {
// up in the existing UI tests. Consider investigating this
// some more.
mbcx.buffer_error(
mbcx.infcx.tcx.sess.create_err(HigherRankedSubtypeError { span: cause.span }),
mbcx.dcx().create_err(HigherRankedSubtypeError { span: cause.span }),
);
}
}
@ -221,7 +221,7 @@ struct PredicateQuery<'tcx> {
impl<'tcx> TypeOpInfo<'tcx> for PredicateQuery<'tcx> {
fn fallback_error(&self, tcx: TyCtxt<'tcx>, span: Span) -> DiagnosticBuilder<'tcx> {
tcx.sess.create_err(HigherRankedLifetimeError {
tcx.dcx().create_err(HigherRankedLifetimeError {
cause: Some(HigherRankedErrorCause::CouldNotProve {
predicate: self.canonical_query.value.value.predicate.to_string(),
}),
@ -258,7 +258,7 @@ where
T: Copy + fmt::Display + TypeFoldable<TyCtxt<'tcx>> + 'tcx,
{
fn fallback_error(&self, tcx: TyCtxt<'tcx>, span: Span) -> DiagnosticBuilder<'tcx> {
tcx.sess.create_err(HigherRankedLifetimeError {
tcx.dcx().create_err(HigherRankedLifetimeError {
cause: Some(HigherRankedErrorCause::CouldNotNormalize {
value: self.canonical_query.value.value.value.to_string(),
}),
@ -303,7 +303,7 @@ impl<'tcx> TypeOpInfo<'tcx> for AscribeUserTypeQuery<'tcx> {
fn fallback_error(&self, tcx: TyCtxt<'tcx>, span: Span) -> DiagnosticBuilder<'tcx> {
// FIXME: This error message isn't great, but it doesn't show up in the existing UI tests,
// and is only the fallback when the nice error fails. Consider improving this some more.
tcx.sess.create_err(HigherRankedLifetimeError { cause: None, span })
tcx.dcx().create_err(HigherRankedLifetimeError { cause: None, span })
}
fn base_universe(&self) -> ty::UniverseIndex {
@ -329,7 +329,7 @@ impl<'tcx> TypeOpInfo<'tcx> for crate::type_check::InstantiateOpaqueType<'tcx> {
fn fallback_error(&self, tcx: TyCtxt<'tcx>, span: Span) -> DiagnosticBuilder<'tcx> {
// FIXME: This error message isn't great, but it doesn't show up in the existing UI tests,
// and is only the fallback when the nice error fails. Consider improving this some more.
tcx.sess.create_err(HigherRankedLifetimeError { cause: None, span })
tcx.dcx().create_err(HigherRankedLifetimeError { cause: None, span })
}
fn base_universe(&self) -> ty::UniverseIndex {

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

@ -551,7 +551,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
let used = desired_action.as_general_verb_in_past_tense();
let mut err =
struct_span_err!(self, span, E0381, "{used} binding {desc}{isnt_initialized}");
struct_span_err!(self.dcx(), span, E0381, "{used} binding {desc}{isnt_initialized}");
use_spans.var_path_only_subdiag(&mut err, desired_action);
if let InitializationRequiringAction::PartialAssignment
@ -1136,7 +1136,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
});
} else {
issued_spans.var_subdiag(
Some(self.infcx.tcx.sess.dcx()),
Some(self.dcx()),
&mut err,
Some(issued_borrow.kind),
|kind, var_span| {
@ -1153,7 +1153,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
);
borrow_spans.var_subdiag(
Some(self.infcx.tcx.sess.dcx()),
Some(self.dcx()),
&mut err,
Some(gen_borrow_kind),
|kind, var_span| {

6
compiler/rustc_borrowck/src/diagnostics/mod.rs
View File

@ -124,7 +124,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
let did = did.expect_local();
if let Some((span, hir_place)) = self.infcx.tcx.closure_kind_origin(did) {
diag.eager_subdiagnostic(
self.infcx.tcx.sess.dcx(),
self.dcx(),
OnClosureNote::InvokedTwice {
place_name: &ty::place_to_string_for_capture(
self.infcx.tcx,
@ -146,7 +146,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
let did = did.expect_local();
if let Some((span, hir_place)) = self.infcx.tcx.closure_kind_origin(did) {
diag.eager_subdiagnostic(
self.infcx.tcx.sess.dcx(),
self.dcx(),
OnClosureNote::MovedTwice {
place_name: &ty::place_to_string_for_capture(self.infcx.tcx, hir_place),
span: *span,
@ -1150,7 +1150,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
&& self.infcx.can_eq(self.param_env, ty, self_ty)
{
err.eager_subdiagnostic(
self.infcx.tcx.sess.dcx(),
self.dcx(),
CaptureReasonSuggest::FreshReborrow {
span: move_span.shrink_to_hi(),
},

3
compiler/rustc_borrowck/src/diagnostics/outlives_suggestion.rs
View File

@ -206,7 +206,7 @@ impl OutlivesSuggestionBuilder {
// If there is exactly one suggestable constraints, then just suggest it. Otherwise, emit a
// list of diagnostics.
let mut diag = if suggested.len() == 1 {
mbcx.infcx.tcx.sess.dcx().struct_help(match suggested.last().unwrap() {
mbcx.dcx().struct_help(match suggested.last().unwrap() {
SuggestedConstraint::Outlives(a, bs) => {
let bs: SmallVec<[String; 2]> = bs.iter().map(|r| r.to_string()).collect();
format!("add bound `{a}: {}`", bs.join(" + "))
@ -222,7 +222,6 @@ impl OutlivesSuggestionBuilder {
let mut diag = mbcx
.infcx
.tcx
.sess
.dcx()
.struct_help("the following changes may resolve your lifetime errors");

15
compiler/rustc_borrowck/src/diagnostics/region_errors.rs
View File

@ -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.span_delayed_bug(DUMMY_SP, format!("{val:?}"));
self.1.sess.dcx().span_delayed_bug(DUMMY_SP, format!("{val:?}"));
self.0.push(val);
}
pub fn is_empty(&self) -> bool {
@ -327,11 +327,10 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
// to report it; we could probably handle it by
// iterating over the universal regions and reporting
// an error that multiple bounds are required.
let mut diag =
self.infcx.tcx.sess.create_err(GenericDoesNotLiveLongEnough {
kind: type_test.generic_kind.to_string(),
span: type_test_span,
});
let mut diag = self.dcx().create_err(GenericDoesNotLiveLongEnough {
kind: type_test.generic_kind.to_string(),
span: type_test_span,
});
// Add notes and suggestions for the case of 'static lifetime
// implied but not specified when a generic associated types
@ -596,7 +595,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
},
};
let mut diag = self.infcx.tcx.sess.create_err(err);
let mut diag = self.dcx().create_err(err);
if let ReturnConstraint::ClosureUpvar(upvar_field) = kind {
let def_id = match self.regioncx.universal_regions().defining_ty {
@ -758,7 +757,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
let mir_def_name = self.infcx.tcx.def_descr(self.mir_def_id().to_def_id());
let err = LifetimeOutliveErr { span: *span };
let mut diag = self.infcx.tcx.sess.create_err(err);
let mut diag = self.dcx().create_err(err);
// In certain scenarios, such as the one described in issue #118021,
// we might encounter a lifetime that cannot be named.

2
compiler/rustc_borrowck/src/diagnostics/region_name.rs
View File

@ -620,7 +620,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
) => {
// HIR lowering sometimes doesn't catch this in erroneous
// programs, so we need to use span_delayed_bug here. See #82126.
self.infcx.tcx.sess.span_delayed_bug(
self.dcx().span_delayed_bug(
hir_arg.span(),
format!("unmatched arg and hir arg: found {kind:?} vs {hir_arg:?}"),
);

7
compiler/rustc_borrowck/src/lib.rs
View File

@ -2134,7 +2134,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
// dereferencing a non-Copy raw pointer *and* have `-Ztreat-err-as-bug`
// enabled. We don't want to ICE for that case, as other errors will have
// been emitted (#52262).
self.infcx.tcx.sess.span_delayed_bug(
self.dcx().span_delayed_bug(
span,
format!(
"Accessing `{place:?}` with the kind `{kind:?}` shouldn't be possible",
@ -2428,7 +2428,7 @@ mod error {
pub fn buffer_error(&mut self, t: DiagnosticBuilder<'_>) {
if let None = self.tainted_by_errors {
self.tainted_by_errors = Some(self.tcx.sess.span_delayed_bug(
self.tainted_by_errors = Some(self.tcx.dcx().span_delayed_bug(
t.span.clone_ignoring_labels(),
"diagnostic buffered but not emitted",
))
@ -2497,8 +2497,9 @@ mod error {
if !self.errors.buffered.is_empty() {
self.errors.buffered.sort_by_key(|diag| diag.sort_span);
let dcx = self.dcx();
for diag in self.errors.buffered.drain(..) {
self.infcx.tcx.sess.dcx().emit_diagnostic(diag);
dcx.emit_diagnostic(diag);
}
}

6
compiler/rustc_borrowck/src/nll.rs
View File

@ -187,7 +187,7 @@ pub(crate) fn compute_regions<'cx, 'tcx>(
if !nll_errors.is_empty() {
// Suppress unhelpful extra errors in `infer_opaque_types`.
infcx.set_tainted_by_errors(infcx.tcx.sess.span_delayed_bug(
infcx.set_tainted_by_errors(infcx.dcx().span_delayed_bug(
body.span,
"`compute_regions` tainted `infcx` with errors but did not emit any errors",
));
@ -280,7 +280,7 @@ pub(super) fn dump_annotation<'tcx>(
let def_span = tcx.def_span(body.source.def_id());
let mut err = if let Some(closure_region_requirements) = closure_region_requirements {
let mut err = tcx.sess.dcx().struct_span_note(def_span, "external requirements");
let mut err = tcx.dcx().struct_span_note(def_span, "external requirements");
regioncx.annotate(tcx, &mut err);
@ -299,7 +299,7 @@ pub(super) fn dump_annotation<'tcx>(
err
} else {
let mut err = tcx.sess.dcx().struct_span_note(def_span, "no external requirements");
let mut err = tcx.dcx().struct_span_note(def_span, "no external requirements");
regioncx.annotate(tcx, &mut err);
err

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

@ -402,7 +402,7 @@ fn check_opaque_type_parameter_valid(
let opaque_param = opaque_generics.param_at(i, tcx);
let kind = opaque_param.kind.descr();
return Err(tcx.sess.emit_err(NonGenericOpaqueTypeParam {
return Err(tcx.dcx().emit_err(NonGenericOpaqueTypeParam {
ty: arg,
kind,
span,
@ -419,7 +419,7 @@ fn check_opaque_type_parameter_valid(
.map(|i| tcx.def_span(opaque_generics.param_at(i, tcx).def_id))
.collect();
return Err(tcx
.sess
.dcx()
.struct_span_err(span, "non-defining opaque type use in defining scope")
.span_note(spans, format!("{descr} used multiple times"))
.emit());

4
compiler/rustc_borrowck/src/type_check/input_output.rs
View File

@ -76,7 +76,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
for (argument_index, &normalized_input_ty) in normalized_input_tys.iter().enumerate() {
if argument_index + 1 >= body.local_decls.len() {
self.tcx()
.sess
.dcx()
.span_delayed_bug(body.span, "found more normalized_input_ty than local_decls");
break;
}
@ -104,7 +104,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
// outside of a coroutine and return an `impl Trait`, so emit a span_delayed_bug
// because we don't want to panic in an assert here if we've already got errors.
if body.yield_ty().is_some() != universal_regions.yield_ty.is_some() {
self.tcx().sess.span_delayed_bug(
self.tcx().dcx().span_delayed_bug(
body.span,
format!(
"Expected body to have yield_ty ({:?}) iff we have a UR yield_ty ({:?})",

10
compiler/rustc_borrowck/src/type_check/mod.rs
View File

@ -224,7 +224,7 @@ pub(crate) fn type_check<'mir, 'tcx>(
let mut hidden_type = infcx.resolve_vars_if_possible(decl.hidden_type);
trace!("finalized opaque type {:?} to {:#?}", opaque_type_key, hidden_type.ty.kind());
if hidden_type.has_non_region_infer() {
let reported = infcx.tcx.sess.span_delayed_bug(
let reported = infcx.dcx().span_delayed_bug(
decl.hidden_type.span,
format!("could not resolve {:#?}", hidden_type.ty.kind()),
);
@ -268,7 +268,7 @@ fn mirbug(tcx: TyCtxt<'_>, span: Span, msg: String) {
// We sometimes see MIR failures (notably predicate failures) due to
// the fact that we check rvalue sized predicates here. So use `span_delayed_bug`
// to avoid reporting bugs in those cases.
tcx.sess.dcx().span_delayed_bug(span, msg);
tcx.dcx().span_delayed_bug(span, msg);
}
enum FieldAccessError {
@ -1067,7 +1067,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
);
if result.is_err() {
self.infcx.tcx.sess.span_delayed_bug(
self.infcx.dcx().span_delayed_bug(
self.body.span,
"failed re-defining predefined opaques in mir typeck",
);
@ -1573,7 +1573,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
sym::simd_shuffle => {
if !matches!(args[2], Operand::Constant(_)) {
self.tcx()
.sess
.dcx()
.emit_err(SimdShuffleLastConst { span: term.source_info.span });
}
}
@ -1752,7 +1752,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
// While this is located in `nll::typeck` this error is not
// an NLL error, it's a required check to prevent creation
// of unsized rvalues in a call expression.
self.tcx().sess.emit_err(MoveUnsized { ty, span });
self.tcx().dcx().emit_err(MoveUnsized { ty, span });
}
}
}

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

@ -31,7 +31,7 @@ pub fn expand(
{
(item, true, ecx.with_def_site_ctxt(fn_kind.sig.span))
} else {
ecx.sess.dcx().emit_err(errors::AllocErrorMustBeFn { span: item.span() });
ecx.dcx().emit_err(errors::AllocErrorMustBeFn { span: item.span() });
return vec![orig_item];
};

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

@ -422,7 +422,7 @@ fn parse_reg<'a>(
ast::InlineAsmRegOrRegClass::Reg(symbol)
}
_ => {
return Err(p.sess.create_err(errors::ExpectedRegisterClassOrExplicitRegister {
return Err(p.dcx().create_err(errors::ExpectedRegisterClassOrExplicitRegister {
span: p.token.span,
}));
}
@ -541,7 +541,7 @@ fn expand_preparsed_asm(ecx: &mut ExtCtxt<'_>, args: AsmArgs) -> Option<ast::Inl
let err = parser.errors.remove(0);
let err_sp = template_span.from_inner(InnerSpan::new(err.span.start, err.span.end));
let msg = format!("invalid asm template string: {}", err.description);
let mut e = ecx.struct_span_err(err_sp, msg);
let mut e = ecx.dcx().struct_span_err(err_sp, msg);
e.span_label(err_sp, err.label + " in asm template string");
if let Some(note) = err.note {
e.note(note);
@ -575,7 +575,7 @@ fn expand_preparsed_asm(ecx: &mut ExtCtxt<'_>, args: AsmArgs) -> Option<ast::Inl
|| args.reg_args.contains(idx)
{
let msg = format!("invalid reference to argument at index {idx}");
let mut err = ecx.struct_span_err(span, msg);
let mut err = ecx.dcx().struct_span_err(span, msg);
err.span_label(span, "from here");
let positional_args = args.operands.len()
@ -625,12 +625,13 @@ fn expand_preparsed_asm(ecx: &mut ExtCtxt<'_>, args: AsmArgs) -> Option<ast::Inl
None => {
let msg = format!("there is no argument named `{name}`");
let span = arg.position_span;
ecx.struct_span_err(
template_span
.from_inner(InnerSpan::new(span.start, span.end)),
msg,
)
.emit();
ecx.dcx()
.struct_span_err(
template_span
.from_inner(InnerSpan::new(span.start, span.end)),
msg,
)
.emit();
None
}
}
@ -645,7 +646,7 @@ fn expand_preparsed_asm(ecx: &mut ExtCtxt<'_>, args: AsmArgs) -> Option<ast::Inl
.ty_span
.map(|sp| template_sp.from_inner(InnerSpan::new(sp.start, sp.end)))
.unwrap_or(template_sp);
ecx.emit_err(errors::AsmModifierInvalid { span });
ecx.dcx().emit_err(errors::AsmModifierInvalid { span });
modifier = None;
}
@ -692,7 +693,7 @@ fn expand_preparsed_asm(ecx: &mut ExtCtxt<'_>, args: AsmArgs) -> Option<ast::Inl
0 => {}
1 => {
let (sp, msg) = unused_operands.into_iter().next().unwrap();
let mut err = ecx.struct_span_err(sp, msg);
let mut err = ecx.dcx().struct_span_err(sp, msg);
err.span_label(sp, msg);
err.help(format!(
"if this argument is intentionally unused, \
@ -701,7 +702,7 @@ fn expand_preparsed_asm(ecx: &mut ExtCtxt<'_>, args: AsmArgs) -> Option<ast::Inl
err.emit();
}
_ => {
let mut err = ecx.struct_span_err(
let mut err = ecx.dcx().struct_span_err(
unused_operands.iter().map(|&(sp, _)| sp).collect::<Vec<Span>>(),
"multiple unused asm arguments",
);

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

@ -115,7 +115,7 @@ fn parse_assert<'a>(cx: &mut ExtCtxt<'a>, sp: Span, stream: TokenStream) -> PRes
let mut parser = cx.new_parser_from_tts(stream);
if parser.token == token::Eof {
return Err(cx.create_err(errors::AssertRequiresBoolean { span: sp }));
return Err(cx.dcx().create_err(errors::AssertRequiresBoolean { span: sp }));
}
let cond_expr = parser.parse_expr()?;
@ -128,7 +128,7 @@ fn parse_assert<'a>(cx: &mut ExtCtxt<'a>, sp: Span, stream: TokenStream) -> PRes
//
// Emit an error about semicolon and suggest removing it.
if parser.token == token::Semi {
cx.emit_err(errors::AssertRequiresExpression { span: sp, token: parser.token.span });
cx.dcx().emit_err(errors::AssertRequiresExpression { span: sp, token: parser.token.span });
parser.bump();
}
@ -141,7 +141,7 @@ fn parse_assert<'a>(cx: &mut ExtCtxt<'a>, sp: Span, stream: TokenStream) -> PRes
let custom_message =
if let token::Literal(token::Lit { kind: token::Str, .. }) = parser.token.kind {
let comma = parser.prev_token.span.shrink_to_hi();
cx.emit_err(errors::AssertMissingComma { span: parser.token.span, comma });
cx.dcx().emit_err(errors::AssertMissingComma { span: parser.token.span, comma });
parse_custom_message(&mut parser)
} else if parser.eat(&token::Comma) {

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

@ -39,7 +39,7 @@ fn parse_cfg<'a>(cx: &mut ExtCtxt<'a>, span: Span, tts: TokenStream) -> PResult<
let mut p = cx.new_parser_from_tts(tts);
if p.token == token::Eof {
return Err(cx.create_err(errors::RequiresCfgPattern { span }));
return Err(cx.dcx().create_err(errors::RequiresCfgPattern { span }));
}
let cfg = p.parse_meta_item()?;
@ -47,7 +47,7 @@ fn parse_cfg<'a>(cx: &mut ExtCtxt<'a>, span: Span, tts: TokenStream) -> PResult<
let _ = p.eat(&token::Comma);
if !p.eat(&token::Eof) {
return Err(cx.create_err(errors::OneCfgPattern { span }));
return Err(cx.dcx().create_err(errors::OneCfgPattern { span }));
}
Ok(cfg)

10
compiler/rustc_builtin_macros/src/cfg_accessible.rs
View File

@ -15,18 +15,18 @@ fn validate_input<'a>(ecx: &mut ExtCtxt<'_>, mi: &'a ast::MetaItem) -> Option<&'
match mi.meta_item_list() {
None => {}
Some([]) => {
ecx.emit_err(UnspecifiedPath(mi.span));
ecx.dcx().emit_err(UnspecifiedPath(mi.span));
}
Some([_, .., l]) => {
ecx.emit_err(MultiplePaths(l.span()));
ecx.dcx().emit_err(MultiplePaths(l.span()));
}
Some([nmi]) => match nmi.meta_item() {
None => {
ecx.emit_err(LiteralPath(nmi.span()));
ecx.dcx().emit_err(LiteralPath(nmi.span()));
}
Some(mi) => {
if !mi.is_word() {
ecx.emit_err(HasArguments(mi.span));
ecx.dcx().emit_err(HasArguments(mi.span));
}
return Some(&mi.path);
}
@ -61,7 +61,7 @@ impl MultiItemModifier for Expander {
Ok(true) => ExpandResult::Ready(vec![item]),
Ok(false) => ExpandResult::Ready(Vec::new()),
Err(Indeterminate) if ecx.force_mode => {
ecx.emit_err(errors::CfgAccessibleIndeterminate { span });
ecx.dcx().emit_err(errors::CfgAccessibleIndeterminate { span });
ExpandResult::Ready(vec![item])
}
Err(Indeterminate) => ExpandResult::Retry(item),

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

@ -18,7 +18,7 @@ pub fn expand_compile_error<'cx>(
reason = "diagnostic message is specified by user"
)]
#[expect(rustc::untranslatable_diagnostic, reason = "diagnostic message is specified by user")]
cx.span_err(sp, var.to_string());
cx.dcx().span_err(sp, var.to_string());
DummyResult::any(sp)
}

8
compiler/rustc_builtin_macros/src/concat.rs
View File

@ -33,11 +33,11 @@ pub fn expand_concat(
accumulator.push_str(&b.to_string());
}
Ok(ast::LitKind::CStr(..)) => {
cx.emit_err(errors::ConcatCStrLit { span: e.span });
cx.dcx().emit_err(errors::ConcatCStrLit { span: e.span });
has_errors = true;
}
Ok(ast::LitKind::Byte(..) | ast::LitKind::ByteStr(..)) => {
cx.emit_err(errors::ConcatBytestr { span: e.span });
cx.dcx().emit_err(errors::ConcatBytestr { span: e.span });
has_errors = true;
}
Ok(ast::LitKind::Err) => {
@ -63,7 +63,7 @@ pub fn expand_concat(
}
}
ast::ExprKind::IncludedBytes(..) => {
cx.emit_err(errors::ConcatBytestr { span: e.span });
cx.dcx().emit_err(errors::ConcatBytestr { span: e.span });
}
ast::ExprKind::Err => {
has_errors = true;
@ -75,7 +75,7 @@ pub fn expand_concat(
}
if !missing_literal.is_empty() {
cx.emit_err(errors::ConcatMissingLiteral { spans: missing_literal });
cx.dcx().emit_err(errors::ConcatMissingLiteral { spans: missing_literal });
return DummyResult::any(sp);
} else if has_errors {
return DummyResult::any(sp);

28
compiler/rustc_builtin_macros/src/concat_bytes.rs
View File

@ -17,16 +17,17 @@ fn invalid_type_err(
ConcatBytesInvalid, ConcatBytesInvalidSuggestion, ConcatBytesNonU8, ConcatBytesOob,
};
let snippet = cx.sess.source_map().span_to_snippet(span).ok();
let dcx = cx.dcx();
match ast::LitKind::from_token_lit(token_lit) {
Ok(ast::LitKind::CStr(_, _)) => {
// Avoid ambiguity in handling of terminal `NUL` by refusing to
// concatenate C string literals as bytes.
cx.emit_err(errors::ConcatCStrLit { span: span });
dcx.emit_err(errors::ConcatCStrLit { span: span });
}
Ok(ast::LitKind::Char(_)) => {
let sugg =
snippet.map(|snippet| ConcatBytesInvalidSuggestion::CharLit { span, snippet });
cx.sess.emit_err(ConcatBytesInvalid { span, lit_kind: "character", sugg });
dcx.emit_err(ConcatBytesInvalid { span, lit_kind: "character", sugg });
}
Ok(ast::LitKind::Str(_, _)) => {
// suggestion would be invalid if we are nested
@ -35,29 +36,29 @@ fn invalid_type_err(
} else {
None
};
cx.emit_err(ConcatBytesInvalid { span, lit_kind: "string", sugg });
dcx.emit_err(ConcatBytesInvalid { span, lit_kind: "string", sugg });
}
Ok(ast::LitKind::Float(_, _)) => {
cx.emit_err(ConcatBytesInvalid { span, lit_kind: "float", sugg: None });
dcx.emit_err(ConcatBytesInvalid { span, lit_kind: "float", sugg: None });
}
Ok(ast::LitKind::Bool(_)) => {
cx.emit_err(ConcatBytesInvalid { span, lit_kind: "boolean", sugg: None });
dcx.emit_err(ConcatBytesInvalid { span, lit_kind: "boolean", sugg: None });
}
Ok(ast::LitKind::Err) => {}
Ok(ast::LitKind::Int(_, _)) if !is_nested => {
let sugg =
snippet.map(|snippet| ConcatBytesInvalidSuggestion::IntLit { span: span, snippet });
cx.emit_err(ConcatBytesInvalid { span, lit_kind: "numeric", sugg });
dcx.emit_err(ConcatBytesInvalid { span, lit_kind: "numeric", sugg });
}
Ok(ast::LitKind::Int(
val,
ast::LitIntType::Unsuffixed | ast::LitIntType::Unsigned(ast::UintTy::U8),
)) => {
assert!(val > u8::MAX.into()); // must be an error
cx.emit_err(ConcatBytesOob { span });
dcx.emit_err(ConcatBytesOob { span });
}
Ok(ast::LitKind::Int(_, _)) => {
cx.emit_err(ConcatBytesNonU8 { span });
dcx.emit_err(ConcatBytesNonU8 { span });
}
Ok(ast::LitKind::ByteStr(..) | ast::LitKind::Byte(_)) => unreachable!(),
Err(err) => {
@ -72,10 +73,11 @@ fn handle_array_element(
missing_literals: &mut Vec<rustc_span::Span>,
expr: &P<rustc_ast::Expr>,
) -> Option<u8> {
let dcx = cx.dcx();
match expr.kind {
ast::ExprKind::Array(_) | ast::ExprKind::Repeat(_, _) => {
if !*has_errors {
cx.emit_err(errors::ConcatBytesArray { span: expr.span, bytestr: false });
dcx.emit_err(errors::ConcatBytesArray { span: expr.span, bytestr: false });
}
*has_errors = true;
None
@ -89,7 +91,7 @@ fn handle_array_element(
Ok(ast::LitKind::Byte(val)) => Some(val),
Ok(ast::LitKind::ByteStr(..)) => {
if !*has_errors {
cx.emit_err(errors::ConcatBytesArray { span: expr.span, bytestr: true });
dcx.emit_err(errors::ConcatBytesArray { span: expr.span, bytestr: true });
}
*has_errors = true;
None
@ -104,7 +106,7 @@ fn handle_array_element(
},
ast::ExprKind::IncludedBytes(..) => {
if !*has_errors {
cx.emit_err(errors::ConcatBytesArray { span: expr.span, bytestr: false });
dcx.emit_err(errors::ConcatBytesArray { span: expr.span, bytestr: false });
}
*has_errors = true;
None
@ -151,7 +153,7 @@ pub fn expand_concat_bytes(
}
}
} else {
cx.emit_err(errors::ConcatBytesBadRepeat { span: count.value.span });
cx.dcx().emit_err(errors::ConcatBytesBadRepeat { span: count.value.span });
}
}
&ast::ExprKind::Lit(token_lit) => match ast::LitKind::from_token_lit(token_lit) {
@ -180,7 +182,7 @@ pub fn expand_concat_bytes(
}
}
if !missing_literals.is_empty() {
cx.emit_err(errors::ConcatBytesMissingLiteral { spans: missing_literals });
cx.dcx().emit_err(errors::ConcatBytesMissingLiteral { spans: missing_literals });
return base::MacEager::expr(DummyResult::raw_expr(sp, true));
} else if has_errors {
return base::MacEager::expr(DummyResult::raw_expr(sp, true));

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

@ -14,7 +14,7 @@ pub fn expand_concat_idents<'cx>(
tts: TokenStream,
) -> Box<dyn base::MacResult + 'cx> {
if tts.is_empty() {
cx.emit_err(errors::ConcatIdentsMissingArgs { span: sp });
cx.dcx().emit_err(errors::ConcatIdentsMissingArgs { span: sp });
return DummyResult::any(sp);
}
@ -24,7 +24,7 @@ pub fn expand_concat_idents<'cx>(
match e {
TokenTree::Token(Token { kind: token::Comma, .. }, _) => {}
_ => {
cx.emit_err(errors::ConcatIdentsMissingComma { span: sp });
cx.dcx().emit_err(errors::ConcatIdentsMissingComma { span: sp });
return DummyResult::any(sp);
}
}
@ -36,7 +36,7 @@ pub fn expand_concat_idents<'cx>(
}
}
cx.emit_err(errors::ConcatIdentsIdentArgs { span: sp });
cx.dcx().emit_err(errors::ConcatIdentsIdentArgs { span: sp });
return DummyResult::any(sp);
}
}

8
compiler/rustc_builtin_macros/src/derive.rs
View File

@ -120,7 +120,7 @@ fn report_bad_target(
let bad_target =
!matches!(item_kind, Some(ItemKind::Struct(..) | ItemKind::Enum(..) | ItemKind::Union(..)));
if bad_target {
return Err(sess.emit_err(errors::BadDeriveTarget { span, item: item.span() }));
return Err(sess.dcx().emit_err(errors::BadDeriveTarget { span, item: item.span() }));
}
Ok(())
}
@ -134,7 +134,7 @@ fn report_unexpected_meta_item_lit(sess: &Session, lit: &ast::MetaItemLit) {
}
_ => errors::BadDeriveLitHelp::Other,
};
sess.emit_err(errors::BadDeriveLit { span: lit.span, help });
sess.dcx().emit_err(errors::BadDeriveLit { span: lit.span, help });
}
fn report_path_args(sess: &Session, meta: &ast::MetaItem) {
@ -143,10 +143,10 @@ fn report_path_args(sess: &Session, meta: &ast::MetaItem) {
match meta.kind {
MetaItemKind::Word => {}
MetaItemKind::List(..) => {
sess.emit_err(errors::DerivePathArgsList { span });
sess.dcx().emit_err(errors::DerivePathArgsList { span });
}
MetaItemKind::NameValue(..) => {
sess.emit_err(errors::DerivePathArgsValue { span });
sess.dcx().emit_err(errors::DerivePathArgsValue { span });
}
}
}

12
compiler/rustc_builtin_macros/src/deriving/clone.rs
View File

@ -62,10 +62,10 @@ pub fn expand_deriving_clone(
cs_clone_simple("Clone", c, s, sub, true)
}));
}
_ => cx.span_bug(span, "`#[derive(Clone)]` on wrong item kind"),
_ => cx.dcx().span_bug(span, "`#[derive(Clone)]` on wrong item kind"),
},
_ => cx.span_bug(span, "`#[derive(Clone)]` on trait item or impl item"),
_ => cx.dcx().span_bug(span, "`#[derive(Clone)]` on trait item or impl item"),
}
let trait_def = TraitDef {
@ -144,7 +144,7 @@ fn cs_clone_simple(
process_variant(&variant.data);
}
}
_ => cx.span_bug(
_ => cx.dcx().span_bug(
trait_span,
format!("unexpected substructure in simple `derive({name})`"),
),
@ -180,10 +180,10 @@ fn cs_clone(
vdata = &variant.data;
}
EnumTag(..) | AllFieldlessEnum(..) => {
cx.span_bug(trait_span, format!("enum tags in `derive({name})`",))
cx.dcx().span_bug(trait_span, format!("enum tags in `derive({name})`",))
}
StaticEnum(..) | StaticStruct(..) => {
cx.span_bug(trait_span, format!("associated function in `derive({name})`"))
cx.dcx().span_bug(trait_span, format!("associated function in `derive({name})`"))
}
}
@ -193,7 +193,7 @@ fn cs_clone(
.iter()
.map(|field| {
let Some(ident) = field.name else {
cx.span_bug(
cx.dcx().span_bug(
trait_span,
format!("unnamed field in normal struct in `derive({name})`",),
);

2
compiler/rustc_builtin_macros/src/deriving/cmp/eq.rs
View File

@ -99,7 +99,7 @@ fn cs_total_eq_assert(
process_variant(&variant.data);
}
}
_ => cx.span_bug(trait_span, "unexpected substructure in `derive(Eq)`"),
_ => cx.dcx().span_bug(trait_span, "unexpected substructure in `derive(Eq)`"),
}
BlockOrExpr::new_stmts(stmts)
}

2
compiler/rustc_builtin_macros/src/deriving/cmp/ord.rs
View File

@ -61,7 +61,7 @@ pub fn cs_cmp(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) -> Bl
|cx, fold| match fold {
CsFold::Single(field) => {
let [other_expr] = &field.other_selflike_exprs[..] else {
cx.span_bug(field.span, "not exactly 2 arguments in `derive(Ord)`");
cx.dcx().span_bug(field.span, "not exactly 2 arguments in `derive(Ord)`");
};
let args = thin_vec![field.self_expr.clone(), other_expr.clone()];
cx.expr_call_global(field.span, cmp_path.clone(), args)

3
compiler/rustc_builtin_macros/src/deriving/cmp/partial_eq.rs
View File

@ -26,7 +26,8 @@ pub fn expand_deriving_partial_eq(
|cx, fold| match fold {
CsFold::Single(field) => {
let [other_expr] = &field.other_selflike_exprs[..] else {
cx.span_bug(field.span, "not exactly 2 arguments in `derive(PartialEq)`");
cx.dcx()
.span_bug(field.span, "not exactly 2 arguments in `derive(PartialEq)`");
};
// We received arguments of type `&T`. Convert them to type `T` by stripping

2
compiler/rustc_builtin_macros/src/deriving/cmp/partial_ord.rs
View File

@ -95,7 +95,7 @@ fn cs_partial_cmp(
|cx, fold| match fold {
CsFold::Single(field) => {
let [other_expr] = &field.other_selflike_exprs[..] else {
cx.span_bug(field.span, "not exactly 2 arguments in `derive(Ord)`");
cx.dcx().span_bug(field.span, "not exactly 2 arguments in `derive(Ord)`");
};
let args = thin_vec![field.self_expr.clone(), other_expr.clone()];
cx.expr_call_global(field.span, partial_cmp_path.clone(), args)

2
compiler/rustc_builtin_macros/src/deriving/debug.rs
View File

@ -55,7 +55,7 @@ fn show_substructure(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>
EnumMatching(_, _, v, fields) => (v.ident, &v.data, fields),
AllFieldlessEnum(enum_def) => return show_fieldless_enum(cx, span, enum_def, substr),
EnumTag(..) | StaticStruct(..) | StaticEnum(..) => {
cx.span_bug(span, "nonsensical .fields in `#[derive(Debug)]`")
cx.dcx().span_bug(span, "nonsensical .fields in `#[derive(Debug)]`")
}
};

2
compiler/rustc_builtin_macros/src/deriving/decodable.rs
View File

@ -177,7 +177,7 @@ fn decodable_substructure(
],
)
}
_ => cx.bug("expected StaticEnum or StaticStruct in derive(Decodable)"),
_ => cx.dcx().bug("expected StaticEnum or StaticStruct in derive(Decodable)"),
};
BlockOrExpr::new_expr(expr)
}

18
compiler/rustc_builtin_macros/src/deriving/default.rs
View File

@ -41,7 +41,7 @@ pub fn expand_deriving_default(
default_struct_substructure(cx, trait_span, substr, fields)
}
StaticEnum(enum_def, _) => default_enum_substructure(cx, trait_span, enum_def),
_ => cx.span_bug(trait_span, "method in `derive(Default)`"),
_ => cx.dcx().span_bug(trait_span, "method in `derive(Default)`"),
}
})),
}],
@ -120,7 +120,7 @@ fn extract_default_variant<'a>(
let suggs = possible_defaults
.map(|v| errors::NoDefaultVariantSugg { span: v.span, ident: v.ident })
.collect();
cx.emit_err(errors::NoDefaultVariant { span: trait_span, suggs });
cx.dcx().emit_err(errors::NoDefaultVariant { span: trait_span, suggs });
return Err(());
}
@ -140,7 +140,7 @@ fn extract_default_variant<'a>(
.then_some(errors::MultipleDefaultsSugg { spans, ident: variant.ident })
})
.collect();
cx.emit_err(errors::MultipleDefaults {
cx.dcx().emit_err(errors::MultipleDefaults {
span: trait_span,
first: first.span,
additional: rest.iter().map(|v| v.span).collect(),
@ -151,12 +151,12 @@ fn extract_default_variant<'a>(
};
if !matches!(variant.data, VariantData::Unit(..)) {
cx.emit_err(errors::NonUnitDefault { span: variant.ident.span });
cx.dcx().emit_err(errors::NonUnitDefault { span: variant.ident.span });
return Err(());
}
if let Some(non_exhaustive_attr) = attr::find_by_name(&variant.attrs, sym::non_exhaustive) {
cx.emit_err(errors::NonExhaustiveDefault {
cx.dcx().emit_err(errors::NonExhaustiveDefault {
span: variant.ident.span,
non_exhaustive: non_exhaustive_attr.span,
});
@ -176,14 +176,14 @@ fn validate_default_attribute(
let attr = match attrs.as_slice() {
[attr] => attr,
[] => cx.bug(
[] => cx.dcx().bug(
"this method must only be called with a variant that has a `#[default]` attribute",
),
[first, rest @ ..] => {
let sugg = errors::MultipleDefaultAttrsSugg {
spans: rest.iter().map(|attr| attr.span).collect(),
};
cx.emit_err(errors::MultipleDefaultAttrs {
cx.dcx().emit_err(errors::MultipleDefaultAttrs {
span: default_variant.ident.span,
first: first.span,
first_rest: rest[0].span,
@ -196,7 +196,7 @@ fn validate_default_attribute(
}
};
if !attr.is_word() {
cx.emit_err(errors::DefaultHasArg { span: attr.span });
cx.dcx().emit_err(errors::DefaultHasArg { span: attr.span });
return Err(());
}
@ -210,7 +210,7 @@ struct DetectNonVariantDefaultAttr<'a, 'b> {
impl<'a, 'b> rustc_ast::visit::Visitor<'a> for DetectNonVariantDefaultAttr<'a, 'b> {
fn visit_attribute(&mut self, attr: &'a rustc_ast::Attribute) {
if attr.has_name(kw::Default) {
self.cx.emit_err(errors::NonUnitDefault { span: attr.span });
self.cx.dcx().emit_err(errors::NonUnitDefault { span: attr.span });
}
rustc_ast::visit::walk_attribute(self, attr);

2
compiler/rustc_builtin_macros/src/deriving/encodable.rs
View File

@ -296,6 +296,6 @@ fn encodable_substructure(
BlockOrExpr::new_mixed(thin_vec![me], Some(expr))
}
_ => cx.bug("expected Struct or EnumMatching in derive(Encodable)"),
_ => cx.dcx().bug("expected Struct or EnumMatching in derive(Encodable)"),
}
}

20
compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
View File

@ -430,7 +430,7 @@ fn find_type_parameters(
}
fn visit_mac_call(&mut self, mac: &ast::MacCall) {
self.cx.emit_err(errors::DeriveMacroCall { span: mac.span() });
self.cx.dcx().emit_err(errors::DeriveMacroCall { span: mac.span() });
}
}
@ -503,7 +503,7 @@ impl<'a> TraitDef<'a> {
is_packed,
)
} else {
cx.emit_err(errors::DeriveUnion { span: mitem.span });
cx.dcx().emit_err(errors::DeriveUnion { span: mitem.span });
return;
}
}
@ -974,7 +974,7 @@ impl<'a> MethodDef<'a> {
match ty {
// Selflike (`&Self`) arguments only occur in non-static methods.
Ref(box Self_, _) if !self.is_static() => selflike_args.push(arg_expr),
Self_ => cx.span_bug(span, "`Self` in non-return position"),
Self_ => cx.dcx().span_bug(span, "`Self` in non-return position"),
_ => nonselflike_args.push(arg_expr),
}
}
@ -1441,9 +1441,9 @@ impl<'a> TraitDef<'a> {
let is_tuple = matches!(struct_def, ast::VariantData::Tuple(..));
match (just_spans.is_empty(), named_idents.is_empty()) {
(false, false) => {
cx.span_bug(self.span, "a struct with named and unnamed fields in generic `derive`")
}
(false, false) => cx
.dcx()
.span_bug(self.span, "a struct with named and unnamed fields in generic `derive`"),
// named fields
(_, false) => Named(named_idents),
// unnamed fields
@ -1489,7 +1489,7 @@ impl<'a> TraitDef<'a> {
let field_pats = pieces_iter
.map(|(sp, ident, pat)| {
if ident.is_none() {
cx.span_bug(
cx.dcx().span_bug(
sp,
"a braced struct with unnamed fields in `derive`",
);
@ -1707,7 +1707,9 @@ where
tag_check_expr
}
}
StaticEnum(..) | StaticStruct(..) => cx.span_bug(trait_span, "static function in `derive`"),
AllFieldlessEnum(..) => cx.span_bug(trait_span, "fieldless enum in `derive`"),
StaticEnum(..) | StaticStruct(..) => {
cx.dcx().span_bug(trait_span, "static function in `derive`")
}
AllFieldlessEnum(..) => cx.dcx().span_bug(trait_span, "fieldless enum in `derive`"),
}
}

4
compiler/rustc_builtin_macros/src/deriving/generic/ty.rs
View File

@ -138,8 +138,8 @@ impl Ty {
cx.path_all(span, false, vec![self_ty], params)
}
Path(p) => p.to_path(cx, span, self_ty, generics),
Ref(..) => cx.span_bug(span, "ref in a path in generic `derive`"),
Unit => cx.span_bug(span, "unit in a path in generic `derive`"),
Ref(..) => cx.dcx().span_bug(span, "ref in a path in generic `derive`"),
Unit => cx.dcx().span_bug(span, "unit in a path in generic `derive`"),
}
}
}

4
compiler/rustc_builtin_macros/src/deriving/hash.rs
View File

@ -52,7 +52,7 @@ fn hash_substructure(
substr: &Substructure<'_>,
) -> BlockOrExpr {
let [state_expr] = substr.nonselflike_args else {
cx.span_bug(trait_span, "incorrect number of arguments in `derive(Hash)`");
cx.dcx().span_bug(trait_span, "incorrect number of arguments in `derive(Hash)`");
};
let call_hash = |span, expr| {
let hash_path = {
@ -75,7 +75,7 @@ fn hash_substructure(
let stmts = thin_vec![call_hash(tag_field.span, tag_field.self_expr.clone())];
(stmts, match_expr.clone())
}
_ => cx.span_bug(trait_span, "impossible substructure in `derive(Hash)`"),
_ => cx.dcx().span_bug(trait_span, "impossible substructure in `derive(Hash)`"),
};
BlockOrExpr::new_mixed(stmts, match_expr)

8
compiler/rustc_builtin_macros/src/env.rs
View File

@ -66,7 +66,7 @@ pub fn expand_env<'cx>(
) -> Box<dyn base::MacResult + 'cx> {
let mut exprs = match get_exprs_from_tts(cx, tts) {
Some(exprs) if exprs.is_empty() || exprs.len() > 2 => {
cx.emit_err(errors::EnvTakesArgs { span: sp });
cx.dcx().emit_err(errors::EnvTakesArgs { span: sp });
return DummyResult::any(sp);
}
None => return DummyResult::any(sp),
@ -101,15 +101,15 @@ pub fn expand_env<'cx>(
};
if let Some(msg_from_user) = custom_msg {
cx.emit_err(errors::EnvNotDefinedWithUserMessage { span, msg_from_user });
cx.dcx().emit_err(errors::EnvNotDefinedWithUserMessage { span, msg_from_user });
} else if is_cargo_env_var(var.as_str()) {
cx.emit_err(errors::EnvNotDefined::CargoEnvVar {
cx.dcx().emit_err(errors::EnvNotDefined::CargoEnvVar {
span,
var: *symbol,
var_expr: var_expr.ast_deref(),
});
} else {
cx.emit_err(errors::EnvNotDefined::CustomEnvVar {
cx.dcx().emit_err(errors::EnvNotDefined::CustomEnvVar {
span,
var: *symbol,
var_expr: var_expr.ast_deref(),

24
compiler/rustc_builtin_macros/src/format.rs
View File

@ -69,7 +69,7 @@ fn parse_args<'a>(ecx: &mut ExtCtxt<'a>, sp: Span, tts: TokenStream) -> PResult<
let mut p = ecx.new_parser_from_tts(tts);
if p.token == token::Eof {
return Err(ecx.create_err(errors::FormatRequiresString { span: sp }));
return Err(ecx.dcx().create_err(errors::FormatRequiresString { span: sp }));
}
let first_token = &p.token;
@ -126,7 +126,7 @@ fn parse_args<'a>(ecx: &mut ExtCtxt<'a>, sp: Span, tts: TokenStream) -> PResult<
p.expect(&token::Eq)?;
let expr = p.parse_expr()?;
if let Some((_, prev)) = args.by_name(ident.name) {
ecx.emit_err(errors::FormatDuplicateArg {
ecx.dcx().emit_err(errors::FormatDuplicateArg {
span: ident.span,
prev: prev.kind.ident().unwrap().span,
duplicate: ident.span,
@ -139,7 +139,7 @@ fn parse_args<'a>(ecx: &mut ExtCtxt<'a>, sp: Span, tts: TokenStream) -> PResult<
_ => {
let expr = p.parse_expr()?;
if !args.named_args().is_empty() {
ecx.emit_err(errors::PositionalAfterNamed {
ecx.dcx().emit_err(errors::PositionalAfterNamed {
span: expr.span,
args: args
.named_args()
@ -293,7 +293,7 @@ fn make_format_args(
}
}
}
ecx.emit_err(e);
ecx.dcx().emit_err(e);
return Err(());
}
@ -351,7 +351,7 @@ fn make_format_args(
} else {
// For the moment capturing variables from format strings expanded from macros is
// disabled (see RFC #2795)
ecx.emit_err(errors::FormatNoArgNamed { span, name });
ecx.dcx().emit_err(errors::FormatNoArgNamed { span, name });
DummyResult::raw_expr(span, true)
};
Ok(args.add(FormatArgument { kind: FormatArgumentKind::Captured(ident), expr }))
@ -529,7 +529,7 @@ fn make_format_args(
// Only check for unused named argument names if there are no other errors to avoid causing
// too much noise in output errors, such as when a named argument is entirely unused.
if invalid_refs.is_empty() && ecx.sess.err_count() == 0 {
if invalid_refs.is_empty() && ecx.dcx().err_count() == 0 {
for &(index, span, used_as) in &numeric_refences_to_named_arg {
let (position_sp_to_replace, position_sp_for_msg) = match used_as {
Placeholder(pspan) => (span, pspan),
@ -585,7 +585,7 @@ fn invalid_placeholder_type_error(
} else {
vec![]
};
ecx.emit_err(errors::FormatUnknownTrait { span: sp.unwrap_or(fmt_span), ty, suggs });
ecx.dcx().emit_err(errors::FormatUnknownTrait { span: sp.unwrap_or(fmt_span), ty, suggs });
}
fn report_missing_placeholders(
@ -600,12 +600,12 @@ fn report_missing_placeholders(
fmt_span: Span,
) {
let mut diag = if let &[(span, named)] = &unused[..] {
ecx.create_err(errors::FormatUnusedArg { span, named })
ecx.dcx().create_err(errors::FormatUnusedArg { span, named })
} else {
let unused_labels =
unused.iter().map(|&(span, named)| errors::FormatUnusedArg { span, named }).collect();
let unused_spans = unused.iter().map(|&(span, _)| span).collect();
ecx.create_err(errors::FormatUnusedArgs {
ecx.dcx().create_err(errors::FormatUnusedArgs {
fmt: fmt_span,
unused: unused_spans,
unused_labels,
@ -776,7 +776,7 @@ fn report_redundant_format_arguments<'a>(
None
};
return Some(ecx.create_err(errors::FormatRedundantArgs {
return Some(ecx.dcx().create_err(errors::FormatRedundantArgs {
n: args_spans.len(),
span: MultiSpan::from(args_spans),
note: multispan,
@ -876,7 +876,7 @@ fn report_invalid_references(
} else {
MultiSpan::from_spans(spans)
};
e = ecx.create_err(errors::FormatPositionalMismatch {
e = ecx.dcx().create_err(errors::FormatPositionalMismatch {
span,
n: num_placeholders,
desc: num_args_desc,
@ -942,7 +942,7 @@ fn report_invalid_references(
head = indexes.into_iter().map(|i| i.to_string()).collect::<Vec<_>>().join(", ")
)
};
e = ecx.struct_span_err(
e = ecx.dcx().struct_span_err(
span,
format!("invalid reference to positional {arg_list} ({num_args_desc})"),
);

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

@ -34,7 +34,7 @@ pub fn expand(
{
(item, true, ecx.with_def_site_ctxt(ty.span))
} else {
ecx.sess.dcx().emit_err(errors::AllocMustStatics { span: item.span() });
ecx.dcx().emit_err(errors::AllocMustStatics { span: item.span() });
return vec![orig_item];
};

8
compiler/rustc_builtin_macros/src/source_util.rs
View File

@ -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.struct_span_err(self.p.token.span, msg).emit();
self.p.dcx().struct_span_err(self.p.token.span, msg).emit();
}
break;
@ -193,12 +193,12 @@ pub fn expand_include_str(
base::MacEager::expr(cx.expr_str(sp, interned_src))
}
Err(_) => {
cx.span_err(sp, format!("{} wasn't a utf-8 file", file.display()));
cx.dcx().span_err(sp, format!("{} wasn't a utf-8 file", file.display()));
DummyResult::any(sp)
}
},
Err(e) => {
cx.span_err(sp, format!("couldn't read {}: {}", file.display(), e));
cx.dcx().span_err(sp, format!("couldn't read {}: {}", file.display(), e));
DummyResult::any(sp)
}
}
@ -226,7 +226,7 @@ pub fn expand_include_bytes(
base::MacEager::expr(expr)
}
Err(e) => {
cx.span_err(sp, format!("couldn't read {}: {}", file.display(), e));
cx.dcx().span_err(sp, format!("couldn't read {}: {}", file.display(), e));
DummyResult::any(sp)
}
}

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

@ -43,7 +43,7 @@ pub fn expand_test_case(
}
}
_ => {
ecx.emit_err(errors::TestCaseNonItem { span: anno_item.span() });
ecx.dcx().emit_err(errors::TestCaseNonItem { span: anno_item.span() });
return vec![];
}
};
@ -389,7 +389,7 @@ pub fn expand_test_or_bench(
}
fn not_testable_error(cx: &ExtCtxt<'_>, attr_sp: Span, item: Option<&ast::Item>) {
let dcx = cx.sess.dcx();
let dcx = cx.dcx();
let msg = "the `#[test]` attribute may only be used on a non-associated function";
let level = match item.map(|i| &i.kind) {
// These were a warning before #92959 and need to continue being that to avoid breaking
@ -465,8 +465,6 @@ fn should_ignore_message(i: &ast::Item) -> Option<Symbol> {
fn should_panic(cx: &ExtCtxt<'_>, i: &ast::Item) -> ShouldPanic {
match attr::find_by_name(&i.attrs, sym::should_panic) {
Some(attr) => {
let dcx = cx.sess.dcx();
match attr.meta_item_list() {
// Handle #[should_panic(expected = "foo")]
Some(list) => {
@ -476,17 +474,18 @@ fn should_panic(cx: &ExtCtxt<'_>, i: &ast::Item) -> ShouldPanic {
.and_then(|mi| mi.meta_item())
.and_then(|mi| mi.value_str());
if list.len() != 1 || msg.is_none() {
dcx.struct_span_warn(
attr.span,
"argument must be of the form: \
cx.dcx()
.struct_span_warn(
attr.span,
"argument must be of the form: \
`expected = \"error message\"`",
)
.note(
"errors in this attribute were erroneously \
)
.note(
"errors in this attribute were erroneously \
allowed and will become a hard error in a \
future release",
)
.emit();
)
.emit();
ShouldPanic::Yes(None)
} else {
ShouldPanic::Yes(msg)
@ -534,7 +533,7 @@ fn check_test_signature(
f: &ast::Fn,
) -> Result<(), ErrorGuaranteed> {
let has_should_panic_attr = attr::contains_name(&i.attrs, sym::should_panic);
let dcx = cx.sess.dcx();
let dcx = cx.dcx();
if let ast::Unsafe::Yes(span) = f.sig.header.unsafety {
return Err(dcx.emit_err(errors::TestBadFn { span: i.span, cause: span, kind: "unsafe" }));
@ -600,7 +599,7 @@ fn check_bench_signature(
// N.B., inadequate check, but we're running
// well before resolve, can't get too deep.
if f.sig.decl.inputs.len() != 1 {
return Err(cx.sess.dcx().emit_err(errors::BenchSig { span: i.span }));
return Err(cx.dcx().emit_err(errors::BenchSig { span: i.span }));
}
Ok(())
}

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

@ -21,7 +21,7 @@ pub fn expand_trace_macros(
};
err |= cursor.next().is_some();
if err {
cx.emit_err(errors::TraceMacros { span: sp });
cx.dcx().emit_err(errors::TraceMacros { span: sp });
} else {
cx.set_trace_macros(value);
}

18
compiler/rustc_codegen_cranelift/src/abi/mod.rs
View File

@ -47,12 +47,12 @@ pub(crate) fn conv_to_call_conv(sess: &Session, c: Conv, default_call_conv: Call
}
Conv::X86Intr | Conv::RiscvInterrupt { .. } => {
sess.fatal(format!("interrupt call conv {c:?} not yet implemented"))
sess.dcx().fatal(format!("interrupt call conv {c:?} not yet implemented"))
}
Conv::ArmAapcs => sess.fatal("aapcs call conv not yet implemented"),
Conv::ArmAapcs => sess.dcx().fatal("aapcs call conv not yet implemented"),
Conv::CCmseNonSecureCall => {
sess.fatal("C-cmse-nonsecure-call call conv is not yet implemented");
sess.dcx().fatal("C-cmse-nonsecure-call call conv is not yet implemented");
}
Conv::Msp430Intr
@ -88,10 +88,10 @@ pub(crate) fn import_function<'tcx>(
let sig = get_function_sig(tcx, module.target_config().default_call_conv, inst);
match module.declare_function(name, Linkage::Import, &sig) {
Ok(func_id) => func_id,
Err(ModuleError::IncompatibleDeclaration(_)) => tcx.sess.fatal(format!(
Err(ModuleError::IncompatibleDeclaration(_)) => tcx.dcx().fatal(format!(
"attempt to declare `{name}` as function, but it was already declared as static"
)),
Err(ModuleError::IncompatibleSignature(_, prev_sig, new_sig)) => tcx.sess.fatal(format!(
Err(ModuleError::IncompatibleSignature(_, prev_sig, new_sig)) => tcx.dcx().fatal(format!(
"attempt to declare `{name}` with signature {new_sig:?}, \
but it was already declared with signature {prev_sig:?}"
)),
@ -181,7 +181,7 @@ fn make_local_place<'tcx>(
is_ssa: bool,
) -> CPlace<'tcx> {
if layout.is_unsized() {
fx.tcx.sess.span_fatal(
fx.tcx.dcx().span_fatal(
fx.mir.local_decls[local].source_info.span,
"unsized locals are not yet supported",
);
@ -226,7 +226,7 @@ pub(crate) fn codegen_fn_prelude<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, start_
// FIXME implement variadics in cranelift
if fn_abi.c_variadic {
fx.tcx.sess.span_fatal(
fx.tcx.dcx().span_fatal(
fx.mir.span,
"Defining variadic functions is not yet supported by Cranelift",
);
@ -543,7 +543,7 @@ pub(crate) fn codegen_terminator_call<'tcx>(
// FIXME find a cleaner way to support varargs
if fn_sig.c_variadic() {
if !matches!(fn_sig.abi(), Abi::C { .. }) {
fx.tcx.sess.span_fatal(
fx.tcx.dcx().span_fatal(
source_info.span,
format!("Variadic call for non-C abi {:?}", fn_sig.abi()),
);
@ -555,7 +555,7 @@ pub(crate) fn codegen_terminator_call<'tcx>(
let ty = fx.bcx.func.dfg.value_type(arg);
if !ty.is_int() {
// FIXME set %al to upperbound on float args once floats are supported
fx.tcx.sess.span_fatal(
fx.tcx.dcx().span_fatal(
source_info.span,
format!("Non int ty {:?} for variadic call", ty),
);

8
compiler/rustc_codegen_cranelift/src/base.rs
View File

@ -236,13 +236,13 @@ pub(crate) fn verify_func(
match cranelift_codegen::verify_function(&func, &flags) {
Ok(_) => {}
Err(err) => {
tcx.sess.err(format!("{:?}", err));
tcx.dcx().err(format!("{:?}", err));
let pretty_error = cranelift_codegen::print_errors::pretty_verifier_error(
&func,
Some(Box::new(writer)),
err,
);
tcx.sess.fatal(format!("cranelift verify error:\n{}", pretty_error));
tcx.dcx().fatal(format!("cranelift verify error:\n{}", pretty_error));
}
}
});
@ -450,7 +450,7 @@ fn codegen_fn_body(fx: &mut FunctionCx<'_, '_, '_>, start_block: Block) {
unwind: _,
} => {
if options.contains(InlineAsmOptions::MAY_UNWIND) {
fx.tcx.sess.span_fatal(
fx.tcx.dcx().span_fatal(
source_info.span,
"cranelift doesn't support unwinding from inline assembly.",
);
@ -812,7 +812,7 @@ fn codegen_stmt<'tcx>(
| StatementKind::PlaceMention(..)
| StatementKind::AscribeUserType(..) => {}
StatementKind::Coverage { .. } => fx.tcx.sess.fatal("-Zcoverage is unimplemented"),
StatementKind::Coverage { .. } => fx.tcx.dcx().fatal("-Zcoverage is unimplemented"),
StatementKind::Intrinsic(ref intrinsic) => match &**intrinsic {
// We ignore `assume` intrinsics, they are only useful for optimizations
NonDivergingIntrinsic::Assume(_) => {}

9
compiler/rustc_codegen_cranelift/src/common.rs
View File

@ -465,9 +465,12 @@ impl<'tcx> LayoutOfHelpers<'tcx> for RevealAllLayoutCx<'tcx> {
#[inline]
fn handle_layout_err(&self, err: LayoutError<'tcx>, span: Span, ty: Ty<'tcx>) -> ! {
if let LayoutError::SizeOverflow(_) | LayoutError::ReferencesError(_) = err {
self.0.sess.span_fatal(span, err.to_string())
self.0.sess.dcx().span_fatal(span, err.to_string())
} else {
self.0.sess.span_fatal(span, format!("failed to get layout for `{}`: {}", ty, err))
self.0
.sess
.dcx()
.span_fatal(span, format!("failed to get layout for `{}`: {}", ty, err))
}
}
}
@ -483,7 +486,7 @@ impl<'tcx> FnAbiOfHelpers<'tcx> for RevealAllLayoutCx<'tcx> {
fn_abi_request: FnAbiRequest<'tcx>,
) -> ! {
if let FnAbiError::Layout(LayoutError::SizeOverflow(_)) = err {
self.0.sess.emit_fatal(Spanned { span, node: err })
self.0.sess.dcx().emit_fatal(Spanned { span, node: err })
} else {
match fn_abi_request {
FnAbiRequest::OfFnPtr { sig, extra_args } => {

8
compiler/rustc_codegen_cranelift/src/constant.rs
View File

@ -263,7 +263,7 @@ fn data_id_for_static(
attrs.flags.contains(CodegenFnAttrFlags::THREAD_LOCAL),
) {
Ok(data_id) => data_id,
Err(ModuleError::IncompatibleDeclaration(_)) => tcx.sess.fatal(format!(
Err(ModuleError::IncompatibleDeclaration(_)) => tcx.dcx().fatal(format!(
"attempt to declare `{symbol_name}` as static, but it was already declared as function"
)),
Err(err) => Err::<_, _>(err).unwrap(),
@ -311,7 +311,7 @@ fn data_id_for_static(
attrs.flags.contains(CodegenFnAttrFlags::THREAD_LOCAL),
) {
Ok(data_id) => data_id,
Err(ModuleError::IncompatibleDeclaration(_)) => tcx.sess.fatal(format!(
Err(ModuleError::IncompatibleDeclaration(_)) => tcx.dcx().fatal(format!(
"attempt to declare `{symbol_name}` as static, but it was already declared as function"
)),
Err(err) => Err::<_, _>(err).unwrap(),
@ -360,7 +360,7 @@ fn define_all_allocs(tcx: TyCtxt<'_>, module: &mut dyn Module, cx: &mut Constant
if let Some(names) = section_name.split_once(',') {
names
} else {
tcx.sess.fatal(format!(
tcx.dcx().fatal(format!(
"#[link_section = \"{}\"] is not valid for macos target: must be segment and section separated by comma",
section_name
));
@ -406,7 +406,7 @@ fn define_all_allocs(tcx: TyCtxt<'_>, module: &mut dyn Module, cx: &mut Constant
GlobalAlloc::Static(def_id) => {
if tcx.codegen_fn_attrs(def_id).flags.contains(CodegenFnAttrFlags::THREAD_LOCAL)
{
tcx.sess.fatal(format!(
tcx.dcx().fatal(format!(
"Allocation {:?} contains reference to TLS value {:?}",
alloc_id, def_id
));

10
compiler/rustc_codegen_cranelift/src/driver/aot.rs
View File

@ -69,7 +69,7 @@ impl OngoingCodegen {
let module_codegen_result = match module_codegen_result {
Ok(module_codegen_result) => module_codegen_result,
Err(err) => sess.fatal(err),
Err(err) => sess.dcx().fatal(err),
};
let ModuleCodegenResult { module_regular, module_global_asm, existing_work_product } =
module_codegen_result;
@ -108,7 +108,7 @@ impl OngoingCodegen {
self.concurrency_limiter.finished();
sess.abort_if_errors();
sess.dcx().abort_if_errors();
(
CodegenResults {
@ -422,7 +422,7 @@ pub(crate) fn run_aot(
backend_config.clone(),
global_asm_config.clone(),
cgu.name(),
concurrency_limiter.acquire(tcx.sess.dcx()),
concurrency_limiter.acquire(tcx.dcx()),
),
module_codegen,
Some(rustc_middle::dep_graph::hash_result),
@ -455,7 +455,7 @@ pub(crate) fn run_aot(
"allocator_shim".to_owned(),
) {
Ok(allocator_module) => Some(allocator_module),
Err(err) => tcx.sess.fatal(err),
Err(err) => tcx.dcx().fatal(err),
}
} else {
None
@ -478,7 +478,7 @@ pub(crate) fn run_aot(
let obj = create_compressed_metadata_file(tcx.sess, &metadata, &symbol_name);
if let Err(err) = std::fs::write(&tmp_file, obj) {
tcx.sess.fatal(format!("error writing metadata object file: {}", err));
tcx.dcx().fatal(format!("error writing metadata object file: {}", err));
}
(metadata_cgu_name, tmp_file)

12
compiler/rustc_codegen_cranelift/src/driver/jit.rs
View File

@ -94,11 +94,11 @@ fn create_jit_module(
pub(crate) fn run_jit(tcx: TyCtxt<'_>, backend_config: BackendConfig) -> ! {
if !tcx.sess.opts.output_types.should_codegen() {
tcx.sess.fatal("JIT mode doesn't work with `cargo check`");
tcx.dcx().fatal("JIT mode doesn't work with `cargo check`");
}
if !tcx.crate_types().contains(&rustc_session::config::CrateType::Executable) {
tcx.sess.fatal("can't jit non-executable crate");
tcx.dcx().fatal("can't jit non-executable crate");
}
let (mut jit_module, mut cx) = create_jit_module(
@ -141,17 +141,17 @@ pub(crate) fn run_jit(tcx: TyCtxt<'_>, backend_config: BackendConfig) -> ! {
}
MonoItem::GlobalAsm(item_id) => {
let item = tcx.hir().item(item_id);
tcx.sess.span_fatal(item.span, "Global asm is not supported in JIT mode");
tcx.dcx().span_fatal(item.span, "Global asm is not supported in JIT mode");
}
}
}
});
if !cx.global_asm.is_empty() {
tcx.sess.fatal("Inline asm is not supported in JIT mode");
tcx.dcx().fatal("Inline asm is not supported in JIT mode");
}
tcx.sess.abort_if_errors();
tcx.dcx().abort_if_errors();
jit_module.finalize_definitions().unwrap();
unsafe { cx.unwind_context.register_jit(&jit_module) };
@ -338,7 +338,7 @@ fn dep_symbol_lookup_fn(
.collect::<Box<[_]>>(),
);
sess.abort_if_errors();
sess.dcx().abort_if_errors();
Box::new(move |sym_name| {
for dylib in &*imported_dylibs {

4
compiler/rustc_codegen_cranelift/src/global_asm.rs
View File

@ -47,7 +47,7 @@ pub(crate) fn codegen_global_asm_item(tcx: TyCtxt<'_>, global_asm: &mut String,
}
InlineAsmOperand::SymFn { anon_const } => {
if cfg!(not(feature = "inline_asm_sym")) {
tcx.sess.span_err(
tcx.dcx().span_err(
item.span,
"asm! and global_asm! sym operands are not yet supported",
);
@ -65,7 +65,7 @@ pub(crate) fn codegen_global_asm_item(tcx: TyCtxt<'_>, global_asm: &mut String,
}
InlineAsmOperand::SymStatic { path: _, def_id } => {
if cfg!(not(feature = "inline_asm_sym")) {
tcx.sess.span_err(
tcx.dcx().span_err(
item.span,
"asm! and global_asm! sym operands are not yet supported",
);

6
compiler/rustc_codegen_cranelift/src/inline_asm.rs
View File

@ -84,7 +84,7 @@ pub(crate) fn codegen_inline_asm_terminator<'tcx>(
InlineAsmOperand::SymFn { ref value } => {
if cfg!(not(feature = "inline_asm_sym")) {
fx.tcx
.sess
.dcx()
.span_err(span, "asm! and global_asm! sym operands are not yet supported");
}
@ -455,7 +455,7 @@ impl<'tcx> InlineAssemblyGenerator<'_, 'tcx> {
}
_ => self
.tcx
.sess
.dcx()
.fatal(format!("Unsupported binary format for inline asm: {binary_format:?}")),
}
@ -563,7 +563,7 @@ impl<'tcx> InlineAssemblyGenerator<'_, 'tcx> {
BinaryFormat::Macho | BinaryFormat::Coff => {}
_ => self
.tcx
.sess
.dcx()
.fatal(format!("Unsupported binary format for inline asm: {binary_format:?}")),
}

2
compiler/rustc_codegen_cranelift/src/intrinsics/llvm.rs
View File

@ -68,7 +68,7 @@ pub(crate) fn codegen_llvm_intrinsic_call<'tcx>(
_ => {
fx.tcx
.sess
.dcx()
.warn(format!("unsupported llvm intrinsic {}; replacing with trap", intrinsic));
crate::trap::trap_unimplemented(fx, intrinsic);
return;

2
compiler/rustc_codegen_cranelift/src/intrinsics/llvm_aarch64.rs
View File

@ -309,7 +309,7 @@ pub(crate) fn codegen_aarch64_llvm_intrinsic_call<'tcx>(
}
*/
_ => {
fx.tcx.sess.warn(format!(
fx.tcx.dcx().warn(format!(
"unsupported AArch64 llvm intrinsic {}; replacing with trap",
intrinsic
));

14
compiler/rustc_codegen_cranelift/src/intrinsics/llvm_x86.rs
View File

@ -960,7 +960,9 @@ pub(crate) fn codegen_x86_llvm_intrinsic_call<'tcx>(
{
imm8
} else {
fx.tcx.sess.span_fatal(span, "Index argument for `_mm_cmpestri` is not a constant");
fx.tcx
.dcx()
.span_fatal(span, "Index argument for `_mm_cmpestri` is not a constant");
};
let imm8 = imm8.try_to_u8().unwrap_or_else(|_| panic!("kind not scalar: {:?}", imm8));
@ -1011,7 +1013,9 @@ pub(crate) fn codegen_x86_llvm_intrinsic_call<'tcx>(
{
imm8
} else {
fx.tcx.sess.span_fatal(span, "Index argument for `_mm_cmpestrm` is not a constant");
fx.tcx
.dcx()
.span_fatal(span, "Index argument for `_mm_cmpestrm` is not a constant");
};
let imm8 = imm8.try_to_u8().unwrap_or_else(|_| panic!("kind not scalar: {:?}", imm8));
@ -1056,7 +1060,7 @@ pub(crate) fn codegen_x86_llvm_intrinsic_call<'tcx>(
{
imm8
} else {
fx.tcx.sess.span_fatal(
fx.tcx.dcx().span_fatal(
span,
"Index argument for `_mm_clmulepi64_si128` is not a constant",
);
@ -1093,7 +1097,7 @@ pub(crate) fn codegen_x86_llvm_intrinsic_call<'tcx>(
{
imm8
} else {
fx.tcx.sess.span_fatal(
fx.tcx.dcx().span_fatal(
span,
"Index argument for `_mm_aeskeygenassist_si128` is not a constant",
);
@ -1361,7 +1365,7 @@ pub(crate) fn codegen_x86_llvm_intrinsic_call<'tcx>(
_ => {
fx.tcx
.sess
.dcx()
.warn(format!("unsupported x86 llvm intrinsic {}; replacing with trap", intrinsic));
crate::trap::trap_unimplemented(fx, intrinsic);
return;

10
compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
View File

@ -37,7 +37,7 @@ fn report_atomic_type_validation_error<'tcx>(
span: Span,
ty: Ty<'tcx>,
) {
fx.tcx.sess.span_err(
fx.tcx.dcx().span_err(
span,
format!(
"`{}` intrinsic: expected basic integer or raw pointer type, found `{:?}`",
@ -785,7 +785,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
return;
} else {
fx.tcx
.sess
.dcx()
.span_fatal(source_info.span, "128bit atomics not yet supported");
}
}
@ -816,7 +816,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
return;
} else {
fx.tcx
.sess
.dcx()
.span_fatal(source_info.span, "128bit atomics not yet supported");
}
}
@ -1245,7 +1245,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
// FIXME implement variadics in cranelift
sym::va_copy | sym::va_arg | sym::va_end => {
fx.tcx.sess.span_fatal(
fx.tcx.dcx().span_fatal(
source_info.span,
"Defining variadic functions is not yet supported by Cranelift",
);
@ -1253,7 +1253,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
_ => {
fx.tcx
.sess
.dcx()
.span_fatal(source_info.span, format!("unsupported intrinsic {}", intrinsic));
}
}

18
compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
View File

@ -12,7 +12,7 @@ fn report_simd_type_validation_error(
span: Span,
ty: Ty<'_>,
) {
fx.tcx.sess.span_err(span, format!("invalid monomorphization of `{}` intrinsic: expected SIMD input type, found non-SIMD `{}`", intrinsic, ty));
fx.tcx.dcx().span_err(span, format!("invalid monomorphization of `{}` intrinsic: expected SIMD input type, found non-SIMD `{}`", intrinsic, ty));
// Prevent verifier error
fx.bcx.ins().trap(TrapCode::UnreachableCodeReached);
}
@ -192,7 +192,7 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
.try_into()
.unwrap(),
_ => {
fx.tcx.sess.span_err(
fx.tcx.dcx().span_err(
span,
format!("simd_shuffle index must be an array of `u32`, got `{}`", idx_ty),
);
@ -278,7 +278,7 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
{
idx_const
} else {
fx.tcx.sess.span_fatal(span, "Index argument for `simd_insert` is not a constant");
fx.tcx.dcx().span_fatal(span, "Index argument for `simd_insert` is not a constant");
};
let idx: u32 = idx_const
@ -286,7 +286,7 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
.unwrap_or_else(|_| panic!("kind not scalar: {:?}", idx_const));
let (lane_count, _lane_ty) = base.layout().ty.simd_size_and_type(fx.tcx);
if u64::from(idx) >= lane_count {
fx.tcx.sess.span_fatal(
fx.tcx.dcx().span_fatal(
fx.mir.span,
format!("[simd_insert] idx {} >= lane_count {}", idx, lane_count),
);
@ -316,7 +316,7 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
{
idx_const
} else {
fx.tcx.sess.span_warn(span, "Index argument for `simd_extract` is not a constant");
fx.tcx.dcx().span_warn(span, "Index argument for `simd_extract` is not a constant");
let trap_block = fx.bcx.create_block();
let true_ = fx.bcx.ins().iconst(types::I8, 1);
let ret_block = fx.get_block(target);
@ -334,7 +334,7 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
.unwrap_or_else(|_| panic!("kind not scalar: {:?}", idx_const));
let (lane_count, _lane_ty) = v.layout().ty.simd_size_and_type(fx.tcx);
if u64::from(idx) >= lane_count {
fx.tcx.sess.span_fatal(
fx.tcx.dcx().span_fatal(
fx.mir.span,
format!("[simd_extract] idx {} >= lane_count {}", idx, lane_count),
);
@ -859,7 +859,7 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
match lane_ty.kind() {
ty::Int(_) | ty::Uint(_) => {}
_ => {
fx.tcx.sess.span_fatal(
fx.tcx.dcx().span_fatal(
span,
format!(
"invalid monomorphization of `simd_bitmask` intrinsic: \
@ -899,7 +899,7 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
&& len.try_eval_target_usize(fx.tcx, ty::ParamEnv::reveal_all())
== Some(expected_bytes) => {}
_ => {
fx.tcx.sess.span_fatal(
fx.tcx.dcx().span_fatal(
span,
format!(
"invalid monomorphization of `simd_bitmask` intrinsic: \
@ -1117,7 +1117,7 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
}
_ => {
fx.tcx.sess.span_err(span, format!("Unknown SIMD intrinsic {}", intrinsic));
fx.tcx.dcx().span_err(span, format!("Unknown SIMD intrinsic {}", intrinsic));
// Prevent verifier error
fx.bcx.ins().trap(TrapCode::UnreachableCodeReached);
return;

21
compiler/rustc_codegen_cranelift/src/lib.rs
View File

@ -177,13 +177,15 @@ impl CodegenBackend for CraneliftCodegenBackend {
use rustc_session::config::Lto;
match sess.lto() {
Lto::No | Lto::ThinLocal => {}
Lto::Thin | Lto::Fat => sess.warn("LTO is not supported. You may get a linker error."),
Lto::Thin | Lto::Fat => {
sess.dcx().warn("LTO is not supported. You may get a linker error.")
}
}
let mut config = self.config.borrow_mut();
if config.is_none() {
let new_config = BackendConfig::from_opts(&sess.opts.cg.llvm_args)
.unwrap_or_else(|err| sess.fatal(err));
.unwrap_or_else(|err| sess.dcx().fatal(err));
*config = Some(new_config);
}
}
@ -202,7 +204,7 @@ impl CodegenBackend for CraneliftCodegenBackend {
metadata: EncodedMetadata,
need_metadata_module: bool,
) -> Box<dyn Any> {
tcx.sess.abort_if_errors();
tcx.dcx().abort_if_errors();
let config = self.config.borrow().clone().unwrap();
match config.codegen_mode {
CodegenMode::Aot => driver::aot::run_aot(tcx, config, metadata, need_metadata_module),
@ -211,7 +213,7 @@ impl CodegenBackend for CraneliftCodegenBackend {
driver::jit::run_jit(tcx, config);
#[cfg(not(feature = "jit"))]
tcx.sess.fatal("jit support was disabled when compiling rustc_codegen_cranelift");
tcx.dcx().fatal("jit support was disabled when compiling rustc_codegen_cranelift");
}
}
}
@ -243,7 +245,7 @@ impl CodegenBackend for CraneliftCodegenBackend {
fn target_triple(sess: &Session) -> target_lexicon::Triple {
match sess.target.llvm_target.parse() {
Ok(triple) => triple,
Err(err) => sess.fatal(format!("target not recognized: {}", err)),
Err(err) => sess.dcx().fatal(format!("target not recognized: {}", err)),
}
}
@ -310,17 +312,18 @@ fn build_isa(sess: &Session, backend_config: &BackendConfig) -> Arc<dyn isa::Tar
Some(value) => {
let mut builder =
cranelift_codegen::isa::lookup(target_triple.clone()).unwrap_or_else(|err| {
sess.fatal(format!("can't compile for {}: {}", target_triple, err));
sess.dcx().fatal(format!("can't compile for {}: {}", target_triple, err));
});
if let Err(_) = builder.enable(value) {
sess.fatal("the specified target cpu isn't currently supported by Cranelift.");
sess.dcx()
.fatal("the specified target cpu isn't currently supported by Cranelift.");
}
builder
}
None => {
let mut builder =
cranelift_codegen::isa::lookup(target_triple.clone()).unwrap_or_else(|err| {
sess.fatal(format!("can't compile for {}: {}", target_triple, err));
sess.dcx().fatal(format!("can't compile for {}: {}", target_triple, err));
});
if target_triple.architecture == target_lexicon::Architecture::X86_64 {
// Don't use "haswell" as the default, as it implies `has_lzcnt`.
@ -333,7 +336,7 @@ fn build_isa(sess: &Session, backend_config: &BackendConfig) -> Arc<dyn isa::Tar
match isa_builder.finish(flags) {
Ok(target_isa) => target_isa,
Err(err) => sess.fatal(format!("failed to build TargetIsa: {}", err)),
Err(err) => sess.dcx().fatal(format!("failed to build TargetIsa: {}", err)),
}
}

4
compiler/rustc_codegen_cranelift/src/main_shim.rs
View File

@ -74,7 +74,7 @@ pub(crate) fn maybe_create_entry_wrapper(
let cmain_func_id = match m.declare_function(entry_name, Linkage::Export, &cmain_sig) {
Ok(func_id) => func_id,
Err(err) => {
tcx.sess
tcx.dcx()
.fatal(format!("entry symbol `{entry_name}` declared multiple times: {err}"));
}
};
@ -171,7 +171,7 @@ pub(crate) fn maybe_create_entry_wrapper(
}
if let Err(err) = m.define_function(cmain_func_id, &mut ctx) {
tcx.sess.fatal(format!("entry symbol `{entry_name}` defined multiple times: {err}"));
tcx.dcx().fatal(format!("entry symbol `{entry_name}` defined multiple times: {err}"));
}
unwind_context.add_function(cmain_func_id, &ctx, m.isa());

2
compiler/rustc_codegen_cranelift/src/value_and_place.rs
View File

@ -397,7 +397,7 @@ impl<'tcx> CPlace<'tcx> {
if layout.size.bytes() >= u64::from(u32::MAX - 16) {
fx.tcx
.sess
.dcx()
.fatal(format!("values of type {} are too big to store on the stack", layout.ty));
}

2
compiler/rustc_codegen_gcc/src/asm.rs
View File

@ -109,7 +109,7 @@ enum ConstraintOrRegister {
impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
fn codegen_inline_asm(&mut self, template: &[InlineAsmTemplatePiece], rust_operands: &[InlineAsmOperandRef<'tcx, Self>], options: InlineAsmOptions, span: &[Span], instance: Instance<'_>, _dest_catch_funclet: Option<(Self::BasicBlock, Self::BasicBlock, Option<&Self::Funclet>)>) {
if options.contains(InlineAsmOptions::MAY_UNWIND) {
self.sess()
self.sess().dcx()
.create_err(UnwindingInlineAsm { span: span[0] })
.emit();
return;

2
compiler/rustc_codegen_gcc/src/attributes.rs
View File

@ -80,7 +80,7 @@ pub fn from_fn_attrs<'gcc, 'tcx>(
let span = cx.tcx
.get_attr(instance.def_id(), sym::target_feature)
.map_or_else(|| cx.tcx.def_span(instance.def_id()), |a| a.span);
cx.tcx.sess.create_err(TiedTargetFeatures {
cx.tcx.dcx().create_err(TiedTargetFeatures {
features: features.join(", "),
span,
})

2
compiler/rustc_codegen_gcc/src/consts.rs
View File

@ -24,7 +24,7 @@ fn set_global_alignment<'gcc, 'tcx>(cx: &CodegenCx<'gcc, 'tcx>, gv: LValue<'gcc>
match Align::from_bits(min) {
Ok(min) => align = align.max(min),
Err(err) => {
cx.sess().emit_err(InvalidMinimumAlignment { err: err.to_string() });
cx.sess().dcx().emit_err(InvalidMinimumAlignment { err: err.to_string() });
}
}
}

6
compiler/rustc_codegen_gcc/src/context.rs
View File

@ -500,9 +500,9 @@ impl<'gcc, 'tcx> LayoutOfHelpers<'tcx> for CodegenCx<'gcc, 'tcx> {
#[inline]
fn handle_layout_err(&self, err: LayoutError<'tcx>, span: Span, ty: Ty<'tcx>) -> ! {
if let LayoutError::SizeOverflow(_) | LayoutError::ReferencesError(_) = err {
self.sess().emit_fatal(respan(span, err.into_diagnostic()))
self.tcx.dcx().emit_fatal(respan(span, err.into_diagnostic()))
} else {
self.tcx.sess.emit_fatal(ssa_errors::FailedToGetLayout { span, ty, err })
self.tcx.dcx().emit_fatal(ssa_errors::FailedToGetLayout { span, ty, err })
}
}
}
@ -518,7 +518,7 @@ impl<'gcc, 'tcx> FnAbiOfHelpers<'tcx> for CodegenCx<'gcc, 'tcx> {
fn_abi_request: FnAbiRequest<'tcx>,
) -> ! {
if let FnAbiError::Layout(LayoutError::SizeOverflow(_)) = err {
self.sess().emit_fatal(respan(span, err))
self.tcx.dcx().emit_fatal(respan(span, err))
} else {
match fn_abi_request {
FnAbiRequest::OfFnPtr { sig, extra_args } => {

6
compiler/rustc_codegen_gcc/src/gcc_util.rs
View File

@ -52,7 +52,7 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri
Some(c @ ('+' | '-')) => c,
Some(_) => {
if diagnostics {
sess.emit_warning(UnknownCTargetFeaturePrefix { feature: s });
sess.dcx().emit_warning(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.emit_warning(unknown_feature);
sess.dcx().emit_warning(unknown_feature);
}
if diagnostics {
@ -114,7 +114,7 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri
if diagnostics {
if let Some(f) = check_tied_features(sess, &featsmap) {
sess.emit_err(TargetFeatureDisableOrEnable {
sess.dcx().emit_err(TargetFeatureDisableOrEnable {
features: f,
span: None,
missing_features: None,

2
compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
View File

@ -262,7 +262,7 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
_ => bug!(),
},
None => {
tcx.sess.emit_err(InvalidMonomorphization::BasicIntegerType { span, name, ty });
tcx.dcx().emit_err(InvalidMonomorphization::BasicIntegerType { span, name, ty });
return;
}
}

4
compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
View File

@ -34,7 +34,7 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
// macros for error handling:
macro_rules! return_error {
($err:expr) => {{
bx.sess().emit_err($err);
bx.tcx.dcx().emit_err($err);
return Err(());
}};
}
@ -390,7 +390,7 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
) -> Result<RValue<'gcc>, ()> {
macro_rules! return_error {
($err:expr) => {{
bx.sess().emit_err($err);
bx.tcx.dcx().emit_err($err);
return Err(());
}};
}

2
compiler/rustc_codegen_gcc/src/lib.rs
View File

@ -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.emit_warning(LTONotSupported {});
sess.dcx().emit_warning(LTONotSupported {});
}
#[cfg(not(feature="master"))]

4
compiler/rustc_codegen_llvm/src/attributes.rs
View File

@ -82,7 +82,7 @@ pub fn sanitize_attrs<'ll>(
let mte_feature =
features.iter().map(|s| &s[..]).rfind(|n| ["+mte", "-mte"].contains(&&n[..]));
if let None | Some("-mte") = mte_feature {
cx.tcx.sess.emit_err(SanitizerMemtagRequiresMte);
cx.tcx.dcx().emit_err(SanitizerMemtagRequiresMte);
}
attrs.push(llvm::AttributeKind::SanitizeMemTag.create_attr(cx.llcx));
@ -444,7 +444,7 @@ pub fn from_fn_attrs<'ll, 'tcx>(
.next()
.map_or_else(|| cx.tcx.def_span(instance.def_id()), |a| a.span);
cx.tcx
.sess
.dcx()
.create_err(TargetFeatureDisableOrEnable {
features: f,
span: Some(span),

12
compiler/rustc_codegen_llvm/src/back/archive.rs
View File

@ -99,7 +99,7 @@ impl<'a> ArchiveBuilder<'a> for LlvmArchiveBuilder<'a> {
fn build(mut self: Box<Self>, output: &Path) -> bool {
match self.build_with_llvm(output) {
Ok(any_members) => any_members,
Err(e) => self.sess.emit_fatal(ArchiveBuildFailure { error: e }),
Err(e) => self.sess.dcx().emit_fatal(ArchiveBuildFailure { error: e }),
}
}
}
@ -175,7 +175,7 @@ impl ArchiveBuilderBuilder for LlvmArchiveBuilderBuilder {
match std::fs::write(&def_file_path, def_file_content) {
Ok(_) => {}
Err(e) => {
sess.emit_fatal(ErrorWritingDEFFile { error: e });
sess.dcx().emit_fatal(ErrorWritingDEFFile { error: e });
}
};
@ -217,14 +217,14 @@ impl ArchiveBuilderBuilder for LlvmArchiveBuilderBuilder {
match dlltool_cmd.output() {
Err(e) => {
sess.emit_fatal(ErrorCallingDllTool {
sess.dcx().emit_fatal(ErrorCallingDllTool {
dlltool_path: dlltool.to_string_lossy(),
error: e,
});
}
// dlltool returns '0' on failure, so check for error output instead.
Ok(output) if !output.stderr.is_empty() => {
sess.emit_fatal(DlltoolFailImportLibrary {
sess.dcx().emit_fatal(DlltoolFailImportLibrary {
dlltool_path: dlltool.to_string_lossy(),
dlltool_args: dlltool_cmd
.get_args()
@ -282,7 +282,7 @@ impl ArchiveBuilderBuilder for LlvmArchiveBuilderBuilder {
};
if result == crate::llvm::LLVMRustResult::Failure {
sess.emit_fatal(ErrorCreatingImportLibrary {
sess.dcx().emit_fatal(ErrorCreatingImportLibrary {
lib_name,
error: llvm::last_error().unwrap_or("unknown LLVM error".to_string()),
});
@ -354,7 +354,7 @@ impl<'a> LlvmArchiveBuilder<'a> {
let kind = kind
.parse::<ArchiveKind>()
.map_err(|_| kind)
.unwrap_or_else(|kind| self.sess.emit_fatal(UnknownArchiveKind { kind }));
.unwrap_or_else(|kind| self.sess.dcx().emit_fatal(UnknownArchiveKind { kind }));
let mut additions = mem::take(&mut self.additions);
let mut strings = Vec::new();

6
compiler/rustc_codegen_llvm/src/back/write.rs
View File

@ -126,7 +126,7 @@ pub fn create_target_machine(tcx: TyCtxt<'_>, mod_name: &str) -> OwnedTargetMach
tcx.backend_optimization_level(()),
tcx.global_backend_features(()),
)(config)
.unwrap_or_else(|err| llvm_err(tcx.sess.dcx(), err).raise())
.unwrap_or_else(|err| llvm_err(tcx.dcx(), err).raise())
}
pub fn to_llvm_opt_settings(
@ -245,12 +245,12 @@ pub fn target_machine_factory(
match sess.opts.debuginfo_compression {
rustc_session::config::DebugInfoCompression::Zlib => {
if !unsafe { LLVMRustLLVMHasZlibCompressionForDebugSymbols() } {
sess.emit_warning(UnknownCompression { algorithm: "zlib" });
sess.dcx().emit_warning(UnknownCompression { algorithm: "zlib" });
}
}
rustc_session::config::DebugInfoCompression::Zstd => {
if !unsafe { LLVMRustLLVMHasZstdCompressionForDebugSymbols() } {
sess.emit_warning(UnknownCompression { algorithm: "zstd" });
sess.dcx().emit_warning(UnknownCompression { algorithm: "zstd" });
}
}
rustc_session::config::DebugInfoCompression::None => {}

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

@ -131,10 +131,10 @@ fn set_global_alignment<'ll>(cx: &CodegenCx<'ll, '_>, gv: &'ll Value, mut align:
Ok(min) => align = align.max(min),
Err(err) => match err {
AlignFromBytesError::NotPowerOfTwo(align) => {
cx.sess().emit_err(InvalidMinimumAlignmentNotPowerOfTwo { align });
cx.sess().dcx().emit_err(InvalidMinimumAlignmentNotPowerOfTwo { align });
}
AlignFromBytesError::TooLarge(align) => {
cx.sess().emit_err(InvalidMinimumAlignmentTooLarge { align });
cx.sess().dcx().emit_err(InvalidMinimumAlignmentTooLarge { align });
}
},
}
@ -169,7 +169,7 @@ fn check_and_apply_linkage<'ll, 'tcx>(
let mut real_name = "_rust_extern_with_linkage_".to_string();
real_name.push_str(sym);
let g2 = cx.define_global(&real_name, llty).unwrap_or_else(|| {
cx.sess().emit_fatal(SymbolAlreadyDefined {
cx.sess().dcx().emit_fatal(SymbolAlreadyDefined {
span: cx.tcx.def_span(def_id),
symbol_name: sym,
})

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

@ -1014,9 +1014,9 @@ impl<'tcx> LayoutOfHelpers<'tcx> for CodegenCx<'_, 'tcx> {
#[inline]
fn handle_layout_err(&self, err: LayoutError<'tcx>, span: Span, ty: Ty<'tcx>) -> ! {
if let LayoutError::SizeOverflow(_) | LayoutError::ReferencesError(_) = err {
self.sess().emit_fatal(Spanned { span, node: err.into_diagnostic() })
self.tcx.dcx().emit_fatal(Spanned { span, node: err.into_diagnostic() })
} else {
self.tcx.sess.emit_fatal(ssa_errors::FailedToGetLayout { span, ty, err })
self.tcx.dcx().emit_fatal(ssa_errors::FailedToGetLayout { span, ty, err })
}
}
}
@ -1032,7 +1032,7 @@ impl<'tcx> FnAbiOfHelpers<'tcx> for CodegenCx<'_, 'tcx> {
fn_abi_request: FnAbiRequest<'tcx>,
) -> ! {
if let FnAbiError::Layout(LayoutError::SizeOverflow(_)) = err {
self.sess().emit_fatal(Spanned { span, node: err })
self.tcx.dcx().emit_fatal(Spanned { span, node: err })
} else {
match fn_abi_request {
FnAbiRequest::OfFnPtr { sig, extra_args } => {

34
compiler/rustc_codegen_llvm/src/intrinsic.rs
View File

@ -285,7 +285,7 @@ impl<'ll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'_, 'll, 'tcx> {
_ => bug!(),
},
None => {
tcx.sess.emit_err(InvalidMonomorphization::BasicIntegerType {
tcx.dcx().emit_err(InvalidMonomorphization::BasicIntegerType {
span,
name,
ty,
@ -921,7 +921,7 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
) -> Result<&'ll Value, ()> {
macro_rules! return_error {
($diag: expr) => {{
bx.sess().emit_err($diag);
bx.sess().dcx().emit_err($diag);
return Err(());
}};
}
@ -1059,7 +1059,7 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
.map(|(arg_idx, val)| {
let idx = val.unwrap_leaf().try_to_i32().unwrap();
if idx >= i32::try_from(total_len).unwrap() {
bx.sess().emit_err(InvalidMonomorphization::ShuffleIndexOutOfBounds {
bx.sess().dcx().emit_err(InvalidMonomorphization::ShuffleIndexOutOfBounds {
span,
name,
arg_idx: arg_idx as u64,
@ -1118,20 +1118,24 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
let val = bx.const_get_elt(vector, i as u64);
match bx.const_to_opt_u128(val, true) {
None => {
bx.sess().emit_err(InvalidMonomorphization::ShuffleIndexNotConstant {
span,
name,
arg_idx,
});
bx.sess().dcx().emit_err(
InvalidMonomorphization::ShuffleIndexNotConstant {
span,
name,
arg_idx,
},
);
None
}
Some(idx) if idx >= total_len => {
bx.sess().emit_err(InvalidMonomorphization::ShuffleIndexOutOfBounds {
span,
name,
arg_idx,
total_len,
});
bx.sess().dcx().emit_err(
InvalidMonomorphization::ShuffleIndexOutOfBounds {
span,
name,
arg_idx,
total_len,
},
);
None
}
Some(idx) => Some(bx.const_i32(idx as i32)),
@ -1276,7 +1280,7 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
) -> Result<&'ll Value, ()> {
macro_rules! return_error {
($diag: expr) => {{
bx.sess().emit_err($diag);
bx.sess().dcx().emit_err($diag);
return Err(());
}};
}

8
compiler/rustc_codegen_llvm/src/llvm_util.rs
View File

@ -529,7 +529,7 @@ pub(crate) fn global_llvm_features(sess: &Session, diagnostics: bool) -> Vec<Str
Some(c @ ('+' | '-')) => c,
Some(_) => {
if diagnostics {
sess.emit_warning(UnknownCTargetFeaturePrefix { feature: s });
sess.dcx().emit_warning(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.emit_warning(unknown_feature);
sess.dcx().emit_warning(unknown_feature);
} else if feature_state
.is_some_and(|(_name, feature_gate)| !feature_gate.is_stable())
{
// An unstable feature. Warn about using it.
sess.emit_warning(UnstableCTargetFeature { feature });
sess.dcx().emit_warning(UnstableCTargetFeature { feature });
}
}
@ -598,7 +598,7 @@ pub(crate) fn global_llvm_features(sess: &Session, diagnostics: bool) -> Vec<Str
features.extend(feats);
if diagnostics && let Some(f) = check_tied_features(sess, &featsmap) {
sess.emit_err(TargetFeatureDisableOrEnable {
sess.dcx().emit_err(TargetFeatureDisableOrEnable {
features: f,
span: None,
missing_features: None,

1
compiler/rustc_codegen_llvm/src/mono_item.rs
View File

@ -26,6 +26,7 @@ impl<'tcx> PreDefineMethods<'tcx> for CodegenCx<'_, 'tcx> {
let g = self.define_global(symbol_name, llty).unwrap_or_else(|| {
self.sess()
.dcx()
.emit_fatal(SymbolAlreadyDefined { span: self.tcx.def_span(def_id), symbol_name })
});

16
compiler/rustc_codegen_ssa/src/assert_module_sources.rs
View File

@ -88,7 +88,7 @@ impl<'tcx> AssertModuleSource<'tcx> {
sym::any => (CguReuse::PreLto, ComparisonKind::AtLeast),
other => {
self.tcx
.sess
.dcx()
.emit_fatal(errors::UnknownReuseKind { span: attr.span, kind: other });
}
}
@ -97,7 +97,7 @@ impl<'tcx> AssertModuleSource<'tcx> {
};
if !self.tcx.sess.opts.unstable_opts.query_dep_graph {
self.tcx.sess.emit_fatal(errors::MissingQueryDepGraph { span: attr.span });
self.tcx.dcx().emit_fatal(errors::MissingQueryDepGraph { span: attr.span });
}
if !self.check_config(attr) {
@ -109,7 +109,7 @@ impl<'tcx> AssertModuleSource<'tcx> {
let crate_name = self.tcx.crate_name(LOCAL_CRATE).to_string();
if !user_path.starts_with(&crate_name) {
self.tcx.sess.emit_fatal(errors::MalformedCguName {
self.tcx.dcx().emit_fatal(errors::MalformedCguName {
span: attr.span,
user_path,
crate_name,
@ -139,7 +139,7 @@ impl<'tcx> AssertModuleSource<'tcx> {
if !self.available_cgus.contains(&cgu_name) {
let cgu_names: Vec<&str> =
self.available_cgus.items().map(|cgu| cgu.as_str()).into_sorted_stable_ord();
self.tcx.sess.emit_err(errors::NoModuleNamed {
self.tcx.dcx().emit_err(errors::NoModuleNamed {
span: attr.span,
user_path,
cgu_name,
@ -162,7 +162,7 @@ impl<'tcx> AssertModuleSource<'tcx> {
if let Some(value) = item.value_str() {
return value;
} else {
self.tcx.sess.emit_fatal(errors::FieldAssociatedValueExpected {
self.tcx.dcx().emit_fatal(errors::FieldAssociatedValueExpected {
span: item.span(),
name,
});
@ -170,7 +170,7 @@ impl<'tcx> AssertModuleSource<'tcx> {
}
}
self.tcx.sess.emit_fatal(errors::NoField { span: attr.span, name });
self.tcx.dcx().emit_fatal(errors::NoField { span: attr.span, name });
}
/// Scan for a `cfg="foo"` attribute and check whether we have a
@ -278,7 +278,7 @@ impl CguReuseTracker {
if error {
let at_least = if at_least { 1 } else { 0 };
sess.emit_err(errors::IncorrectCguReuseType {
sess.dcx().emit_err(errors::IncorrectCguReuseType {
span: *error_span,
cgu_user_name,
actual_reuse,
@ -287,7 +287,7 @@ impl CguReuseTracker {
});
}
} else {
sess.emit_fatal(errors::CguNotRecorded { cgu_user_name, cgu_name });
sess.dcx().emit_fatal(errors::CguNotRecorded { cgu_user_name, cgu_name });
}
}
}

4
compiler/rustc_codegen_ssa/src/back/archive.rs
View File

@ -220,7 +220,7 @@ impl<'a> ArchiveBuilder<'a> for ArArchiveBuilder<'a> {
let sess = self.sess;
match self.build_inner(output) {
Ok(any_members) => any_members,
Err(e) => sess.emit_fatal(ArchiveBuildFailure { error: e }),
Err(e) => sess.dcx().emit_fatal(ArchiveBuildFailure { error: e }),
}
}
}
@ -234,7 +234,7 @@ impl<'a> ArArchiveBuilder<'a> {
"coff" => ArchiveKind::Coff,
"aix_big" => ArchiveKind::AixBig,
kind => {
self.sess.emit_fatal(UnknownArchiveKind { kind });
self.sess.dcx().emit_fatal(UnknownArchiveKind { kind });
}
};

88
compiler/rustc_codegen_ssa/src/back/link.rs
View File

@ -98,7 +98,7 @@ pub fn link_binary<'a>(
let tmpdir = TempFileBuilder::new()
.prefix("rustc")
.tempdir()
.unwrap_or_else(|error| sess.emit_fatal(errors::CreateTempDir { error }));
.unwrap_or_else(|error| sess.dcx().emit_fatal(errors::CreateTempDir { error }));
let path = MaybeTempDir::new(tmpdir, sess.opts.cg.save_temps);
let output = out_filename(
sess,
@ -161,11 +161,11 @@ pub fn link_binary<'a>(
if output.is_stdout() {
if output.is_tty() {
sess.emit_err(errors::BinaryOutputToTty {
sess.dcx().emit_err(errors::BinaryOutputToTty {
shorthand: OutputType::Exe.shorthand(),
});
} else if let Err(e) = copy_to_stdout(&out_filename) {
sess.emit_err(errors::CopyPath::new(&out_filename, output.as_path(), e));
sess.dcx().emit_err(errors::CopyPath::new(&out_filename, output.as_path(), e));
}
tempfiles_for_stdout_output.push(out_filename);
}
@ -380,8 +380,8 @@ fn link_rlib<'a>(
&& let Some(filename) = lib.filename
{
let path = find_native_static_library(filename.as_str(), true, &lib_search_paths, sess);
let src =
read(path).map_err(|e| sess.emit_fatal(errors::ReadFileError { message: e }))?;
let src = read(path)
.map_err(|e| sess.dcx().emit_fatal(errors::ReadFileError { message: e }))?;
let (data, _) = create_wrapper_file(sess, b".bundled_lib".to_vec(), &src);
let wrapper_file = emit_wrapper_file(sess, &data, tmpdir, filename.as_str());
packed_bundled_libs.push(wrapper_file);
@ -393,7 +393,7 @@ fn link_rlib<'a>(
sess,
);
ab.add_archive(&path, Box::new(|_| false)).unwrap_or_else(|error| {
sess.emit_fatal(errors::AddNativeLibrary { library_path: path, error })
sess.dcx().emit_fatal(errors::AddNativeLibrary { library_path: path, error })
});
}
}
@ -410,7 +410,7 @@ fn link_rlib<'a>(
);
ab.add_archive(&output_path, Box::new(|_| false)).unwrap_or_else(|error| {
sess.emit_fatal(errors::AddNativeLibrary { library_path: output_path, error });
sess.dcx().emit_fatal(errors::AddNativeLibrary { library_path: output_path, error });
});
}
@ -475,7 +475,7 @@ fn collate_raw_dylibs<'a, 'b>(
// FIXME: when we add support for ordinals, figure out if we need to do anything
// if we have two DllImport values with the same name but different ordinals.
if import.calling_convention != old_import.calling_convention {
sess.emit_err(errors::MultipleExternalFuncDecl {
sess.dcx().emit_err(errors::MultipleExternalFuncDecl {
span: import.span,
function: import.name,
library_name: &name,
@ -558,7 +558,7 @@ fn link_staticlib<'a>(
archive_builder_builder
.extract_bundled_libs(path, tempdir.as_ref(), &relevant_libs)
.unwrap_or_else(|e| sess.emit_fatal(e));
.unwrap_or_else(|e| sess.dcx().emit_fatal(e));
for filename in relevant_libs {
let joined = tempdir.as_ref().join(filename.as_str());
let path = joined.as_path();
@ -570,7 +570,7 @@ fn link_staticlib<'a>(
},
);
if let Err(e) = res {
sess.emit_fatal(e);
sess.dcx().emit_fatal(e);
}
ab.build(out_filename);
@ -596,9 +596,9 @@ fn link_staticlib<'a>(
all_rust_dylibs.push(&**path);
} else {
if used_crate_source.rmeta.is_some() {
sess.emit_fatal(errors::LinkRlibError::OnlyRmetaFound { crate_name });
sess.dcx().emit_fatal(errors::LinkRlibError::OnlyRmetaFound { crate_name });
} else {
sess.emit_fatal(errors::LinkRlibError::NotFound { crate_name });
sess.dcx().emit_fatal(errors::LinkRlibError::NotFound { crate_name });
}
}
}
@ -715,8 +715,8 @@ fn link_dwarf_object<'a>(
}) {
Ok(()) => {}
Err(e) => {
sess.emit_err(errors::ThorinErrorWrapper(e));
sess.abort_if_errors();
sess.dcx().emit_err(errors::ThorinErrorWrapper(e));
sess.dcx().abort_if_errors();
}
}
}
@ -765,7 +765,7 @@ fn link_natively<'a>(
}
// May have not found libraries in the right formats.
sess.abort_if_errors();
sess.dcx().abort_if_errors();
// Invoke the system linker
info!("{:?}", &cmd);
@ -955,22 +955,22 @@ fn link_natively<'a>(
)
.is_some();
sess.emit_note(errors::LinkExeUnexpectedError);
sess.dcx().emit_note(errors::LinkExeUnexpectedError);
if is_vs_installed && has_linker {
// the linker is broken
sess.emit_note(errors::RepairVSBuildTools);
sess.emit_note(errors::MissingCppBuildToolComponent);
sess.dcx().emit_note(errors::RepairVSBuildTools);
sess.dcx().emit_note(errors::MissingCppBuildToolComponent);
} else if is_vs_installed {
// the linker is not installed
sess.emit_note(errors::SelectCppBuildToolWorkload);
sess.dcx().emit_note(errors::SelectCppBuildToolWorkload);
} else {
// visual studio is not installed
sess.emit_note(errors::VisualStudioNotInstalled);
sess.dcx().emit_note(errors::VisualStudioNotInstalled);
}
}
}
sess.abort_if_errors();
sess.dcx().abort_if_errors();
}
info!("linker stderr:\n{}", escape_string(&prog.stderr));
info!("linker stdout:\n{}", escape_string(&prog.stdout));
@ -979,9 +979,9 @@ fn link_natively<'a>(
let linker_not_found = e.kind() == io::ErrorKind::NotFound;
if linker_not_found {
sess.emit_err(errors::LinkerNotFound { linker_path, error: e });
sess.dcx().emit_err(errors::LinkerNotFound { linker_path, error: e });
} else {
sess.emit_err(errors::UnableToExeLinker {
sess.dcx().emit_err(errors::UnableToExeLinker {
linker_path,
error: e,
command_formatted: format!("{:?}", &cmd),
@ -989,11 +989,11 @@ fn link_natively<'a>(
}
if sess.target.is_like_msvc && linker_not_found {
sess.emit_note(errors::MsvcMissingLinker);
sess.emit_note(errors::CheckInstalledVisualStudio);
sess.emit_note(errors::InsufficientVSCodeProduct);
sess.dcx().emit_note(errors::MsvcMissingLinker);
sess.dcx().emit_note(errors::CheckInstalledVisualStudio);
sess.dcx().emit_note(errors::InsufficientVSCodeProduct);
}
sess.abort_if_errors();
sess.dcx().abort_if_errors();
}
}
@ -1016,13 +1016,13 @@ fn link_natively<'a>(
if !prog.status.success() {
let mut output = prog.stderr.clone();
output.extend_from_slice(&prog.stdout);
sess.emit_warning(errors::ProcessingDymutilFailed {
sess.dcx().emit_warning(errors::ProcessingDymutilFailed {
status: prog.status,
output: escape_string(&output),
});
}
}
Err(error) => sess.emit_fatal(errors::UnableToRunDsymutil { error }),
Err(error) => sess.dcx().emit_fatal(errors::UnableToRunDsymutil { error }),
}
}
@ -1091,14 +1091,14 @@ fn strip_symbols_with_external_utility<'a>(
if !prog.status.success() {
let mut output = prog.stderr.clone();
output.extend_from_slice(&prog.stdout);
sess.emit_warning(errors::StrippingDebugInfoFailed {
sess.dcx().emit_warning(errors::StrippingDebugInfoFailed {
util,
status: prog.status,
output: escape_string(&output),
});
}
}
Err(error) => sess.emit_fatal(errors::UnableToRun { util, error }),
Err(error) => sess.dcx().emit_fatal(errors::UnableToRun { util, error }),
}
}
@ -1311,7 +1311,7 @@ pub fn linker_and_flavor(sess: &Session) -> (PathBuf, LinkerFlavor) {
)),
(Some(linker), None) => {
let stem = linker.file_stem().and_then(|stem| stem.to_str()).unwrap_or_else(|| {
sess.emit_fatal(errors::LinkerFileStem);
sess.dcx().emit_fatal(errors::LinkerFileStem);
});
let flavor = sess.target.linker_flavor.with_linker_hints(stem);
Some((linker, flavor))
@ -1456,15 +1456,15 @@ fn print_native_static_libs(
OutFileName::Real(path) => {
out.overwrite(&lib_args.join(" "), sess);
if !lib_args.is_empty() {
sess.emit_note(errors::StaticLibraryNativeArtifactsToFile { path });
sess.dcx().emit_note(errors::StaticLibraryNativeArtifactsToFile { path });
}
}
OutFileName::Stdout => {
if !lib_args.is_empty() {
sess.emit_note(errors::StaticLibraryNativeArtifacts);
sess.dcx().emit_note(errors::StaticLibraryNativeArtifacts);
// Prefix for greppability
// Note: This must not be translated as tools are allowed to depend on this exact string.
sess.note(format!("native-static-libs: {}", &lib_args.join(" ")));
sess.dcx().note(format!("native-static-libs: {}", &lib_args.join(" ")));
}
}
}
@ -1703,7 +1703,7 @@ fn self_contained_components(sess: &Session, crate_type: CrateType) -> LinkSelfC
// Emit an error if the user requested self-contained mode on the CLI but the target
// explicitly refuses it.
if sess.target.link_self_contained.is_disabled() {
sess.emit_err(errors::UnsupportedLinkSelfContained);
sess.dcx().emit_err(errors::UnsupportedLinkSelfContained);
}
self_contained
} else {
@ -1790,14 +1790,14 @@ fn add_link_script(cmd: &mut dyn Linker, sess: &Session, tmpdir: &Path, crate_ty
match (crate_type, &sess.target.link_script) {
(CrateType::Cdylib | CrateType::Executable, Some(script)) => {
if !sess.target.linker_flavor.is_gnu() {
sess.emit_fatal(errors::LinkScriptUnavailable);
sess.dcx().emit_fatal(errors::LinkScriptUnavailable);
}
let file_name = ["rustc", &sess.target.llvm_target, "linkfile.ld"].join("-");
let path = tmpdir.join(file_name);
if let Err(error) = fs::write(&path, script.as_ref()) {
sess.emit_fatal(errors::LinkScriptWriteFailure { path, error });
sess.dcx().emit_fatal(errors::LinkScriptWriteFailure { path, error });
}
cmd.arg("--script");
@ -1921,7 +1921,7 @@ fn add_linked_symbol_object(
let path = tmpdir.join("symbols.o");
let result = std::fs::write(&path, file.write().unwrap());
if let Err(error) = result {
sess.emit_fatal(errors::FailedToWrite { path, error });
sess.dcx().emit_fatal(errors::FailedToWrite { path, error });
}
cmd.add_object(&path);
}
@ -2390,7 +2390,7 @@ fn collect_natvis_visualizers(
visualizer_paths.push(visualizer_out_file);
}
Err(error) => {
sess.emit_warning(errors::UnableToWriteDebuggerVisualizer {
sess.dcx().emit_warning(errors::UnableToWriteDebuggerVisualizer {
path: visualizer_out_file,
error,
});
@ -2425,7 +2425,7 @@ fn add_native_libs_from_crate(
let rlib = &codegen_results.crate_info.used_crate_source[&cnum].rlib.as_ref().unwrap().0;
archive_builder_builder
.extract_bundled_libs(rlib, tmpdir, bundled_libs)
.unwrap_or_else(|e| sess.emit_fatal(e));
.unwrap_or_else(|e| sess.dcx().emit_fatal(e));
}
let native_libs = match cnum {
@ -2798,7 +2798,7 @@ fn add_static_crate<'a>(
false
}),
) {
sess.emit_fatal(errors::RlibArchiveBuildFailure { error });
sess.dcx().emit_fatal(errors::RlibArchiveBuildFailure { error });
}
if archive.build(&dst) {
link_upstream(&dst);
@ -2872,14 +2872,14 @@ fn add_apple_sdk(cmd: &mut dyn Linker, sess: &Session, flavor: LinkerFlavor) {
("arm", "watchos") => "watchos",
(_, "macos") => "macosx",
_ => {
sess.emit_err(errors::UnsupportedArch { arch, os });
sess.dcx().emit_err(errors::UnsupportedArch { arch, os });
return;
}
};
let sdk_root = match get_apple_sdk_root(sdk_name) {
Ok(s) => s,
Err(e) => {
sess.emit_err(e);
sess.dcx().emit_err(e);
return;
}
};

22
compiler/rustc_codegen_ssa/src/back/linker.rs
View File

@ -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.emit_warning(errors::Ld64UnimplementedModifier);
self.sess.dcx().emit_warning(errors::Ld64UnimplementedModifier);
} else if self.is_gnu && !self.sess.target.is_like_windows {
self.linker_arg("--no-as-needed");
} else {
self.sess.emit_warning(errors::LinkerUnsupportedModifier);
self.sess.dcx().emit_warning(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.emit_warning(errors::Ld64UnimplementedModifier);
self.sess.dcx().emit_warning(errors::Ld64UnimplementedModifier);
}
self.cmd.arg("-framework").arg(framework);
}
@ -693,7 +693,7 @@ impl<'a> Linker for GccLinker<'a> {
}
};
if let Err(error) = res {
self.sess.emit_fatal(errors::LibDefWriteFailure { error });
self.sess.dcx().emit_fatal(errors::LibDefWriteFailure { error });
}
} else if is_windows {
let res: io::Result<()> = try {
@ -708,7 +708,7 @@ impl<'a> Linker for GccLinker<'a> {
}
};
if let Err(error) = res {
self.sess.emit_fatal(errors::LibDefWriteFailure { error });
self.sess.dcx().emit_fatal(errors::LibDefWriteFailure { error });
}
} else {
// Write an LD version script
@ -725,7 +725,7 @@ impl<'a> Linker for GccLinker<'a> {
writeln!(f, "\n local:\n *;\n}};")?;
};
if let Err(error) = res {
self.sess.emit_fatal(errors::VersionScriptWriteFailure { error });
self.sess.dcx().emit_fatal(errors::VersionScriptWriteFailure { error });
}
}
@ -950,7 +950,7 @@ impl<'a> Linker for MsvcLinker<'a> {
}
}
Err(error) => {
self.sess.emit_warning(errors::NoNatvisDirectory { error });
self.sess.dcx().emit_warning(errors::NoNatvisDirectory { error });
}
}
}
@ -1005,7 +1005,7 @@ impl<'a> Linker for MsvcLinker<'a> {
}
};
if let Err(error) = res {
self.sess.emit_fatal(errors::LibDefWriteFailure { error });
self.sess.dcx().emit_fatal(errors::LibDefWriteFailure { error });
}
let mut arg = OsString::from("/DEF:");
arg.push(path);
@ -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.emit_warning(errors::L4BenderExportingSymbolsUnimplemented);
self.sess.dcx().emit_warning(errors::L4BenderExportingSymbolsUnimplemented);
return;
}
@ -1688,7 +1688,7 @@ impl<'a> Linker for AixLinker<'a> {
}
};
if let Err(e) = res {
self.sess.fatal(format!("failed to write export file: {e}"));
self.sess.dcx().fatal(format!("failed to write export file: {e}"));
}
self.cmd.arg(format!("-bE:{}", path.to_str().unwrap()));
}
@ -1995,7 +1995,7 @@ impl<'a> Linker for BpfLinker<'a> {
}
};
if let Err(error) = res {
self.sess.emit_fatal(errors::SymbolFileWriteFailure { error });
self.sess.dcx().emit_fatal(errors::SymbolFileWriteFailure { error });
} else {
self.cmd.arg("--export-symbols").arg(&path);
}

21
compiler/rustc_codegen_ssa/src/back/write.rs
View File

@ -534,12 +534,12 @@ fn produce_final_output_artifacts(
let copy_gracefully = |from: &Path, to: &OutFileName| match to {
OutFileName::Stdout => {
if let Err(e) = copy_to_stdout(from) {
sess.emit_err(errors::CopyPath::new(from, to.as_path(), e));
sess.dcx().emit_err(errors::CopyPath::new(from, to.as_path(), e));
}
}
OutFileName::Real(path) => {
if let Err(e) = fs::copy(from, path) {
sess.emit_err(errors::CopyPath::new(from, path, e));
sess.dcx().emit_err(errors::CopyPath::new(from, path, e));
}
}
};
@ -552,7 +552,8 @@ fn produce_final_output_artifacts(
let path = crate_output.temp_path(output_type, module_name);
let output = crate_output.path(output_type);
if !output_type.is_text_output() && output.is_tty() {
sess.emit_err(errors::BinaryOutputToTty { shorthand: output_type.shorthand() });
sess.dcx()
.emit_err(errors::BinaryOutputToTty { shorthand: output_type.shorthand() });
} else {
copy_gracefully(&path, &output);
}
@ -572,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.emit_warning(errors::IgnoringEmitPath { extension });
sess.dcx().emit_warning(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.emit_warning(errors::IgnoringOutput { extension });
sess.dcx().emit_warning(errors::IgnoringOutput { extension });
} else {
// 4) Multiple codegen units, but no explicit name. We
// just leave the `foo.0.x` files in place.
@ -1079,7 +1080,7 @@ fn start_executing_work<B: ExtraBackendMethods>(
let result = fs::create_dir_all(dir).and_then(|_| dir.canonicalize());
match result {
Ok(dir) => Some(dir),
Err(error) => sess.emit_fatal(ErrorCreatingRemarkDir { error }),
Err(error) => sess.dcx().emit_fatal(ErrorCreatingRemarkDir { error }),
}
} else {
None
@ -1882,10 +1883,10 @@ impl SharedEmitterMain {
err.emit();
}
Ok(SharedEmitterMessage::AbortIfErrors) => {
sess.abort_if_errors();
sess.dcx().abort_if_errors();
}
Ok(SharedEmitterMessage::Fatal(msg)) => {
sess.fatal(msg);
sess.dcx().fatal(msg);
}
Err(_) => {
break;
@ -1938,7 +1939,7 @@ impl<B: ExtraBackendMethods> OngoingCodegen<B> {
let compiled_modules = sess.time("join_worker_thread", || match self.coordinator.join() {
Ok(Ok(compiled_modules)) => compiled_modules,
Ok(Err(())) => {
sess.abort_if_errors();
sess.dcx().abort_if_errors();
panic!("expected abort due to worker thread errors")
}
Err(_) => {
@ -1946,7 +1947,7 @@ impl<B: ExtraBackendMethods> OngoingCodegen<B> {
}
});
sess.abort_if_errors();
sess.dcx().abort_if_errors();
let work_products =
copy_all_cgu_workproducts_to_incr_comp_cache_dir(sess, &compiled_modules);

11
compiler/rustc_codegen_ssa/src/base.rs
View File

@ -448,8 +448,9 @@ pub fn maybe_create_entry_wrapper<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
let Some(llfn) = cx.declare_c_main(llfty) else {
// FIXME: We should be smart and show a better diagnostic here.
let span = cx.tcx().def_span(rust_main_def_id);
cx.sess().emit_err(errors::MultipleMainFunctions { span });
cx.sess().abort_if_errors();
let dcx = cx.tcx().dcx();
dcx.emit_err(errors::MultipleMainFunctions { span });
dcx.abort_if_errors();
bug!();
};
@ -620,7 +621,7 @@ pub fn codegen_crate<B: ExtraBackendMethods>(
&exported_symbols::metadata_symbol_name(tcx),
);
if let Err(error) = std::fs::write(&file_name, data) {
tcx.sess.emit_fatal(errors::MetadataObjectFileWrite { error });
tcx.dcx().emit_fatal(errors::MetadataObjectFileWrite { error });
}
CompiledModule {
name: metadata_cgu_name,
@ -752,7 +753,7 @@ pub fn codegen_crate<B: ExtraBackendMethods>(
// This will unwind if there are errors, which triggers our `AbortCodegenOnDrop`
// guard. Unfortunately, just skipping the `submit_codegened_module_to_llvm` makes
// compilation hang on post-monomorphization errors.
tcx.sess.abort_if_errors();
tcx.dcx().abort_if_errors();
submit_codegened_module_to_llvm(
&backend,
@ -819,7 +820,7 @@ impl CrateInfo {
let subsystem = attr::first_attr_value_str_by_name(crate_attrs, sym::windows_subsystem);
let windows_subsystem = subsystem.map(|subsystem| {
if subsystem != sym::windows && subsystem != sym::console {
tcx.sess.emit_fatal(errors::InvalidWindowsSubsystem { subsystem });
tcx.dcx().emit_fatal(errors::InvalidWindowsSubsystem { subsystem });
}
subsystem.to_string()
});

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

@ -44,7 +44,7 @@ fn linkage_by_name(tcx: TyCtxt<'_>, def_id: LocalDefId, name: &str) -> Linkage {
"private" => Private,
"weak" => WeakAny,
"weak_odr" => WeakODR,
_ => tcx.sess.span_fatal(tcx.def_span(def_id), "invalid linkage specified"),
_ => tcx.dcx().span_fatal(tcx.def_span(def_id), "invalid linkage specified"),
}
}
@ -90,7 +90,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
if let Fn | AssocFn | Variant | Ctor(..) = def_kind {
Some(tcx.fn_sig(did))
} else {
tcx.sess
tcx.dcx()
.span_delayed_bug(attr.span, "this attribute can only be applied to functions");
None
}
@ -119,7 +119,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
if tcx.opt_item_name(did.to_def_id()).is_some() {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::NO_MANGLE
} else {
tcx.sess
tcx.dcx()
.struct_span_err(
attr.span,
format!(
@ -142,7 +142,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
// coverage on a smaller scope within an excluded larger scope.
}
Some(_) | None => {
tcx.sess.emit_err(ExpectedCoverageSymbol { span: attr.span });
tcx.dcx().emit_err(ExpectedCoverageSymbol { span: attr.span });
}
}
}
@ -177,7 +177,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::USED;
}
Some(_) => {
tcx.sess.emit_err(ExpectedUsedSymbol { span: attr.span });
tcx.dcx().emit_err(ExpectedUsedSymbol { span: attr.span });
}
None => {
// Unfortunately, unconditionally using `llvm.used` causes
@ -217,7 +217,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
&& !matches!(fn_sig.skip_binder().abi(), abi::Abi::C { .. })
{
struct_span_err!(
tcx.sess,
tcx.dcx(),
attr.span,
E0776,
"`#[cmse_nonsecure_entry]` requires C ABI"
@ -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.sess, attr.span, E0775, "`#[cmse_nonsecure_entry]` is only valid for targets with the TrustZone-M extension")
struct_span_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
@ -239,7 +239,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
&& fn_sig.skip_binder().abi() != abi::Abi::Rust
{
struct_span_err!(
tcx.sess,
tcx.dcx(),
attr.span,
E0737,
"`#[track_caller]` requires Rust ABI"
@ -266,7 +266,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
// `#[export_name = ...]` will be converted to a null-terminated string,
// so it may not contain any null characters.
struct_span_err!(
tcx.sess,
tcx.dcx(),
attr.span,
E0648,
"`export_name` may not contain null characters"
@ -336,7 +336,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
if let Some(val) = attr.value_str() {
if val.as_str().bytes().any(|b| b == 0) {
let msg = format!("illegal null byte in link_section value: `{}`", &val);
tcx.sess.span_err(attr.span, msg);
tcx.dcx().span_err(attr.span, msg);
} else {
codegen_fn_attrs.link_section = Some(val);
}
@ -370,7 +370,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
codegen_fn_attrs.no_sanitize |= SanitizerSet::HWADDRESS
}
_ => {
tcx.sess.emit_err(errors::InvalidNoSanitize { span: item.span() });
tcx.dcx().emit_err(errors::InvalidNoSanitize { span: item.span() });
}
}
}
@ -386,7 +386,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
[sym::arm, sym::a32] | [sym::arm, sym::t32] => {
if !tcx.sess.target.has_thumb_interworking {
struct_span_err!(
tcx.sess.dcx(),
tcx.dcx(),
attr.span,
E0779,
"target does not support `#[instruction_set]`"
@ -403,7 +403,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
}
_ => {
struct_span_err!(
tcx.sess.dcx(),
tcx.dcx(),
attr.span,
E0779,
"invalid instruction set specified",
@ -415,7 +415,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
}
[] => {
struct_span_err!(
tcx.sess.dcx(),
tcx.dcx(),
attr.span,
E0778,
"`#[instruction_set]` requires an argument"
@ -425,7 +425,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
}
_ => {
struct_span_err!(
tcx.sess.dcx(),
tcx.dcx(),
attr.span,
E0779,
"cannot specify more than one instruction set"
@ -443,7 +443,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
rustc_attr::parse_alignment(&literal.kind)
.map_err(|msg| {
struct_span_err!(
tcx.sess.dcx(),
tcx.dcx(),
attr.span,
E0589,
"invalid `repr(align)` attribute: {}",
@ -469,15 +469,14 @@ 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.sess.dcx(), attr.span, E0534, "expected one argument")
.emit();
struct_span_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.sess.dcx(), items[0].span(), E0535, "invalid argument")
struct_span_err!(tcx.dcx(), items[0].span(), E0535, "invalid argument")
.help("valid inline arguments are `always` and `never`")
.emit();
@ -493,7 +492,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.sess.dcx(), sp, E0722, "{}", s).emit();
let err = |sp, s| struct_span_err!(tcx.dcx(), sp, E0722, "{}", s).emit();
match attr.meta_kind() {
Some(MetaItemKind::Word) => {
err(attr.span, "expected one argument");
@ -550,7 +549,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
if !codegen_fn_attrs.target_features.is_empty() {
if codegen_fn_attrs.inline == InlineAttr::Always {
if let Some(span) = inline_span {
tcx.sess.span_err(
tcx.dcx().span_err(
span,
"cannot use `#[inline(always)]` with \
`#[target_feature]`",
@ -637,7 +636,7 @@ fn check_link_ordinal(tcx: TyCtxt<'_>, attr: &ast::Attribute) -> Option<u16> {
let sole_meta_list = match meta_item_list {
Some([item]) => item.lit(),
Some(_) => {
tcx.sess.emit_err(errors::InvalidLinkOrdinalNargs { span: attr.span });
tcx.dcx().emit_err(errors::InvalidLinkOrdinalNargs { span: attr.span });
return None;
}
_ => None,
@ -661,14 +660,14 @@ fn check_link_ordinal(tcx: TyCtxt<'_>, attr: &ast::Attribute) -> Option<u16> {
Some(*ordinal as u16)
} else {
let msg = format!("ordinal value in `link_ordinal` is too large: `{}`", &ordinal);
tcx.sess
tcx.dcx()
.struct_span_err(attr.span, msg)
.note("the value may not exceed `u16::MAX`")
.emit();
None
}
} else {
tcx.sess.emit_err(errors::InvalidLinkOrdinalFormat { span: attr.span });
tcx.dcx().emit_err(errors::InvalidLinkOrdinalFormat { span: attr.span });
None
}
}
@ -683,9 +682,9 @@ fn check_link_name_xor_ordinal(
}
let msg = "cannot use `#[link_name]` with `#[link_ordinal]`";
if let Some(span) = inline_span {
tcx.sess.span_err(span, msg);
tcx.dcx().span_err(span, msg);
} else {
tcx.sess.err(msg);
tcx.dcx().err(msg);
}
}

2
compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
View File

@ -93,7 +93,7 @@ fn push_debuginfo_type_name<'tcx>(
Err(e) => {
// Computing the layout can still fail here, e.g. if the target architecture
// cannot represent the type. See https://github.com/rust-lang/rust/issues/94961.
tcx.sess.emit_fatal(e.into_diagnostic());
tcx.dcx().emit_fatal(e.into_diagnostic());
}
}
} else {

2
compiler/rustc_codegen_ssa/src/mir/constant.rs
View File

@ -94,7 +94,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
bx.const_struct(&values, false)
})
.unwrap_or_else(|| {
bx.tcx().sess.emit_err(errors::ShuffleIndicesEvaluation { span: constant.span });
bx.tcx().dcx().emit_err(errors::ShuffleIndicesEvaluation { span: constant.span });
// We've errored, so we don't have to produce working code.
let llty = bx.backend_type(bx.layout_of(ty));
bx.const_undef(llty)

18
compiler/rustc_codegen_ssa/src/mir/intrinsic.rs
View File

@ -220,7 +220,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
}
}
None => {
bx.tcx().sess.emit_err(InvalidMonomorphization::BasicIntegerType {
bx.tcx().dcx().emit_err(InvalidMonomorphization::BasicIntegerType {
span,
name,
ty,
@ -240,7 +240,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
_ => bug!(),
},
None => {
bx.tcx().sess.emit_err(InvalidMonomorphization::BasicFloatType {
bx.tcx().dcx().emit_err(InvalidMonomorphization::BasicFloatType {
span,
name,
ty: arg_tys[0],
@ -252,14 +252,14 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
sym::float_to_int_unchecked => {
if float_type_width(arg_tys[0]).is_none() {
bx.tcx().sess.emit_err(InvalidMonomorphization::FloatToIntUnchecked {
bx.tcx().dcx().emit_err(InvalidMonomorphization::FloatToIntUnchecked {
span,
ty: arg_tys[0],
});
return;
}
let Some((_width, signed)) = int_type_width_signed(ret_ty, bx.tcx()) else {
bx.tcx().sess.emit_err(InvalidMonomorphization::FloatToIntUnchecked {
bx.tcx().dcx().emit_err(InvalidMonomorphization::FloatToIntUnchecked {
span,
ty: ret_ty,
});
@ -297,7 +297,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
use crate::common::{AtomicRmwBinOp, SynchronizationScope};
let Some((instruction, ordering)) = atomic.split_once('_') else {
bx.sess().emit_fatal(errors::MissingMemoryOrdering);
bx.sess().dcx().emit_fatal(errors::MissingMemoryOrdering);
};
let parse_ordering = |bx: &Bx, s| match s {
@ -307,11 +307,11 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
"release" => Release,
"acqrel" => AcquireRelease,
"seqcst" => SequentiallyConsistent,
_ => bx.sess().emit_fatal(errors::UnknownAtomicOrdering),
_ => bx.sess().dcx().emit_fatal(errors::UnknownAtomicOrdering),
};
let invalid_monomorphization = |ty| {
bx.tcx().sess.emit_err(InvalidMonomorphization::BasicIntegerType {
bx.tcx().dcx().emit_err(InvalidMonomorphization::BasicIntegerType {
span,
name,
ty,
@ -321,7 +321,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
match instruction {
"cxchg" | "cxchgweak" => {
let Some((success, failure)) = ordering.split_once('_') else {
bx.sess().emit_fatal(errors::AtomicCompareExchange);
bx.sess().dcx().emit_fatal(errors::AtomicCompareExchange);
};
let ty = fn_args.type_at(0);
if int_type_width_signed(ty, bx.tcx()).is_some() || ty.is_unsafe_ptr() {
@ -437,7 +437,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
"min" => AtomicRmwBinOp::AtomicMin,
"umax" => AtomicRmwBinOp::AtomicUMax,
"umin" => AtomicRmwBinOp::AtomicUMin,
_ => bx.sess().emit_fatal(errors::UnknownAtomicOperation),
_ => bx.sess().dcx().emit_fatal(errors::UnknownAtomicOperation),
};
let ty = fn_args.type_at(0);

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

@ -25,7 +25,7 @@ pub fn from_target_feature(
let bad_item = |span| {
let msg = "malformed `target_feature` attribute input";
let code = "enable = \"..\"";
tcx.sess
tcx.dcx()
.struct_span_err(span, msg)
.span_suggestion(span, "must be of the form", code, Applicability::HasPlaceholders)
.emit();
@ -48,7 +48,7 @@ pub fn from_target_feature(
target_features.extend(value.as_str().split(',').filter_map(|feature| {
let Some(feature_gate) = supported_target_features.get(feature) else {
let msg = format!("the feature named `{feature}` is not valid for this target");
let mut err = tcx.sess.struct_span_err(item.span(), msg);
let mut err = tcx.dcx().struct_span_err(item.span(), msg);
err.span_label(item.span(), format!("`{feature}` is not valid for this target"));
if let Some(stripped) = feature.strip_prefix('+') {
let valid = supported_target_features.contains_key(stripped);
@ -121,7 +121,7 @@ pub fn check_target_feature_trait_unsafe(tcx: TyCtxt<'_>, id: LocalDefId, attr_s
if let DefKind::AssocFn = tcx.def_kind(id) {
let parent_id = tcx.local_parent(id);
if let DefKind::Trait | DefKind::Impl { of_trait: true } = tcx.def_kind(parent_id) {
tcx.sess.emit_err(errors::TargetFeatureSafeTrait {
tcx.dcx().emit_err(errors::TargetFeatureSafeTrait {
span: attr_span,
def: tcx.def_span(id),
});

4
compiler/rustc_const_eval/src/const_eval/error.rs
View File

@ -151,10 +151,10 @@ where
let (our_span, frames) = get_span_and_frames();
let span = span.unwrap_or(our_span);
let err = mk(span, frames);
let mut err = tcx.sess.create_err(err);
let mut err = tcx.dcx().create_err(err);
let msg = error.diagnostic_message();
error.add_args(tcx.sess.dcx(), &mut err);
error.add_args(tcx.dcx(), &mut err);
// Use *our* span to label the interp error
err.span_label(our_span, msg);

6
compiler/rustc_const_eval/src/const_eval/machine.rs
View File

@ -391,7 +391,7 @@ 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.sess.span_delayed_bug(
let guar = ecx.tcx.dcx().span_delayed_bug(
rustc_span::DUMMY_SP,
"This is likely a const item that is missing from its impl",
);
@ -621,7 +621,7 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
if is_error {
let guard = ecx
.tcx
.sess
.dcx()
.span_delayed_bug(span, "The deny lint should have already errored");
throw_inval!(AlreadyReported(guard.into()));
}
@ -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.sess.emit_warning(LongRunningWarn { span, item_span: ecx.tcx.span });
ecx.tcx.dcx().emit_warning(LongRunningWarn { span, item_span: ecx.tcx.span });
}
}

2
compiler/rustc_const_eval/src/const_eval/mod.rs
View File

@ -61,7 +61,7 @@ pub(crate) fn eval_to_valtree<'tcx>(
match err {
ValTreeCreationError::NodesOverflow => {
let span = tcx.hir().span_if_local(did);
tcx.sess.emit_err(MaxNumNodesInConstErr { span, global_const_id });
tcx.dcx().emit_err(MaxNumNodesInConstErr { span, global_const_id });
Ok(None)
}

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

@ -439,8 +439,8 @@ pub trait ReportErrorExt {
Self: Sized,
{
ty::tls::with(move |tcx| {
let mut builder = tcx.sess.struct_allow(DiagnosticMessage::Str(String::new().into()));
let dcx = tcx.sess.dcx();
let dcx = tcx.dcx();
let mut builder = dcx.struct_allow(DiagnosticMessage::Str(String::new().into()));
let message = self.diagnostic_message();
self.add_args(dcx, &mut builder);
let s = dcx.eagerly_translate_to_string(message, builder.args());

4
compiler/rustc_const_eval/src/interpret/eval_context.rs
View File

@ -473,9 +473,9 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
backtrace.print_backtrace();
// FIXME(fee1-dead), HACK: we want to use the error as title therefore we can just extract the
// label and arguments from the InterpError.
let dcx = self.tcx.sess.dcx();
let dcx = self.tcx.dcx();
#[allow(rustc::untranslatable_diagnostic)]
let mut diag = self.tcx.sess.struct_allow("");
let mut diag = dcx.struct_allow("");
let msg = e.diagnostic_message();
e.add_args(dcx, &mut diag);
let s = dcx.eagerly_translate_to_string(msg, diag.args());

10
compiler/rustc_const_eval/src/interpret/intern.rs
View File

@ -96,7 +96,7 @@ fn intern_shallow<'rt, 'mir, 'tcx, M: CompileTimeMachine<'mir, 'tcx, const_eval:
// in the value the dangling reference lies.
// The `span_delayed_bug` ensures that we don't forget such a check in validation.
if tcx.try_get_global_alloc(alloc_id).is_none() {
tcx.sess.span_delayed_bug(ecx.tcx.span, "tried to intern dangling pointer");
tcx.dcx().span_delayed_bug(ecx.tcx.span, "tried to intern dangling pointer");
}
// treat dangling pointers like other statics
// just to stop trying to recurse into them
@ -185,7 +185,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: CompileTimeMachine<'mir, 'tcx, const_eval::Memory
} else {
// Validation will error (with a better message) on an invalid vtable pointer.
// Let validation show the error message, but make sure it *does* error.
tcx.sess
tcx.dcx()
.span_delayed_bug(tcx.span, "vtables pointers cannot be integer pointers");
}
}
@ -375,7 +375,7 @@ pub fn intern_const_alloc_recursive<
match res {
Ok(()) => {}
Err(error) => {
ecx.tcx.sess.span_delayed_bug(
ecx.tcx.dcx().span_delayed_bug(
ecx.tcx.span,
format!(
"error during interning should later cause validation failure: {}",
@ -424,7 +424,7 @@ pub fn intern_const_alloc_recursive<
// something that cannot be promoted, which in constants means values that have
// drop glue, such as the example above.
InternKind::Constant => {
ecx.tcx.sess.emit_err(UnsupportedUntypedPointer { span: ecx.tcx.span });
ecx.tcx.dcx().emit_err(UnsupportedUntypedPointer { span: ecx.tcx.span });
// For better errors later, mark the allocation as immutable.
alloc.mutability = Mutability::Not;
}
@ -440,7 +440,7 @@ pub fn intern_const_alloc_recursive<
} else if ecx.memory.dead_alloc_map.contains_key(&alloc_id) {
// Codegen does not like dangling pointers, and generally `tcx` assumes that
// all allocations referenced anywhere actually exist. So, make sure we error here.
let reported = ecx.tcx.sess.emit_err(DanglingPtrInFinal { span: ecx.tcx.span });
let reported = ecx.tcx.dcx().emit_err(DanglingPtrInFinal { span: ecx.tcx.span });
return Err(reported);
} else if ecx.tcx.try_get_global_alloc(alloc_id).is_none() {
// We have hit an `AllocId` that is neither in local or global memory and isn't

10
compiler/rustc_const_eval/src/transform/check_consts/check.rs
View File

@ -244,7 +244,7 @@ impl<'mir, 'tcx> Checker<'mir, 'tcx> {
// `async` functions cannot be `const fn`. This is checked during AST lowering, so there's
// no need to emit duplicate errors here.
if self.ccx.is_async() || body.coroutine.is_some() {
tcx.sess.span_delayed_bug(body.span, "`async` functions cannot be `const fn`");
tcx.dcx().span_delayed_bug(body.span, "`async` functions cannot be `const fn`");
return;
}
@ -276,10 +276,10 @@ impl<'mir, 'tcx> Checker<'mir, 'tcx> {
let secondary_errors = mem::take(&mut self.secondary_errors);
if self.error_emitted.is_none() {
for error in secondary_errors {
self.tcx.sess.dcx().emit_diagnostic(error);
self.tcx.dcx().emit_diagnostic(error);
}
} else {
assert!(self.tcx.sess.has_errors().is_some());
assert!(self.tcx.dcx().has_errors().is_some());
}
}
@ -354,7 +354,7 @@ impl<'mir, 'tcx> Checker<'mir, 'tcx> {
fn check_static(&mut self, def_id: DefId, span: Span) {
if self.tcx.is_thread_local_static(def_id) {
self.tcx
.sess
.dcx()
.span_delayed_bug(span, "tls access is checked in `Rvalue::ThreadLocalRef`");
}
self.check_op_spanned(ops::StaticAccess, span)
@ -994,5 +994,5 @@ fn is_int_bool_or_char(ty: Ty<'_>) -> bool {
fn emit_unstable_in_stable_error(ccx: &ConstCx<'_, '_>, span: Span, gate: Symbol) {
let attr_span = ccx.tcx.def_span(ccx.def_id()).shrink_to_lo();
ccx.tcx.sess.emit_err(UnstableInStable { gate: gate.to_string(), span, attr_span });
ccx.dcx().emit_err(UnstableInStable { gate: gate.to_string(), span, attr_span });
}

Some files were not shown because too many files have changed in this diff Show More