rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

Replace some Option<Span> with Span and use DUMMY_SP instead of None

Browse Source
This commit is contained in:
Oli Scherer
2025-06-04 06:26:56 +00:00
parent 81a964c23e
commit fd3da4bebd
77 changed files with 250 additions and 250 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -732,7 +732,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
span: Span,
args: Option<&'hir hir::GenericArgs<'hir>>,
) -> &'hir hir::Path<'hir> {
let def_id = self.tcx.require_lang_item(lang_item, Some(span));
let def_id = self.tcx.require_lang_item(lang_item, span);
let def_kind = self.tcx.def_kind(def_id);
let res = Res::Def(def_kind, def_id);
self.arena.alloc(hir::Path {

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

@@ -263,7 +263,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
// something that already has `Fn`-like bounds (or is a closure), so we can't
// restrict anyways.
} else {
let copy_did = self.infcx.tcx.require_lang_item(LangItem::Copy, Some(span));
let copy_did = self.infcx.tcx.require_lang_item(LangItem::Copy, span);
self.suggest_adding_bounds(&mut err, ty, copy_did, span);
}
@@ -1915,7 +1915,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
let local_ty = self.body.local_decls[place.local].ty;
let typeck_results = tcx.typeck(self.mir_def_id());
let clone = tcx.require_lang_item(LangItem::Clone, Some(body.span));
let clone = tcx.require_lang_item(LangItem::Clone, body.span);
for expr in expr_finder.clones {
if let hir::ExprKind::MethodCall(_, rcvr, _, span) = expr.kind
&& let Some(rcvr_ty) = typeck_results.node_type_opt(rcvr.hir_id)

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

@@ -688,7 +688,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
if !self.unsized_feature_enabled() {
let trait_ref = ty::TraitRef::new(
tcx,
tcx.require_lang_item(LangItem::Sized, Some(self.last_span)),
tcx.require_lang_item(LangItem::Sized, self.last_span),
[place_ty],
);
self.prove_trait_ref(
@@ -1010,7 +1010,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
let ty = place.ty(self.body, tcx).ty;
let trait_ref = ty::TraitRef::new(
tcx,
tcx.require_lang_item(LangItem::Copy, Some(span)),
tcx.require_lang_item(LangItem::Copy, span),
[ty],
);
@@ -1025,11 +1025,8 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
}
&Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf, ty) => {
let trait_ref = ty::TraitRef::new(
tcx,
tcx.require_lang_item(LangItem::Sized, Some(span)),
[ty],
);
let trait_ref =
ty::TraitRef::new(tcx, tcx.require_lang_item(LangItem::Sized, span), [ty]);
self.prove_trait_ref(
trait_ref,
@@ -1041,11 +1038,8 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
&Rvalue::NullaryOp(NullOp::UbChecks, _) => {}
Rvalue::ShallowInitBox(_operand, ty) => {
let trait_ref = ty::TraitRef::new(
tcx,
tcx.require_lang_item(LangItem::Sized, Some(span)),
[*ty],
);
let trait_ref =
ty::TraitRef::new(tcx, tcx.require_lang_item(LangItem::Sized, span), [*ty]);
self.prove_trait_ref(
trait_ref,
@@ -1222,7 +1216,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
let &ty = ty;
let trait_ref = ty::TraitRef::new(
tcx,
tcx.require_lang_item(LangItem::CoerceUnsized, Some(span)),
tcx.require_lang_item(LangItem::CoerceUnsized, span),
[op.ty(self.body, tcx), ty],
);
@@ -1811,7 +1805,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
if let PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy) = context {
let trait_ref = ty::TraitRef::new(
tcx,
tcx.require_lang_item(LangItem::Copy, Some(self.last_span)),
tcx.require_lang_item(LangItem::Copy, self.last_span),
[place_ty.ty],
);

8
compiler/rustc_borrowck/src/universal_regions.rs
View File

@@ -544,10 +544,10 @@ impl<'cx, 'tcx> UniversalRegionsBuilder<'cx, 'tcx> {
// (as it's created inside the body itself, not passed in from outside).
if let DefiningTy::FnDef(def_id, _) = defining_ty {
if self.infcx.tcx.fn_sig(def_id).skip_binder().c_variadic() {
let va_list_did = self.infcx.tcx.require_lang_item(
LangItem::VaList,
Some(self.infcx.tcx.def_span(self.mir_def)),
);
let va_list_did = self
.infcx
.tcx
.require_lang_item(LangItem::VaList, self.infcx.tcx.def_span(self.mir_def));
let reg_vid = self
.infcx

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

@@ -380,7 +380,7 @@ fn codegen_fn_body(fx: &mut FunctionCx<'_, '_, '_>, start_block: Block) {
rustc_hir::LangItem::PanicBoundsCheck,
&[index, len, location],
*unwind,
Some(source_info.span),
source_info.span,
);
}
AssertKind::MisalignedPointerDereference { ref required, ref found } => {
@@ -393,7 +393,7 @@ fn codegen_fn_body(fx: &mut FunctionCx<'_, '_, '_>, start_block: Block) {
rustc_hir::LangItem::PanicMisalignedPointerDereference,
&[required, found, location],
*unwind,
Some(source_info.span),
source_info.span,
);
}
AssertKind::NullPointerDereference => {
@@ -404,7 +404,7 @@ fn codegen_fn_body(fx: &mut FunctionCx<'_, '_, '_>, start_block: Block) {
rustc_hir::LangItem::PanicNullPointerDereference,
&[location],
*unwind,
Some(source_info.span),
source_info.span,
)
}
_ => {
@@ -415,7 +415,7 @@ fn codegen_fn_body(fx: &mut FunctionCx<'_, '_, '_>, start_block: Block) {
msg.panic_function(),
&[location],
*unwind,
Some(source_info.span),
source_info.span,
);
}
}
@@ -531,7 +531,7 @@ fn codegen_fn_body(fx: &mut FunctionCx<'_, '_, '_>, start_block: Block) {
);
}
TerminatorKind::UnwindTerminate(reason) => {
codegen_unwind_terminate(fx, Some(source_info.span), *reason);
codegen_unwind_terminate(fx, source_info.span, *reason);
}
TerminatorKind::UnwindResume => {
// FIXME implement unwinding
@@ -1074,7 +1074,7 @@ pub(crate) fn codegen_operand<'tcx>(
pub(crate) fn codegen_panic_nounwind<'tcx>(
fx: &mut FunctionCx<'_, '_, 'tcx>,
msg_str: &str,
span: Option<Span>,
span: Span,
) {
let msg_ptr = fx.anonymous_str(msg_str);
let msg_len = fx.bcx.ins().iconst(fx.pointer_type, i64::try_from(msg_str.len()).unwrap());
@@ -1091,7 +1091,7 @@ pub(crate) fn codegen_panic_nounwind<'tcx>(
pub(crate) fn codegen_unwind_terminate<'tcx>(
fx: &mut FunctionCx<'_, '_, 'tcx>,
span: Option<Span>,
span: Span,
reason: UnwindTerminateReason,
) {
codegen_panic_inner(fx, reason.lang_item(), &[], UnwindAction::Unreachable, span);
@@ -1102,7 +1102,7 @@ fn codegen_panic_inner<'tcx>(
lang_item: rustc_hir::LangItem,
args: &[Value],
_unwind: UnwindAction,
span: Option<Span>,
span: Span,
) {
fx.bcx.set_cold_block(fx.bcx.current_block().unwrap());

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

@@ -71,7 +71,7 @@ pub(crate) fn codegen_llvm_intrinsic_call<'tcx>(
See https://github.com/rust-lang/rustc_codegen_cranelift/issues/171\n\
Please open an issue at https://github.com/rust-lang/rustc_codegen_cranelift/issues"
);
crate::base::codegen_panic_nounwind(fx, &msg, None);
crate::base::codegen_panic_nounwind(fx, &msg, span);
return;
}
}

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

@@ -512,7 +512,7 @@ pub(super) fn codegen_aarch64_llvm_intrinsic_call<'tcx>(
See https://github.com/rust-lang/rustc_codegen_cranelift/issues/171\n\
Please open an issue at https://github.com/rust-lang/rustc_codegen_cranelift/issues"
);
crate::base::codegen_panic_nounwind(fx, &msg, None);
crate::base::codegen_panic_nounwind(fx, &msg, fx.mir.span);
return;
}
}

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

@@ -1321,7 +1321,7 @@ pub(super) fn codegen_x86_llvm_intrinsic_call<'tcx>(
See https://github.com/rust-lang/rustc_codegen_cranelift/issues/171\n\
Please open an issue at https://github.com/rust-lang/rustc_codegen_cranelift/issues"
);
crate::base::codegen_panic_nounwind(fx, &msg, None);
crate::base::codegen_panic_nounwind(fx, &msg, span);
return;
}
}

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

@@ -785,7 +785,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
}
})
});
crate::base::codegen_panic_nounwind(fx, &msg_str, Some(source_info.span));
crate::base::codegen_panic_nounwind(fx, &msg_str, source_info.span);
return Ok(());
}
}
@@ -884,7 +884,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
crate::base::codegen_panic_nounwind(
fx,
"128bit atomics not yet supported",
None,
source_info.span,
);
return Ok(());
} else {
@@ -919,7 +919,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
crate::base::codegen_panic_nounwind(
fx,
"128bit atomics not yet supported",
None,
source_info.span,
);
return Ok(());
} else {

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

@@ -101,7 +101,7 @@ pub(crate) fn maybe_create_entry_wrapper(
let call_inst = bcx.ins().call(main_func_ref, &[]);
let call_results = bcx.func.dfg.inst_results(call_inst).to_owned();
let termination_trait = tcx.require_lang_item(LangItem::Termination, None);
let termination_trait = tcx.require_lang_item(LangItem::Termination, DUMMY_SP);
let report = tcx
.associated_items(termination_trait)
.find_by_ident_and_kind(
@@ -136,7 +136,7 @@ pub(crate) fn maybe_create_entry_wrapper(
}
} else {
// Regular main fn invoked via start lang item.
let start_def_id = tcx.require_lang_item(LangItem::Start, None);
let start_def_id = tcx.require_lang_item(LangItem::Start, DUMMY_SP);
let start_instance = Instance::expect_resolve(
tcx,
ty::TypingEnv::fully_monomorphized(),

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

@@ -54,7 +54,7 @@ fn codegen_three_way_compare<'tcx>(
let gt = fx.bcx.ins().icmp(gt_cc, lhs, rhs);
let lt = fx.bcx.ins().icmp(lt_cc, lhs, rhs);
let val = fx.bcx.ins().isub(gt, lt);
CValue::by_val(val, fx.layout_of(fx.tcx.ty_ordering_enum(Some(fx.mir.span))))
CValue::by_val(val, fx.layout_of(fx.tcx.ty_ordering_enum(fx.mir.span)))
}
fn codegen_compare_bin_op<'tcx>(

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

@@ -240,7 +240,7 @@ pub(crate) fn size_and_align_of<'tcx>(
})
});
codegen_panic_nounwind(fx, &msg_str, None);
codegen_panic_nounwind(fx, &msg_str, fx.mir.span);
fx.bcx.switch_to_block(next_block);

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

@@ -561,7 +561,7 @@ pub fn maybe_create_entry_wrapper<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
let EntryFnType::Main { sigpipe } = entry_type;
let (start_fn, start_ty, args, instance) = {
let start_def_id = cx.tcx().require_lang_item(LangItem::Start, None);
let start_def_id = cx.tcx().require_lang_item(LangItem::Start, DUMMY_SP);
let start_instance = ty::Instance::expect_resolve(
cx.tcx(),
cx.typing_env(),

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

@@ -110,7 +110,7 @@ mod temp_stable_hash_impls {
pub(crate) fn build_langcall<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
bx: &Bx,
span: Option<Span>,
span: Span,
li: LangItem,
) -> (Bx::FnAbiOfResult, Bx::Value, Instance<'tcx>) {
let tcx = bx.tcx();

9
compiler/rustc_codegen_ssa/src/mir/block.rs
View File

@@ -783,7 +783,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
}
};
let (fn_abi, llfn, instance) = common::build_langcall(bx, Some(span), lang_item);
let (fn_abi, llfn, instance) = common::build_langcall(bx, span, lang_item);
// Codegen the actual panic invoke/call.
let merging_succ =
@@ -803,7 +803,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
self.set_debug_loc(bx, terminator.source_info);
// Obtain the panic entry point.
let (fn_abi, llfn, instance) = common::build_langcall(bx, Some(span), reason.lang_item());
let (fn_abi, llfn, instance) = common::build_langcall(bx, span, reason.lang_item());
// Codegen the actual panic invoke/call.
let merging_succ = helper.do_call(
@@ -871,7 +871,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
// Obtain the panic entry point.
let (fn_abi, llfn, instance) =
common::build_langcall(bx, Some(source_info.span), LangItem::PanicNounwind);
common::build_langcall(bx, source_info.span, LangItem::PanicNounwind);
// Codegen the actual panic invoke/call.
Some(helper.do_call(
@@ -1830,7 +1830,8 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
self.set_debug_loc(&mut bx, mir::SourceInfo::outermost(self.mir.span));
let (fn_abi, fn_ptr, instance) = common::build_langcall(&bx, None, reason.lang_item());
let (fn_abi, fn_ptr, instance) =
common::build_langcall(&bx, self.mir.span, reason.lang_item());
if is_call_from_compiler_builtins_to_upstream_monomorphization(bx.tcx(), instance) {
bx.abort();
} else {

3
compiler/rustc_codegen_ssa/src/size_of_val.rs
View File

@@ -5,6 +5,7 @@ use rustc_hir::LangItem;
use rustc_middle::bug;
use rustc_middle::ty::print::{with_no_trimmed_paths, with_no_visible_paths};
use rustc_middle::ty::{self, Ty};
use rustc_span::DUMMY_SP;
use tracing::{debug, trace};
use crate::common::IntPredicate;
@@ -62,7 +63,7 @@ pub fn size_and_align_of_dst<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
// Obtain the panic entry point.
let (fn_abi, llfn, _instance) =
common::build_langcall(bx, None, LangItem::PanicNounwind);
common::build_langcall(bx, DUMMY_SP, LangItem::PanicNounwind);
// Generate the call. Cannot use `do_call` since we don't have a MIR terminator so we
// can't create a `TerminationCodegenHelper`. (But we are in good company, this code is

6
compiler/rustc_const_eval/src/check_consts/ops.rs
View File

@@ -345,11 +345,7 @@ fn build_error_for_const_call<'tcx>(
non_or_conditionally,
});
note_trait_if_possible(
&mut err,
self_ty,
tcx.require_lang_item(LangItem::Deref, Some(span)),
);
note_trait_if_possible(&mut err, self_ty, tcx.require_lang_item(LangItem::Deref, span));
err
}
_ if tcx.opt_parent(callee) == tcx.get_diagnostic_item(sym::FmtArgumentsNew) => {

4
compiler/rustc_const_eval/src/check_consts/qualifs.rs
View File

@@ -99,7 +99,7 @@ impl Qualif for HasMutInterior {
// requires borrowck, which in turn will invoke mir_const_qualifs again, causing a cycle error.
// Instead we invoke an obligation context manually, and provide the opaque type inference settings
// that allow the trait solver to just error out instead of cycling.
let freeze_def_id = cx.tcx.require_lang_item(LangItem::Freeze, Some(cx.body.span));
let freeze_def_id = cx.tcx.require_lang_item(LangItem::Freeze, cx.body.span);
// FIXME(#132279): Once we've got a typing mode which reveals opaque types using the HIR
// typeck results without causing query cycles, we should use this here instead of defining
// opaque types.
@@ -180,7 +180,7 @@ impl Qualif for NeedsNonConstDrop {
// that the components of this type are also `~const Destruct`. This
// amounts to verifying that there are no values in this ADT that may have
// a non-const drop.
let destruct_def_id = cx.tcx.require_lang_item(LangItem::Destruct, Some(cx.body.span));
let destruct_def_id = cx.tcx.require_lang_item(LangItem::Destruct, cx.body.span);
let (infcx, param_env) = cx.tcx.infer_ctxt().build_with_typing_env(cx.typing_env);
let ocx = ObligationCtxt::new(&infcx);
ocx.register_obligation(Obligation::new(

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

@@ -249,7 +249,7 @@ impl<'tcx> CompileTimeInterpCx<'tcx> {
return Err(ConstEvalErrKind::Panic { msg, file, line, col }).into();
} else if self.tcx.is_lang_item(def_id, LangItem::PanicFmt) {
// For panic_fmt, call const_panic_fmt instead.
let const_def_id = self.tcx.require_lang_item(LangItem::ConstPanicFmt, None);
let const_def_id = self.tcx.require_lang_item(LangItem::ConstPanicFmt, self.tcx.span);
let new_instance = ty::Instance::expect_resolve(
*self.tcx,
self.typing_env(),

3
compiler/rustc_const_eval/src/interpret/operand.rs
View File

@@ -12,6 +12,7 @@ use rustc_middle::ty::layout::{HasTyCtxt, HasTypingEnv, LayoutOf, TyAndLayout};
use rustc_middle::ty::print::{FmtPrinter, PrettyPrinter};
use rustc_middle::ty::{ConstInt, ScalarInt, Ty, TyCtxt};
use rustc_middle::{bug, mir, span_bug, ty};
use rustc_span::DUMMY_SP;
use tracing::trace;
use super::{
@@ -307,7 +308,7 @@ impl<'tcx, Prov: Provenance> ImmTy<'tcx, Prov> {
#[inline]
pub fn from_ordering(c: std::cmp::Ordering, tcx: TyCtxt<'tcx>) -> Self {
// Can use any typing env, since `Ordering` is always monomorphic.
let ty = tcx.ty_ordering_enum(None);
let ty = tcx.ty_ordering_enum(DUMMY_SP);
let layout =
tcx.layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(ty)).unwrap();
Self::from_scalar(Scalar::Int(c.into()), layout)

2
compiler/rustc_const_eval/src/util/caller_location.rs
View File

@@ -30,7 +30,7 @@ fn alloc_caller_location<'tcx>(
// Allocate memory for `CallerLocation` struct.
let loc_ty = ecx
.tcx
.type_of(ecx.tcx.require_lang_item(LangItem::PanicLocation, None))
.type_of(ecx.tcx.require_lang_item(LangItem::PanicLocation, ecx.tcx.span))
.instantiate(*ecx.tcx, ecx.tcx.mk_args(&[ecx.tcx.lifetimes.re_erased.into()]));
let loc_layout = ecx.layout_of(loc_ty).unwrap();
let location = ecx.allocate(loc_layout, MemoryKind::CallerLocation).unwrap();

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

@@ -97,7 +97,7 @@ fn allowed_union_or_unsafe_field<'tcx>(
let def_id = tcx
.lang_items()
.get(LangItem::BikeshedGuaranteedNoDrop)
.unwrap_or_else(|| tcx.require_lang_item(LangItem::Copy, Some(span)));
.unwrap_or_else(|| tcx.require_lang_item(LangItem::Copy, span));
let Ok(ty) = tcx.try_normalize_erasing_regions(typing_env, ty) else {
tcx.dcx().span_delayed_bug(span, "could not normalize field type");
return true;

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

@@ -180,7 +180,7 @@ pub(crate) fn check_intrinsic_type(
ty::BoundVariableKind::Region(ty::BoundRegionKind::ClosureEnv),
]);
let mk_va_list_ty = |mutbl| {
let did = tcx.require_lang_item(LangItem::VaList, Some(span));
let did = tcx.require_lang_item(LangItem::VaList, span);
let region = ty::Region::new_bound(
tcx,
ty::INNERMOST,
@@ -442,9 +442,7 @@ pub(crate) fn check_intrinsic_type(
sym::bswap | sym::bitreverse => (1, 0, vec![param(0)], param(0)),
sym::three_way_compare => {
(1, 0, vec![param(0), param(0)], tcx.ty_ordering_enum(Some(span)))
}
sym::three_way_compare => (1, 0, vec![param(0), param(0)], tcx.ty_ordering_enum(span)),
sym::add_with_overflow | sym::sub_with_overflow | sym::mul_with_overflow => {
(1, 0, vec![param(0), param(0)], Ty::new_tup(tcx, &[param(0), tcx.types.bool]))
@@ -520,7 +518,7 @@ pub(crate) fn check_intrinsic_type(
sym::discriminant_value => {
let assoc_items = tcx.associated_item_def_ids(
tcx.require_lang_item(hir::LangItem::DiscriminantKind, None),
tcx.require_lang_item(hir::LangItem::DiscriminantKind, span),
);
let discriminant_def_id = assoc_items[0];

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

@@ -969,7 +969,7 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) -> Result<(),
),
wfcx.param_env,
ty,
tcx.require_lang_item(LangItem::UnsizedConstParamTy, Some(hir_ty.span)),
tcx.require_lang_item(LangItem::UnsizedConstParamTy, hir_ty.span),
);
Ok(())
})
@@ -983,7 +983,7 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) -> Result<(),
),
wfcx.param_env,
ty,
tcx.require_lang_item(LangItem::ConstParamTy, Some(hir_ty.span)),
tcx.require_lang_item(LangItem::ConstParamTy, hir_ty.span),
);
Ok(())
})
@@ -1232,7 +1232,7 @@ fn check_type_defn<'tcx>(
),
wfcx.param_env,
ty,
tcx.require_lang_item(LangItem::Sized, Some(hir_ty.span)),
tcx.require_lang_item(LangItem::Sized, hir_ty.span),
);
}
@@ -1356,7 +1356,7 @@ fn check_static_item(
),
wfcx.param_env,
item_ty,
tcx.require_lang_item(LangItem::Sized, Some(ty_span)),
tcx.require_lang_item(LangItem::Sized, ty_span),
);
}
@@ -1375,7 +1375,7 @@ fn check_static_item(
),
wfcx.param_env,
item_ty,
tcx.require_lang_item(LangItem::Sync, Some(ty_span)),
tcx.require_lang_item(LangItem::Sync, ty_span),
);
}
Ok(())
@@ -1401,7 +1401,7 @@ fn check_const_item(
),
wfcx.param_env,
ty,
tcx.require_lang_item(LangItem::Sized, None),
tcx.require_lang_item(LangItem::Sized, ty_span),
);
check_where_clauses(wfcx, item_span, def_id);
@@ -1725,13 +1725,13 @@ fn check_fn_or_method<'tcx>(
ObligationCause::new(span, wfcx.body_def_id, ObligationCauseCode::RustCall),
wfcx.param_env,
*ty,
tcx.require_lang_item(hir::LangItem::Tuple, Some(span)),
tcx.require_lang_item(hir::LangItem::Tuple, span),
);
wfcx.register_bound(
ObligationCause::new(span, wfcx.body_def_id, ObligationCauseCode::RustCall),
wfcx.param_env,
*ty,
tcx.require_lang_item(hir::LangItem::Sized, Some(span)),
tcx.require_lang_item(hir::LangItem::Sized, span),
);
} else {
tcx.dcx().span_err(
@@ -1776,7 +1776,7 @@ fn check_sized_if_body<'tcx>(
ObligationCause::new(span, def_id, code),
wfcx.param_env,
ty,
tcx.require_lang_item(LangItem::Sized, Some(span)),
tcx.require_lang_item(LangItem::Sized, span),
);
}
}
@@ -2013,7 +2013,7 @@ fn receiver_is_valid<'tcx>(
// deref chain implement `LegacyReceiver`.
if arbitrary_self_types_enabled.is_none() {
let legacy_receiver_trait_def_id =
tcx.require_lang_item(LangItem::LegacyReceiver, Some(span));
tcx.require_lang_item(LangItem::LegacyReceiver, span);
if !legacy_receiver_is_implemented(
wfcx,
legacy_receiver_trait_def_id,

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

@@ -225,7 +225,7 @@ fn visit_implementation_of_dispatch_from_dyn(checker: &Checker<'_>) -> Result<()
// redundant errors for `DispatchFromDyn`. This is best effort, though.
let mut res = Ok(());
tcx.for_each_relevant_impl(
tcx.require_lang_item(LangItem::CoerceUnsized, Some(span)),
tcx.require_lang_item(LangItem::CoerceUnsized, span),
source,
|impl_def_id| {
res = res.and(tcx.ensure_ok().coerce_unsized_info(impl_def_id));
@@ -379,8 +379,8 @@ pub(crate) fn coerce_unsized_info<'tcx>(
let span = tcx.def_span(impl_did);
let trait_name = "CoerceUnsized";
let coerce_unsized_trait = tcx.require_lang_item(LangItem::CoerceUnsized, Some(span));
let unsize_trait = tcx.require_lang_item(LangItem::Unsize, Some(span));
let coerce_unsized_trait = tcx.require_lang_item(LangItem::CoerceUnsized, span);
let unsize_trait = tcx.require_lang_item(LangItem::Unsize, span);
let source = tcx.type_of(impl_did).instantiate_identity();
let trait_ref = tcx.impl_trait_ref(impl_did).unwrap().instantiate_identity();
@@ -591,7 +591,7 @@ fn infringing_fields_error<'tcx>(
impl_did: LocalDefId,
impl_span: Span,
) -> ErrorGuaranteed {
let trait_did = tcx.require_lang_item(lang_item, Some(impl_span));
let trait_did = tcx.require_lang_item(lang_item, impl_span);
let trait_name = tcx.def_path_str(trait_did);
@@ -748,7 +748,7 @@ fn visit_implementation_of_pointer_like(checker: &Checker<'_>) -> Result<(), Err
ObligationCause::misc(impl_span, checker.impl_def_id),
param_env,
nontrivial_field_ty,
tcx.require_lang_item(LangItem::PointerLike, Some(impl_span)),
tcx.require_lang_item(LangItem::PointerLike, impl_span),
);
// FIXME(dyn-star): We should regionck this implementation.
if ocx.select_all_or_error().is_empty() {

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

@@ -2590,7 +2590,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
.unwrap_or_else(|guar| Ty::new_error(tcx, guar))
}
&hir::TyKind::Path(hir::QPath::LangItem(lang_item, span)) => {
let def_id = tcx.require_lang_item(lang_item, Some(span));
let def_id = tcx.require_lang_item(lang_item, span);
let (args, _) = self.lower_generic_args_of_path(
span,
def_id,

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

@@ -508,7 +508,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
if let Some(ty) = fn_sig.inputs().last().copied() {
self.register_bound(
ty,
self.tcx.require_lang_item(hir::LangItem::Tuple, Some(sp)),
self.tcx.require_lang_item(hir::LangItem::Tuple, sp),
self.cause(sp, ObligationCauseCode::RustCall),
);
self.require_type_is_sized(ty, sp, ObligationCauseCode::RustCall);

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

@@ -57,7 +57,7 @@ pub(super) fn check_fn<'a, 'tcx>(
// (as it's created inside the body itself, not passed in from outside).
let maybe_va_list = fn_sig.c_variadic.then(|| {
let span = body.params.last().unwrap().span;
let va_list_did = tcx.require_lang_item(LangItem::VaList, Some(span));
let va_list_did = tcx.require_lang_item(LangItem::VaList, span);
let region = fcx.next_region_var(RegionVariableOrigin::MiscVariable(span));
tcx.type_of(va_list_did).instantiate(tcx, &[region.into()])
@@ -178,7 +178,7 @@ fn check_panic_info_fn(tcx: TyCtxt<'_>, fn_id: LocalDefId, fn_sig: ty::FnSig<'_>
tcx.dcx().span_err(span, "should have no const parameters");
}
let panic_info_did = tcx.require_lang_item(hir::LangItem::PanicInfo, Some(span));
let panic_info_did = tcx.require_lang_item(hir::LangItem::PanicInfo, span);
// build type `for<'a, 'b> fn(&'a PanicInfo<'b>) -> !`
let panic_info_ty = tcx.type_of(panic_info_did).instantiate(

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

@@ -142,13 +142,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
Ty::new_adt(
tcx,
tcx.adt_def(
tcx.require_lang_item(hir::LangItem::Poll, Some(expr_span)),
),
tcx.adt_def(tcx.require_lang_item(hir::LangItem::Poll, expr_span)),
tcx.mk_args(&[Ty::new_adt(
tcx,
tcx.adt_def(
tcx.require_lang_item(hir::LangItem::Option, Some(expr_span)),
tcx.require_lang_item(hir::LangItem::Option, expr_span),
),
tcx.mk_args(&[yield_ty.into()]),
)

5
compiler/rustc_hir_typeck/src/coercion.rs
View File

@@ -760,8 +760,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
self.param_env,
ty::TraitRef::new(
self.tcx,
self.tcx
.require_lang_item(hir::LangItem::PointerLike, Some(self.cause.span)),
self.tcx.require_lang_item(hir::LangItem::PointerLike, self.cause.span),
[a],
),
),
@@ -1969,7 +1968,7 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
fcx.param_env,
ty::TraitRef::new(
fcx.tcx,
fcx.tcx.require_lang_item(hir::LangItem::Sized, None),
fcx.tcx.require_lang_item(hir::LangItem::Sized, DUMMY_SP),
[sig.output()],
),
))

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

@@ -1407,7 +1407,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let lhs_deref_ty_is_sized = self
.infcx
.type_implements_trait(
self.tcx.require_lang_item(LangItem::Sized, None),
self.tcx.require_lang_item(LangItem::Sized, span),
[lhs_deref_ty],
self.param_env,
)

6
compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
View File

@@ -409,7 +409,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
code: traits::ObligationCauseCode<'tcx>,
) {
if !ty.references_error() {
let lang_item = self.tcx.require_lang_item(LangItem::Sized, None);
let lang_item = self.tcx.require_lang_item(LangItem::Sized, span);
self.require_type_meets(ty, span, code, lang_item);
}
}
@@ -443,7 +443,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// Nothing else is required here.
} else {
// We can't be sure, let's required full `Sized`.
let lang_item = self.tcx.require_lang_item(LangItem::Sized, None);
let lang_item = self.tcx.require_lang_item(LangItem::Sized, span);
self.require_type_meets(ty, span, ObligationCauseCode::Misc, lang_item);
}
}
@@ -732,7 +732,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
span: Span,
hir_id: HirId,
) -> (Res, Ty<'tcx>) {
let def_id = self.tcx.require_lang_item(lang_item, Some(span));
let def_id = self.tcx.require_lang_item(lang_item, span);
let def_kind = self.tcx.def_kind(def_id);
let item_ty = if let DefKind::Variant = def_kind {

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

@@ -165,7 +165,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
_ => traits::IsConstable::No,
};
let lang_item = self.tcx.require_lang_item(LangItem::Copy, None);
let lang_item = self.tcx.require_lang_item(LangItem::Copy, element.span);
let code = traits::ObligationCauseCode::RepeatElementCopy {
is_constable,
elt_span: element.span,
@@ -1680,8 +1680,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
ast::LitKind::CStr(_, _) => Ty::new_imm_ref(
tcx,
tcx.lifetimes.re_static,
tcx.type_of(tcx.require_lang_item(hir::LangItem::CStr, Some(lit.span)))
.skip_binder(),
tcx.type_of(tcx.require_lang_item(hir::LangItem::CStr, lit.span)).skip_binder(),
),
ast::LitKind::Err(guar) => Ty::new_error(tcx, guar),
}

2
compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
View File

@@ -2679,7 +2679,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let mut sugg_sp = sp;
if let hir::ExprKind::MethodCall(segment, receiver, args, _) = expr.kind {
let clone_trait =
self.tcx.require_lang_item(LangItem::Clone, Some(segment.ident.span));
self.tcx.require_lang_item(LangItem::Clone, segment.ident.span);
if args.is_empty()
&& self
.typeck_results

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

@@ -796,7 +796,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
if *negated {
self.register_bound(
ty,
self.tcx.require_lang_item(LangItem::Neg, Some(lt.span)),
self.tcx.require_lang_item(LangItem::Neg, lt.span),
ObligationCause::dummy_with_span(lt.span),
);
}
@@ -2553,13 +2553,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let tcx = self.tcx;
self.register_bound(
source_ty,
tcx.require_lang_item(hir::LangItem::DerefPure, Some(span)),
tcx.require_lang_item(hir::LangItem::DerefPure, span),
self.misc(span),
);
// The expected type for the deref pat's inner pattern is `<expected as Deref>::Target`.
let target_ty = Ty::new_projection(
tcx,
tcx.require_lang_item(hir::LangItem::DerefTarget, Some(span)),
tcx.require_lang_item(hir::LangItem::DerefTarget, span),
[source_ty],
);
let target_ty = self.normalize(span, target_ty);
@@ -2580,7 +2580,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
for mutably_derefed_ty in derefed_tys {
self.register_bound(
mutably_derefed_ty,
self.tcx.require_lang_item(hir::LangItem::DerefMut, Some(span)),
self.tcx.require_lang_item(hir::LangItem::DerefMut, span),
self.misc(span),
);
}

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

@@ -1560,7 +1560,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
};
let is_drop_defined_for_ty = |ty: Ty<'tcx>| {
let drop_trait = self.tcx.require_lang_item(hir::LangItem::Drop, Some(closure_span));
let drop_trait = self.tcx.require_lang_item(hir::LangItem::Drop, closure_span);
self.infcx
.type_implements_trait(drop_trait, [ty], self.tcx.param_env(closure_def_id))
.must_apply_modulo_regions()

5
compiler/rustc_lint/src/builtin.rs
View File

@@ -39,7 +39,7 @@ pub use rustc_session::lint::builtin::*;
use rustc_session::{declare_lint, declare_lint_pass, impl_lint_pass};
use rustc_span::edition::Edition;
use rustc_span::source_map::Spanned;
use rustc_span::{BytePos, Ident, InnerSpan, Span, Symbol, kw, sym};
use rustc_span::{BytePos, DUMMY_SP, Ident, InnerSpan, Span, Symbol, kw, sym};
use rustc_target::asm::InlineAsmArch;
use rustc_trait_selection::infer::{InferCtxtExt, TyCtxtInferExt};
use rustc_trait_selection::traits::misc::type_allowed_to_implement_copy;
@@ -635,7 +635,8 @@ fn type_implements_negative_copy_modulo_regions<'tcx>(
typing_env: ty::TypingEnv<'tcx>,
) -> bool {
let (infcx, param_env) = tcx.infer_ctxt().build_with_typing_env(typing_env);
let trait_ref = ty::TraitRef::new(tcx, tcx.require_lang_item(hir::LangItem::Copy, None), [ty]);
let trait_ref =
ty::TraitRef::new(tcx, tcx.require_lang_item(hir::LangItem::Copy, DUMMY_SP), [ty]);
let pred = ty::TraitPredicate { trait_ref, polarity: ty::PredicatePolarity::Negative };
let obligation = traits::Obligation {
cause: traits::ObligationCause::dummy(),

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

@@ -95,7 +95,7 @@ pub(crate) struct StrictCoherenceNeedsNegativeCoherence {
#[diag(middle_requires_lang_item)]
pub(crate) struct RequiresLangItem {
#[primary_span]
pub span: Option<Span>,
pub span: Span,
pub name: Symbol,
}

2
compiler/rustc_middle/src/middle/lang_items.rs
View File

@@ -17,7 +17,7 @@ use crate::ty::{self, TyCtxt};
impl<'tcx> TyCtxt<'tcx> {
/// Returns the `DefId` for a given `LangItem`.
/// If not found, fatally aborts compilation.
pub fn require_lang_item(self, lang_item: LangItem, span: Option<Span>) -> DefId {
pub fn require_lang_item(self, lang_item: LangItem, span: Span) -> DefId {
self.lang_items().get(lang_item).unwrap_or_else(|| {
self.dcx().emit_fatal(crate::error::RequiresLangItem { span, name: lang_item.name() });
})

2
compiler/rustc_middle/src/mir/statement.rs
View File

@@ -835,7 +835,7 @@ impl<'tcx> BinOp {
&BinOp::Cmp => {
// these should be integer-like types of the same size.
assert_eq!(lhs_ty, rhs_ty);
tcx.ty_ordering_enum(None)
tcx.ty_ordering_enum(DUMMY_SP)
}
}
}

4
compiler/rustc_middle/src/ty/adjustment.rs
View File

@@ -128,8 +128,8 @@ impl OverloadedDeref {
/// for this overloaded deref's mutability.
pub fn method_call<'tcx>(&self, tcx: TyCtxt<'tcx>) -> DefId {
let trait_def_id = match self.mutbl {
hir::Mutability::Not => tcx.require_lang_item(LangItem::Deref, None),
hir::Mutability::Mut => tcx.require_lang_item(LangItem::DerefMut, None),
hir::Mutability::Not => tcx.require_lang_item(LangItem::Deref, self.span),
hir::Mutability::Mut => tcx.require_lang_item(LangItem::DerefMut, self.span),
};
tcx.associated_items(trait_def_id)
.in_definition_order()

8
compiler/rustc_middle/src/ty/context.rs
View File

@@ -458,7 +458,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
}
fn require_lang_item(self, lang_item: TraitSolverLangItem) -> DefId {
self.require_lang_item(trait_lang_item_to_lang_item(lang_item), None)
self.require_lang_item(trait_lang_item_to_lang_item(lang_item), DUMMY_SP)
}
fn is_lang_item(self, def_id: DefId, lang_item: TraitSolverLangItem) -> bool {
@@ -1710,7 +1710,7 @@ impl<'tcx> TyCtxt<'tcx> {
/// Gets a `Ty` representing the [`LangItem::OrderingEnum`]
#[track_caller]
pub fn ty_ordering_enum(self, span: Option<Span>) -> Ty<'tcx> {
pub fn ty_ordering_enum(self, span: Span) -> Ty<'tcx> {
let ordering_enum = self.require_lang_item(hir::LangItem::OrderingEnum, span);
self.type_of(ordering_enum).no_bound_vars().unwrap()
}
@@ -2253,7 +2253,7 @@ impl<'tcx> TyCtxt<'tcx> {
Ty::new_imm_ref(
self,
self.lifetimes.re_static,
self.type_of(self.require_lang_item(LangItem::PanicLocation, None))
self.type_of(self.require_lang_item(LangItem::PanicLocation, DUMMY_SP))
.instantiate(self, self.mk_args(&[self.lifetimes.re_static.into()])),
)
}
@@ -2712,7 +2712,7 @@ impl<'tcx> TyCtxt<'tcx> {
/// Given a `ty`, return whether it's an `impl Future<...>`.
pub fn ty_is_opaque_future(self, ty: Ty<'_>) -> bool {
let ty::Alias(ty::Opaque, ty::AliasTy { def_id, .. }) = ty.kind() else { return false };
let future_trait = self.require_lang_item(LangItem::Future, None);
let future_trait = self.require_lang_item(LangItem::Future, DUMMY_SP);
self.explicit_item_self_bounds(def_id).skip_binder().iter().any(|&(predicate, _)| {
let ty::ClauseKind::Trait(trait_predicate) = predicate.kind().skip_binder() else {

6
compiler/rustc_middle/src/ty/instance.rs
View File

@@ -786,7 +786,7 @@ impl<'tcx> Instance<'tcx> {
}
pub fn resolve_drop_in_place(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> ty::Instance<'tcx> {
let def_id = tcx.require_lang_item(LangItem::DropInPlace, None);
let def_id = tcx.require_lang_item(LangItem::DropInPlace, DUMMY_SP);
let args = tcx.mk_args(&[ty.into()]);
Instance::expect_resolve(
tcx,
@@ -798,7 +798,7 @@ impl<'tcx> Instance<'tcx> {
}
pub fn resolve_async_drop_in_place(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> ty::Instance<'tcx> {
let def_id = tcx.require_lang_item(LangItem::AsyncDropInPlace, None);
let def_id = tcx.require_lang_item(LangItem::AsyncDropInPlace, DUMMY_SP);
let args = tcx.mk_args(&[ty.into()]);
Instance::expect_resolve(
tcx,
@@ -824,7 +824,7 @@ impl<'tcx> Instance<'tcx> {
closure_did: DefId,
args: ty::GenericArgsRef<'tcx>,
) -> Instance<'tcx> {
let fn_once = tcx.require_lang_item(LangItem::FnOnce, None);
let fn_once = tcx.require_lang_item(LangItem::FnOnce, DUMMY_SP);
let call_once = tcx
.associated_items(fn_once)
.in_definition_order()

14
compiler/rustc_middle/src/ty/sty.rs
View File

@@ -593,7 +593,7 @@ impl<'tcx> Ty<'tcx> {
ty: Ty<'tcx>,
mutbl: ty::Mutability,
) -> Ty<'tcx> {
let pin = tcx.adt_def(tcx.require_lang_item(LangItem::Pin, None));
let pin = tcx.adt_def(tcx.require_lang_item(LangItem::Pin, DUMMY_SP));
Ty::new_adt(tcx, pin, tcx.mk_args(&[Ty::new_ref(tcx, r, ty, mutbl).into()]))
}
@@ -857,19 +857,19 @@ impl<'tcx> Ty<'tcx> {
#[inline]
pub fn new_box(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
let def_id = tcx.require_lang_item(LangItem::OwnedBox, None);
let def_id = tcx.require_lang_item(LangItem::OwnedBox, DUMMY_SP);
Ty::new_generic_adt(tcx, def_id, ty)
}
#[inline]
pub fn new_maybe_uninit(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
let def_id = tcx.require_lang_item(LangItem::MaybeUninit, None);
let def_id = tcx.require_lang_item(LangItem::MaybeUninit, DUMMY_SP);
Ty::new_generic_adt(tcx, def_id, ty)
}
/// Creates a `&mut Context<'_>` [`Ty`] with erased lifetimes.
pub fn new_task_context(tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
let context_did = tcx.require_lang_item(LangItem::Context, None);
let context_did = tcx.require_lang_item(LangItem::Context, DUMMY_SP);
let context_adt_ref = tcx.adt_def(context_did);
let context_args = tcx.mk_args(&[tcx.lifetimes.re_erased.into()]);
let context_ty = Ty::new_adt(tcx, context_adt_ref, context_args);
@@ -1549,7 +1549,7 @@ impl<'tcx> Ty<'tcx> {
ty::Param(_) | ty::Alias(..) | ty::Infer(ty::TyVar(_)) => {
let assoc_items = tcx.associated_item_def_ids(
tcx.require_lang_item(hir::LangItem::DiscriminantKind, None),
tcx.require_lang_item(hir::LangItem::DiscriminantKind, DUMMY_SP),
);
Ty::new_projection_from_args(tcx, assoc_items[0], tcx.mk_args(&[self.into()]))
}
@@ -1629,7 +1629,7 @@ impl<'tcx> Ty<'tcx> {
ty::Str | ty::Slice(_) => Ok(tcx.types.usize),
ty::Dynamic(_, _, ty::Dyn) => {
let dyn_metadata = tcx.require_lang_item(LangItem::DynMetadata, None);
let dyn_metadata = tcx.require_lang_item(LangItem::DynMetadata, DUMMY_SP);
Ok(tcx.type_of(dyn_metadata).instantiate(tcx, &[tail.into()]))
}
@@ -1683,7 +1683,7 @@ impl<'tcx> Ty<'tcx> {
match pointee_ty.ptr_metadata_ty_or_tail(tcx, |x| x) {
Ok(metadata_ty) => metadata_ty,
Err(tail_ty) => {
let metadata_def_id = tcx.require_lang_item(LangItem::Metadata, None);
let metadata_def_id = tcx.require_lang_item(LangItem::Metadata, DUMMY_SP);
Ty::new_projection(tcx, metadata_def_id, [tail_ty])
}
}

2
compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
View File

@@ -145,7 +145,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
// malloc some memory of suitable size and align:
let exchange_malloc = Operand::function_handle(
tcx,
tcx.require_lang_item(LangItem::ExchangeMalloc, Some(expr_span)),
tcx.require_lang_item(LangItem::ExchangeMalloc, expr_span),
[],
expr_span,
);

2
compiler/rustc_mir_build/src/builder/expr/into.rs
View File

@@ -307,7 +307,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
} else if this.infcx.type_is_use_cloned_modulo_regions(this.param_env, ty) {
// Convert `expr.use` to a call like `Clone::clone(&expr)`
let success = this.cfg.start_new_block();
let clone_trait = this.tcx.require_lang_item(LangItem::Clone, None);
let clone_trait = this.tcx.require_lang_item(LangItem::Clone, span);
let clone_fn = this.tcx.associated_item_def_ids(clone_trait)[0];
let func = Operand::function_handle(this.tcx, clone_fn, [ty.into()], expr_span);
let ref_ty = Ty::new_imm_ref(this.tcx, this.tcx.lifetimes.re_erased, ty);

4
compiler/rustc_mir_build/src/builder/matches/test.rs
View File

@@ -364,7 +364,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
let borrow_kind = super::util::ref_pat_borrow_kind(mutability);
let source_info = self.source_info(span);
let re_erased = self.tcx.lifetimes.re_erased;
let trait_item = self.tcx.require_lang_item(trait_item, None);
let trait_item = self.tcx.require_lang_item(trait_item, span);
let method = trait_method(self.tcx, trait_item, method, [ty]);
let ref_src = self.temp(Ty::new_ref(self.tcx, re_erased, ty, mutability), span);
// `let ref_src = &src_place;`
@@ -437,7 +437,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
val: Operand<'tcx>,
) {
let str_ty = self.tcx.types.str_;
let eq_def_id = self.tcx.require_lang_item(LangItem::PartialEq, Some(source_info.span));
let eq_def_id = self.tcx.require_lang_item(LangItem::PartialEq, source_info.span);
let method = trait_method(self.tcx, eq_def_id, sym::eq, [str_ty, str_ty]);
let bool_ty = self.tcx.types.bool;

2
compiler/rustc_mir_build/src/thir/cx/expr.rs
View File

@@ -220,7 +220,7 @@ impl<'tcx> ThirBuildCx<'tcx> {
});
// kind = Pin { __pointer: pointer }
let pin_did = self.tcx.require_lang_item(rustc_hir::LangItem::Pin, Some(span));
let pin_did = self.tcx.require_lang_item(rustc_hir::LangItem::Pin, span);
let args = self.tcx.mk_args(&[new_pin_target.into()]);
let kind = ExprKind::Adt(Box::new(AdtExpr {
adt_def: self.tcx.adt_def(pin_did),

2
compiler/rustc_mir_build/src/thir/cx/mod.rs
View File

@@ -189,7 +189,7 @@ impl<'tcx> ThirBuildCx<'tcx> {
// C-variadic fns also have a `VaList` input that's not listed in `fn_sig`
// (as it's created inside the body itself, not passed in from outside).
let ty = if fn_decl.c_variadic && index == fn_decl.inputs.len() {
let va_list_did = self.tcx.require_lang_item(LangItem::VaList, Some(param.span));
let va_list_did = self.tcx.require_lang_item(LangItem::VaList, param.span);
self.tcx
.type_of(va_list_did)

7
compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
View File

@@ -15,7 +15,7 @@ use rustc_middle::ty::{
};
use rustc_middle::{mir, span_bug};
use rustc_span::def_id::DefId;
use rustc_span::{Span, sym};
use rustc_span::{DUMMY_SP, Span, sym};
use rustc_trait_selection::traits::ObligationCause;
use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
use tracing::{debug, instrument, trace};
@@ -480,8 +480,9 @@ fn type_has_partial_eq_impl<'tcx>(
// (If there isn't, then we can safely issue a hard
// error, because that's never worked, due to compiler
// using `PartialEq::eq` in this scenario in the past.)
let partial_eq_trait_id = tcx.require_lang_item(hir::LangItem::PartialEq, None);
let structural_partial_eq_trait_id = tcx.require_lang_item(hir::LangItem::StructuralPeq, None);
let partial_eq_trait_id = tcx.require_lang_item(hir::LangItem::PartialEq, DUMMY_SP);
let structural_partial_eq_trait_id =
tcx.require_lang_item(hir::LangItem::StructuralPeq, DUMMY_SP);
let partial_eq_obligation = Obligation::new(
tcx,

31
compiler/rustc_mir_transform/src/coroutine.rs
View File

@@ -225,7 +225,7 @@ impl<'tcx> TransformVisitor<'tcx> {
CoroutineKind::Coroutine(_) => span_bug!(body.span, "`Coroutine`s cannot be fused"),
// `gen` continues return `None`
CoroutineKind::Desugared(CoroutineDesugaring::Gen, _) => {
let option_def_id = self.tcx.require_lang_item(LangItem::Option, None);
let option_def_id = self.tcx.require_lang_item(LangItem::Option, body.span);
make_aggregate_adt(
option_def_id,
VariantIdx::ZERO,
@@ -242,7 +242,7 @@ impl<'tcx> TransformVisitor<'tcx> {
span: source_info.span,
const_: Const::Unevaluated(
UnevaluatedConst::new(
self.tcx.require_lang_item(LangItem::AsyncGenFinished, None),
self.tcx.require_lang_item(LangItem::AsyncGenFinished, body.span),
self.tcx.mk_args(&[yield_ty.into()]),
),
self.old_yield_ty,
@@ -282,7 +282,7 @@ impl<'tcx> TransformVisitor<'tcx> {
const ONE: VariantIdx = VariantIdx::from_usize(1);
let rvalue = match self.coroutine_kind {
CoroutineKind::Desugared(CoroutineDesugaring::Async, _) => {
let poll_def_id = self.tcx.require_lang_item(LangItem::Poll, None);
let poll_def_id = self.tcx.require_lang_item(LangItem::Poll, source_info.span);
let args = self.tcx.mk_args(&[self.old_ret_ty.into()]);
let (variant_idx, operands) = if is_return {
(ZERO, IndexVec::from_raw(vec![val])) // Poll::Ready(val)
@@ -292,7 +292,7 @@ impl<'tcx> TransformVisitor<'tcx> {
make_aggregate_adt(poll_def_id, variant_idx, args, operands)
}
CoroutineKind::Desugared(CoroutineDesugaring::Gen, _) => {
let option_def_id = self.tcx.require_lang_item(LangItem::Option, None);
let option_def_id = self.tcx.require_lang_item(LangItem::Option, source_info.span);
let args = self.tcx.mk_args(&[self.old_yield_ty.into()]);
let (variant_idx, operands) = if is_return {
(ZERO, IndexVec::new()) // None
@@ -310,7 +310,10 @@ impl<'tcx> TransformVisitor<'tcx> {
span: source_info.span,
const_: Const::Unevaluated(
UnevaluatedConst::new(
self.tcx.require_lang_item(LangItem::AsyncGenFinished, None),
self.tcx.require_lang_item(
LangItem::AsyncGenFinished,
source_info.span,
),
self.tcx.mk_args(&[yield_ty.into()]),
),
self.old_yield_ty,
@@ -323,7 +326,7 @@ impl<'tcx> TransformVisitor<'tcx> {
}
CoroutineKind::Coroutine(_) => {
let coroutine_state_def_id =
self.tcx.require_lang_item(LangItem::CoroutineState, None);
self.tcx.require_lang_item(LangItem::CoroutineState, source_info.span);
let args = self.tcx.mk_args(&[self.old_yield_ty.into(), self.old_ret_ty.into()]);
let variant_idx = if is_return {
ONE // CoroutineState::Complete(val)
@@ -496,7 +499,7 @@ fn make_coroutine_state_argument_indirect<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Bo
fn make_coroutine_state_argument_pinned<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
let ref_coroutine_ty = body.local_decls.raw[1].ty;
let pin_did = tcx.require_lang_item(LangItem::Pin, Some(body.span));
let pin_did = tcx.require_lang_item(LangItem::Pin, body.span);
let pin_adt_ref = tcx.adt_def(pin_did);
let args = tcx.mk_args(&[ref_coroutine_ty.into()]);
let pin_ref_coroutine_ty = Ty::new_adt(tcx, pin_adt_ref, args);
@@ -557,7 +560,7 @@ fn transform_async_context<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) -> Ty
// replace the type of the `resume` argument
replace_resume_ty_local(tcx, body, CTX_ARG, context_mut_ref);
let get_context_def_id = tcx.require_lang_item(LangItem::GetContext, None);
let get_context_def_id = tcx.require_lang_item(LangItem::GetContext, body.span);
for bb in body.basic_blocks.indices() {
let bb_data = &body[bb];
@@ -618,7 +621,7 @@ fn replace_resume_ty_local<'tcx>(
#[cfg(debug_assertions)]
{
if let ty::Adt(resume_ty_adt, _) = local_ty.kind() {
let expected_adt = tcx.adt_def(tcx.require_lang_item(LangItem::ResumeTy, None));
let expected_adt = tcx.adt_def(tcx.require_lang_item(LangItem::ResumeTy, body.span));
assert_eq!(*resume_ty_adt, expected_adt);
} else {
panic!("expected `ResumeTy`, found `{:?}`", local_ty);
@@ -1095,7 +1098,7 @@ fn insert_term_block<'tcx>(body: &mut Body<'tcx>, kind: TerminatorKind<'tcx>) ->
fn return_poll_ready_assign<'tcx>(tcx: TyCtxt<'tcx>, source_info: SourceInfo) -> Statement<'tcx> {
// Poll::Ready(())
let poll_def_id = tcx.require_lang_item(LangItem::Poll, None);
let poll_def_id = tcx.require_lang_item(LangItem::Poll, source_info.span);
let args = tcx.mk_args(&[tcx.types.unit.into()]);
let val = Operand::Constant(Box::new(ConstOperand {
span: source_info.span,
@@ -1437,7 +1440,7 @@ fn check_field_tys_sized<'tcx>(
),
param_env,
field_ty.ty,
tcx.require_lang_item(hir::LangItem::Sized, Some(field_ty.source_info.span)),
tcx.require_lang_item(hir::LangItem::Sized, field_ty.source_info.span),
);
}
@@ -1473,14 +1476,14 @@ impl<'tcx> crate::MirPass<'tcx> for StateTransform {
let new_ret_ty = match coroutine_kind {
CoroutineKind::Desugared(CoroutineDesugaring::Async, _) => {
// Compute Poll<return_ty>
let poll_did = tcx.require_lang_item(LangItem::Poll, None);
let poll_did = tcx.require_lang_item(LangItem::Poll, body.span);
let poll_adt_ref = tcx.adt_def(poll_did);
let poll_args = tcx.mk_args(&[old_ret_ty.into()]);
Ty::new_adt(tcx, poll_adt_ref, poll_args)
}
CoroutineKind::Desugared(CoroutineDesugaring::Gen, _) => {
// Compute Option<yield_ty>
let option_did = tcx.require_lang_item(LangItem::Option, None);
let option_did = tcx.require_lang_item(LangItem::Option, body.span);
let option_adt_ref = tcx.adt_def(option_did);
let option_args = tcx.mk_args(&[old_yield_ty.into()]);
Ty::new_adt(tcx, option_adt_ref, option_args)
@@ -1491,7 +1494,7 @@ impl<'tcx> crate::MirPass<'tcx> for StateTransform {
}
CoroutineKind::Coroutine(_) => {
// Compute CoroutineState<yield_ty, return_ty>
let state_did = tcx.require_lang_item(LangItem::CoroutineState, None);
let state_did = tcx.require_lang_item(LangItem::CoroutineState, body.span);
let state_adt_ref = tcx.adt_def(state_did);
let state_args = tcx.mk_args(&[old_yield_ty.into(), old_ret_ty.into()]);
Ty::new_adt(tcx, state_adt_ref, state_args)

39
compiler/rustc_mir_transform/src/coroutine/drop.rs
View File

@@ -42,7 +42,7 @@ fn build_poll_call<'tcx>(
context_ref_place: &Place<'tcx>,
unwind: UnwindAction,
) -> BasicBlock {
let poll_fn = tcx.require_lang_item(LangItem::FuturePoll, None);
let poll_fn = tcx.require_lang_item(LangItem::FuturePoll, DUMMY_SP);
let poll_fn = Ty::new_fn_def(tcx, poll_fn, [fut_ty]);
let poll_fn = Operand::Constant(Box::new(ConstOperand {
span: DUMMY_SP,
@@ -77,11 +77,8 @@ fn build_pin_fut<'tcx>(
let fut_ty = fut_place.ty(&body.local_decls, tcx).ty;
let fut_ref_ty = Ty::new_mut_ref(tcx, tcx.lifetimes.re_erased, fut_ty);
let fut_ref_place = Place::from(body.local_decls.push(LocalDecl::new(fut_ref_ty, span)));
let pin_fut_new_unchecked_fn = Ty::new_fn_def(
tcx,
tcx.require_lang_item(LangItem::PinNewUnchecked, Some(span)),
[fut_ref_ty],
);
let pin_fut_new_unchecked_fn =
Ty::new_fn_def(tcx, tcx.require_lang_item(LangItem::PinNewUnchecked, span), [fut_ref_ty]);
let fut_pin_ty = pin_fut_new_unchecked_fn.fn_sig(tcx).output().skip_binder();
let fut_pin_place = Place::from(body.local_decls.push(LocalDecl::new(fut_pin_ty, span)));
let pin_fut_new_unchecked_fn = Operand::Constant(Box::new(ConstOperand {
@@ -143,13 +140,15 @@ fn build_poll_switch<'tcx>(
let Discr { val: poll_ready_discr, ty: poll_discr_ty } = poll_enum
.discriminant_for_variant(
tcx,
poll_enum_adt.variant_index_with_id(tcx.require_lang_item(LangItem::PollReady, None)),
poll_enum_adt
.variant_index_with_id(tcx.require_lang_item(LangItem::PollReady, DUMMY_SP)),
)
.unwrap();
let poll_pending_discr = poll_enum
.discriminant_for_variant(
tcx,
poll_enum_adt.variant_index_with_id(tcx.require_lang_item(LangItem::PollPending, None)),
poll_enum_adt
.variant_index_with_id(tcx.require_lang_item(LangItem::PollPending, DUMMY_SP)),
)
.unwrap()
.val;
@@ -316,16 +315,17 @@ pub(super) fn expand_async_drops<'tcx>(
// pending => return rv (yield)
// ready => *continue_bb|drop_bb*
let source_info = body[bb].terminator.as_ref().unwrap().source_info;
// Compute Poll<> (aka Poll with void return)
let poll_adt_ref = tcx.adt_def(tcx.require_lang_item(LangItem::Poll, None));
let poll_adt_ref = tcx.adt_def(tcx.require_lang_item(LangItem::Poll, source_info.span));
let poll_enum = Ty::new_adt(tcx, poll_adt_ref, tcx.mk_args(&[tcx.types.unit.into()]));
let poll_decl = LocalDecl::new(poll_enum, body.span);
let poll_decl = LocalDecl::new(poll_enum, source_info.span);
let poll_unit_place = Place::from(body.local_decls.push(poll_decl));
// First state-loop yield for mainline
let context_ref_place =
Place::from(body.local_decls.push(LocalDecl::new(context_mut_ref, body.span)));
let source_info = body[bb].terminator.as_ref().unwrap().source_info;
Place::from(body.local_decls.push(LocalDecl::new(context_mut_ref, source_info.span)));
let arg = Rvalue::Use(Operand::Move(Place::from(CTX_ARG)));
body[bb].statements.push(Statement {
source_info,
@@ -353,8 +353,9 @@ pub(super) fn expand_async_drops<'tcx>(
let mut dropline_context_ref: Option<Place<'_>> = None;
let mut dropline_call_bb: Option<BasicBlock> = None;
if !is_dropline_bb {
let context_ref_place2: Place<'_> =
Place::from(body.local_decls.push(LocalDecl::new(context_mut_ref, body.span)));
let context_ref_place2: Place<'_> = Place::from(
body.local_decls.push(LocalDecl::new(context_mut_ref, source_info.span)),
);
let drop_yield_block = insert_term_block(body, TerminatorKind::Unreachable); // `kind` replaced later to yield
let drop_switch_block = build_poll_switch(
tcx,
@@ -394,7 +395,7 @@ pub(super) fn expand_async_drops<'tcx>(
span: source_info.span,
const_: Const::Unevaluated(
UnevaluatedConst::new(
tcx.require_lang_item(LangItem::AsyncGenPending, None),
tcx.require_lang_item(LangItem::AsyncGenPending, source_info.span),
tcx.mk_args(&[yield_ty.into()]),
),
full_yield_ty,
@@ -404,7 +405,7 @@ pub(super) fn expand_async_drops<'tcx>(
} else {
// value needed only for return-yields or gen-coroutines, so just const here
Operand::Constant(Box::new(ConstOperand {
span: body.span,
span: source_info.span,
user_ty: None,
const_: Const::from_bool(tcx, false),
}))
@@ -595,7 +596,7 @@ pub(super) fn create_coroutine_drop_shim<'tcx>(
// Update the body's def to become the drop glue.
let coroutine_instance = body.source.instance;
let drop_in_place = tcx.require_lang_item(LangItem::DropInPlace, None);
let drop_in_place = tcx.require_lang_item(LangItem::DropInPlace, body.span);
let drop_instance = InstanceKind::DropGlue(drop_in_place, Some(coroutine_ty));
// Temporary change MirSource to coroutine's instance so that dump_mir produces more sensible
@@ -666,7 +667,7 @@ pub(super) fn create_coroutine_drop_shim_async<'tcx>(
}
// Replace the return variable: Poll<RetT> to Poll<()>
let poll_adt_ref = tcx.adt_def(tcx.require_lang_item(LangItem::Poll, None));
let poll_adt_ref = tcx.adt_def(tcx.require_lang_item(LangItem::Poll, body.span));
let poll_enum = Ty::new_adt(tcx, poll_adt_ref, tcx.mk_args(&[tcx.types.unit.into()]));
body.local_decls[RETURN_PLACE] = LocalDecl::with_source_info(poll_enum, source_info);
@@ -717,7 +718,7 @@ pub(super) fn create_coroutine_drop_shim_proxy_async<'tcx>(
let source_info = SourceInfo::outermost(body.span);
// Replace the return variable: Poll<RetT> to Poll<()>
let poll_adt_ref = tcx.adt_def(tcx.require_lang_item(LangItem::Poll, None));
let poll_adt_ref = tcx.adt_def(tcx.require_lang_item(LangItem::Poll, body.span));
let poll_enum = Ty::new_adt(tcx, poll_adt_ref, tcx.mk_args(&[tcx.types.unit.into()]));
body.local_decls[RETURN_PLACE] = LocalDecl::with_source_info(poll_enum, source_info);

13
compiler/rustc_mir_transform/src/elaborate_drop.rs
View File

@@ -235,11 +235,8 @@ where
let (fut_ty, drop_fn_def_id, trait_args) = if call_destructor_only {
// Resolving obj.<AsyncDrop::drop>()
let trait_ref = ty::TraitRef::new(
tcx,
tcx.require_lang_item(LangItem::AsyncDrop, Some(span)),
[drop_ty],
);
let trait_ref =
ty::TraitRef::new(tcx, tcx.require_lang_item(LangItem::AsyncDrop, span), [drop_ty]);
let (drop_trait, trait_args) = match tcx.codegen_select_candidate(
ty::TypingEnv::fully_monomorphized().as_query_input(trait_ref),
) {
@@ -292,7 +289,7 @@ where
(sig.output(), drop_fn_def_id, trait_args)
} else {
// Resolving async_drop_in_place<T> function for drop_ty
let drop_fn_def_id = tcx.require_lang_item(LangItem::AsyncDropInPlace, Some(span));
let drop_fn_def_id = tcx.require_lang_item(LangItem::AsyncDropInPlace, span);
let trait_args = tcx.mk_args(&[drop_ty.into()]);
let sig = tcx.fn_sig(drop_fn_def_id).instantiate(tcx, trait_args);
let sig = tcx.instantiate_bound_regions_with_erased(sig);
@@ -319,7 +316,7 @@ where
// pin_obj_place preparation
let pin_obj_new_unchecked_fn = Ty::new_fn_def(
tcx,
tcx.require_lang_item(LangItem::PinNewUnchecked, Some(span)),
tcx.require_lang_item(LangItem::PinNewUnchecked, span),
[GenericArg::from(obj_ref_ty)],
);
let pin_obj_ty = pin_obj_new_unchecked_fn.fn_sig(tcx).output().no_bound_vars().unwrap();
@@ -937,7 +934,7 @@ where
fn destructor_call_block_sync(&mut self, (succ, unwind): (BasicBlock, Unwind)) -> BasicBlock {
debug!("destructor_call_block_sync({:?}, {:?})", self, succ);
let tcx = self.tcx();
let drop_trait = tcx.require_lang_item(LangItem::Drop, None);
let drop_trait = tcx.require_lang_item(LangItem::Drop, DUMMY_SP);
let drop_fn = tcx.associated_item_def_ids(drop_trait)[0];
let ty = self.place_ty(self.place);

2
compiler/rustc_mir_transform/src/shim.rs
View File

@@ -98,7 +98,7 @@ fn make_shim<'tcx>(tcx: TyCtxt<'tcx>, instance: ty::InstanceKind<'tcx>) -> Body<
build_call_shim(tcx, instance, None, CallKind::Direct(def_id))
}
ty::InstanceKind::ClosureOnceShim { call_once: _, track_caller: _ } => {
let fn_mut = tcx.require_lang_item(LangItem::FnMut, None);
let fn_mut = tcx.require_lang_item(LangItem::FnMut, DUMMY_SP);
let call_mut = tcx
.associated_items(fn_mut)
.in_definition_order()

12
compiler/rustc_mir_transform/src/shim/async_destructor_ctor.rs
View File

@@ -64,7 +64,7 @@ pub(super) fn build_async_drop_shim<'tcx>(
let needs_async_drop = drop_ty.needs_async_drop(tcx, typing_env);
let needs_sync_drop = !needs_async_drop && drop_ty.needs_drop(tcx, typing_env);
let resume_adt = tcx.adt_def(tcx.require_lang_item(LangItem::ResumeTy, None));
let resume_adt = tcx.adt_def(tcx.require_lang_item(LangItem::ResumeTy, DUMMY_SP));
let resume_ty = Ty::new_adt(tcx, resume_adt, ty::List::empty());
let fn_sig = ty::Binder::dummy(tcx.mk_fn_sig(
@@ -220,7 +220,7 @@ fn build_adrop_for_coroutine_shim<'tcx>(
body.source.instance = instance;
body.phase = MirPhase::Runtime(RuntimePhase::Initial);
body.var_debug_info.clear();
let pin_adt_ref = tcx.adt_def(tcx.require_lang_item(LangItem::Pin, Some(span)));
let pin_adt_ref = tcx.adt_def(tcx.require_lang_item(LangItem::Pin, span));
let args = tcx.mk_args(&[proxy_ref.into()]);
let pin_proxy_ref = Ty::new_adt(tcx, pin_adt_ref, args);
@@ -308,10 +308,10 @@ fn build_adrop_for_adrop_shim<'tcx>(
let cor_ref = Ty::new_mut_ref(tcx, tcx.lifetimes.re_erased, impl_ty);
// ret_ty = `Poll<()>`
let poll_adt_ref = tcx.adt_def(tcx.require_lang_item(LangItem::Poll, None));
let poll_adt_ref = tcx.adt_def(tcx.require_lang_item(LangItem::Poll, span));
let ret_ty = Ty::new_adt(tcx, poll_adt_ref, tcx.mk_args(&[tcx.types.unit.into()]));
// env_ty = `Pin<&mut proxy_ty>`
let pin_adt_ref = tcx.adt_def(tcx.require_lang_item(LangItem::Pin, None));
let pin_adt_ref = tcx.adt_def(tcx.require_lang_item(LangItem::Pin, span));
let env_ty = Ty::new_adt(tcx, pin_adt_ref, tcx.mk_args(&[proxy_ref.into()]));
// sig = `fn (Pin<&mut proxy_ty>, &mut Context) -> Poll<()>`
let sig = tcx.mk_fn_sig(
@@ -376,7 +376,7 @@ fn build_adrop_for_adrop_shim<'tcx>(
let cor_pin_ty = Ty::new_adt(tcx, pin_adt_ref, tcx.mk_args(&[cor_ref.into()]));
let cor_pin_place = Place::from(locals.push(LocalDecl::new(cor_pin_ty, span)));
let pin_fn = tcx.require_lang_item(LangItem::PinNewUnchecked, Some(span));
let pin_fn = tcx.require_lang_item(LangItem::PinNewUnchecked, span);
// call Pin<FutTy>::new_unchecked(&mut impl_cor)
blocks.push(BasicBlockData {
statements,
@@ -396,7 +396,7 @@ fn build_adrop_for_adrop_shim<'tcx>(
});
// When dropping async drop coroutine, we continue its execution:
// we call impl::poll (impl_layout, ctx)
let poll_fn = tcx.require_lang_item(LangItem::FuturePoll, None);
let poll_fn = tcx.require_lang_item(LangItem::FuturePoll, span);
let resume_ctx = Place::from(Local::new(2));
blocks.push(BasicBlockData {
statements: vec![],

2
compiler/rustc_mir_transform/src/validate.rs
View File

@@ -1253,7 +1253,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
self.tcx,
self.tcx.require_lang_item(
LangItem::CoerceUnsized,
Some(self.body.source_info(location).span),
self.body.source_info(location).span,
),
[op_ty, *target_type],
)) {

4
compiler/rustc_monomorphize/src/collector.rs
View File

@@ -781,7 +781,7 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirUsedCollector<'a, 'tcx> {
let tcx = self.tcx;
let push_mono_lang_item = |this: &mut Self, lang_item: LangItem| {
let instance = Instance::mono(tcx, tcx.require_lang_item(lang_item, Some(source)));
let instance = Instance::mono(tcx, tcx.require_lang_item(lang_item, source));
if tcx.should_codegen_locally(instance) {
this.used_items.push(create_fn_mono_item(tcx, instance, source));
}
@@ -921,7 +921,7 @@ fn visit_instance_use<'tcx>(
// be lowered in codegen to nothing or a call to panic_nounwind. So if we encounter any
// of those intrinsics, we need to include a mono item for panic_nounwind, else we may try to
// codegen a call to that function without generating code for the function itself.
let def_id = tcx.require_lang_item(LangItem::PanicNounwind, None);
let def_id = tcx.require_lang_item(LangItem::PanicNounwind, source);
let panic_instance = Instance::mono(tcx, def_id);
if tcx.should_codegen_locally(panic_instance) {
output.push(create_fn_mono_item(tcx, panic_instance, source));

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

@@ -29,7 +29,7 @@ fn custom_coerce_unsize_info<'tcx>(
) -> Result<CustomCoerceUnsized, ErrorGuaranteed> {
let trait_ref = ty::TraitRef::new(
tcx.tcx,
tcx.require_lang_item(LangItem::CoerceUnsized, Some(tcx.span)),
tcx.require_lang_item(LangItem::CoerceUnsized, tcx.span),
[source_ty, target_ty],
);

8
compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
View File

@@ -14,7 +14,7 @@ use rustc_middle::ty::{
TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitableExt, UintTy,
};
use rustc_span::def_id::DefId;
use rustc_span::sym;
use rustc_span::{DUMMY_SP, sym};
use rustc_trait_selection::traits;
use tracing::{debug, instrument};
@@ -414,7 +414,7 @@ pub(crate) fn transform_instance<'tcx>(
}
ty::Coroutine(..) => match tcx.coroutine_kind(instance.def_id()).unwrap() {
hir::CoroutineKind::Coroutine(..) => (
tcx.require_lang_item(LangItem::Coroutine, None),
tcx.require_lang_item(LangItem::Coroutine, DUMMY_SP),
Some(instance.args.as_coroutine().resume_ty()),
),
hir::CoroutineKind::Desugared(desugaring, _) => {
@@ -423,11 +423,11 @@ pub(crate) fn transform_instance<'tcx>(
hir::CoroutineDesugaring::AsyncGen => LangItem::AsyncIterator,
hir::CoroutineDesugaring::Gen => LangItem::Iterator,
};
(tcx.require_lang_item(lang_item, None), None)
(tcx.require_lang_item(lang_item, DUMMY_SP), None)
}
},
ty::CoroutineClosure(..) => (
tcx.require_lang_item(LangItem::FnOnce, None),
tcx.require_lang_item(LangItem::FnOnce, DUMMY_SP),
Some(
tcx.instantiate_bound_regions_with_erased(
instance.args.as_coroutine_closure().coroutine_closure_sig(),

4
compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
View File

@@ -73,7 +73,7 @@ use rustc_middle::ty::{
TypeVisitableExt,
};
use rustc_span::def_id::LOCAL_CRATE;
use rustc_span::{BytePos, DesugaringKind, Pos, Span, sym};
use rustc_span::{BytePos, DUMMY_SP, DesugaringKind, Pos, Span, sym};
use tracing::{debug, instrument};
use crate::error_reporting::TypeErrCtxt;
@@ -194,7 +194,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
_ => return None,
};
let future_trait = self.tcx.require_lang_item(LangItem::Future, None);
let future_trait = self.tcx.require_lang_item(LangItem::Future, DUMMY_SP);
let item_def_id = self.tcx.associated_item_def_ids(future_trait)[0];
self.tcx

6
compiler/rustc_trait_selection/src/error_reporting/traits/call_kind.rs
View File

@@ -6,7 +6,7 @@ use rustc_hir::def::DefKind;
use rustc_hir::def_id::DefId;
use rustc_hir::{LangItem, lang_items};
use rustc_middle::ty::{AssocItemContainer, GenericArgsRef, Instance, Ty, TyCtxt, TypingEnv};
use rustc_span::{DesugaringKind, Ident, Span, sym};
use rustc_span::{DUMMY_SP, DesugaringKind, Ident, Span, sym};
use tracing::debug;
use crate::traits::specialization_graph;
@@ -31,9 +31,9 @@ impl CallDesugaringKind {
pub fn trait_def_id(self, tcx: TyCtxt<'_>) -> DefId {
match self {
Self::ForLoopIntoIter => tcx.get_diagnostic_item(sym::IntoIterator).unwrap(),
Self::ForLoopNext => tcx.require_lang_item(LangItem::Iterator, None),
Self::ForLoopNext => tcx.require_lang_item(LangItem::Iterator, DUMMY_SP),
Self::QuestionBranch | Self::TryBlockFromOutput => {
tcx.require_lang_item(LangItem::Try, None)
tcx.require_lang_item(LangItem::Try, DUMMY_SP)
}
Self::QuestionFromResidual => tcx.get_diagnostic_item(sym::FromResidual).unwrap(),
Self::Await => tcx.get_diagnostic_item(sym::IntoFuture).unwrap(),

6
compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
View File

@@ -955,7 +955,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
return false;
};
let clone_trait = self.tcx.require_lang_item(LangItem::Clone, None);
let clone_trait = self.tcx.require_lang_item(LangItem::Clone, obligation.cause.span);
let has_clone = |ty| {
self.type_implements_trait(clone_trait, [ty], obligation.param_env)
.must_apply_modulo_regions()
@@ -3625,7 +3625,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
trait_pred: ty::PolyTraitPredicate<'tcx>,
span: Span,
) {
let future_trait = self.tcx.require_lang_item(LangItem::Future, None);
let future_trait = self.tcx.require_lang_item(LangItem::Future, span);
let self_ty = self.resolve_vars_if_possible(trait_pred.self_ty());
let impls_future = self.type_implements_trait(
@@ -4141,7 +4141,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
let pred = ty::Binder::dummy(ty::TraitPredicate {
trait_ref: ty::TraitRef::new(
tcx,
tcx.require_lang_item(LangItem::Clone, Some(span)),
tcx.require_lang_item(LangItem::Clone, span),
[*ty],
),
polarity: ty::PredicatePolarity::Positive,

8
compiler/rustc_trait_selection/src/infer.rs
View File

@@ -38,7 +38,7 @@ impl<'tcx> InferCtxt<'tcx> {
return self.tcx.type_is_copy_modulo_regions(self.typing_env(param_env), ty);
}
let copy_def_id = self.tcx.require_lang_item(LangItem::Copy, None);
let copy_def_id = self.tcx.require_lang_item(LangItem::Copy, DUMMY_SP);
// This can get called from typeck (by euv), and `moves_by_default`
// rightly refuses to work with inference variables, but
@@ -49,7 +49,7 @@ impl<'tcx> InferCtxt<'tcx> {
fn type_is_clone_modulo_regions(&self, param_env: ty::ParamEnv<'tcx>, ty: Ty<'tcx>) -> bool {
let ty = self.resolve_vars_if_possible(ty);
let clone_def_id = self.tcx.require_lang_item(LangItem::Clone, None);
let clone_def_id = self.tcx.require_lang_item(LangItem::Clone, DUMMY_SP);
traits::type_known_to_meet_bound_modulo_regions(self, param_env, ty, clone_def_id)
}
@@ -59,12 +59,12 @@ impl<'tcx> InferCtxt<'tcx> {
ty: Ty<'tcx>,
) -> bool {
let ty = self.resolve_vars_if_possible(ty);
let use_cloned_def_id = self.tcx.require_lang_item(LangItem::UseCloned, None);
let use_cloned_def_id = self.tcx.require_lang_item(LangItem::UseCloned, DUMMY_SP);
traits::type_known_to_meet_bound_modulo_regions(self, param_env, ty, use_cloned_def_id)
}
fn type_is_sized_modulo_regions(&self, param_env: ty::ParamEnv<'tcx>, ty: Ty<'tcx>) -> bool {
let lang_item = self.tcx.require_lang_item(LangItem::Sized, None);
let lang_item = self.tcx.require_lang_item(LangItem::Sized, DUMMY_SP);
traits::type_known_to_meet_bound_modulo_regions(self, param_env, ty, lang_item)
}

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

@@ -248,7 +248,7 @@ fn evaluate_host_effect_for_destruct_goal<'tcx>(
obligation: &HostEffectObligation<'tcx>,
) -> Result<ThinVec<PredicateObligation<'tcx>>, EvaluationFailure> {
let tcx = selcx.tcx();
let destruct_def_id = tcx.require_lang_item(LangItem::Destruct, None);
let destruct_def_id = tcx.require_lang_item(LangItem::Destruct, obligation.cause.span);
let self_ty = obligation.predicate.self_ty();
let const_conditions = match *self_ty.kind() {
@@ -267,7 +267,7 @@ fn evaluate_host_effect_for_destruct_goal<'tcx>(
Some(hir::Constness::NotConst) => return Err(EvaluationFailure::NoSolution),
// `Drop` impl exists, and it's const. Require `Ty: ~const Drop` to hold.
Some(hir::Constness::Const) => {
let drop_def_id = tcx.require_lang_item(LangItem::Drop, None);
let drop_def_id = tcx.require_lang_item(LangItem::Drop, obligation.cause.span);
let drop_trait_ref = ty::TraitRef::new(tcx, drop_def_id, [self_ty]);
const_conditions.push(drop_trait_ref);
}

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

@@ -157,7 +157,7 @@ pub fn type_allowed_to_implement_const_param_ty<'tcx>(
parent_cause.clone(),
param_env,
inner_ty,
tcx.require_lang_item(lang_item, Some(parent_cause.span)),
tcx.require_lang_item(lang_item, parent_cause.span),
);
let errors = ocx.select_all_or_error();
@@ -193,7 +193,7 @@ pub fn all_fields_implement_trait<'tcx>(
parent_cause: ObligationCause<'tcx>,
lang_item: LangItem,
) -> Result<(), Vec<(&'tcx ty::FieldDef, Ty<'tcx>, InfringingFieldsReason<'tcx>)>> {
let trait_def_id = tcx.require_lang_item(lang_item, Some(parent_cause.span));
let trait_def_id = tcx.require_lang_item(lang_item, parent_cause.span);
let mut infringing = Vec::new();
for variant in adt.variants() {

34
compiler/rustc_trait_selection/src/traits/project.rs
View File

@@ -1117,7 +1117,7 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
selcx.tcx(),
selcx.tcx().require_lang_item(
LangItem::Sized,
Some(obligation.cause.span),
obligation.cause.span,
),
[self_ty],
),
@@ -1317,7 +1317,7 @@ fn confirm_coroutine_candidate<'cx, 'tcx>(
let tcx = selcx.tcx();
let coroutine_def_id = tcx.require_lang_item(LangItem::Coroutine, None);
let coroutine_def_id = tcx.require_lang_item(LangItem::Coroutine, obligation.cause.span);
let (trait_ref, yield_ty, return_ty) = super::util::coroutine_trait_ref_and_outputs(
tcx,
@@ -1375,7 +1375,7 @@ fn confirm_future_candidate<'cx, 'tcx>(
debug!(?obligation, ?coroutine_sig, ?obligations, "confirm_future_candidate");
let tcx = selcx.tcx();
let fut_def_id = tcx.require_lang_item(LangItem::Future, None);
let fut_def_id = tcx.require_lang_item(LangItem::Future, obligation.cause.span);
let (trait_ref, return_ty) = super::util::future_trait_ref_and_outputs(
tcx,
@@ -1421,7 +1421,7 @@ fn confirm_iterator_candidate<'cx, 'tcx>(
debug!(?obligation, ?gen_sig, ?obligations, "confirm_iterator_candidate");
let tcx = selcx.tcx();
let iter_def_id = tcx.require_lang_item(LangItem::Iterator, None);
let iter_def_id = tcx.require_lang_item(LangItem::Iterator, obligation.cause.span);
let (trait_ref, yield_ty) = super::util::iterator_trait_ref_and_outputs(
tcx,
@@ -1467,7 +1467,7 @@ fn confirm_async_iterator_candidate<'cx, 'tcx>(
debug!(?obligation, ?gen_sig, ?obligations, "confirm_async_iterator_candidate");
let tcx = selcx.tcx();
let iter_def_id = tcx.require_lang_item(LangItem::AsyncIterator, None);
let iter_def_id = tcx.require_lang_item(LangItem::AsyncIterator, obligation.cause.span);
let (trait_ref, yield_ty) = super::util::async_iterator_trait_ref_and_outputs(
tcx,
@@ -1511,12 +1511,13 @@ fn confirm_builtin_candidate<'cx, 'tcx>(
let trait_def_id = tcx.trait_of_item(item_def_id).unwrap();
let args = tcx.mk_args(&[self_ty.into()]);
let (term, obligations) = if tcx.is_lang_item(trait_def_id, LangItem::DiscriminantKind) {
let discriminant_def_id = tcx.require_lang_item(LangItem::Discriminant, None);
let discriminant_def_id =
tcx.require_lang_item(LangItem::Discriminant, obligation.cause.span);
assert_eq!(discriminant_def_id, item_def_id);
(self_ty.discriminant_ty(tcx).into(), PredicateObligations::new())
} else if tcx.is_lang_item(trait_def_id, LangItem::PointeeTrait) {
let metadata_def_id = tcx.require_lang_item(LangItem::Metadata, None);
let metadata_def_id = tcx.require_lang_item(LangItem::Metadata, obligation.cause.span);
assert_eq!(metadata_def_id, item_def_id);
let mut obligations = PredicateObligations::new();
@@ -1538,7 +1539,7 @@ fn confirm_builtin_candidate<'cx, 'tcx>(
// exist. Instead, `Pointee<Metadata = ()>` should be a supertrait of `Sized`.
let sized_predicate = ty::TraitRef::new(
tcx,
tcx.require_lang_item(LangItem::Sized, Some(obligation.cause.span)),
tcx.require_lang_item(LangItem::Sized, obligation.cause.span),
[self_ty],
);
obligations.push(obligation.with(tcx, sized_predicate));
@@ -1620,7 +1621,7 @@ fn confirm_closure_candidate<'cx, 'tcx>(
)
} else {
let upvars_projection_def_id =
tcx.require_lang_item(LangItem::AsyncFnKindUpvars, None);
tcx.require_lang_item(LangItem::AsyncFnKindUpvars, obligation.cause.span);
let tupled_upvars_ty = Ty::new_projection(
tcx,
upvars_projection_def_id,
@@ -1681,8 +1682,9 @@ fn confirm_callable_candidate<'cx, 'tcx>(
debug!(?obligation, ?fn_sig, "confirm_callable_candidate");
let fn_once_def_id = tcx.require_lang_item(LangItem::FnOnce, None);
let fn_once_output_def_id = tcx.require_lang_item(LangItem::FnOnceOutput, None);
let fn_once_def_id = tcx.require_lang_item(LangItem::FnOnce, obligation.cause.span);
let fn_once_output_def_id =
tcx.require_lang_item(LangItem::FnOnceOutput, obligation.cause.span);
let predicate = super::util::closure_trait_ref_and_return_type(
tcx,
@@ -1740,8 +1742,8 @@ fn confirm_async_closure_candidate<'cx, 'tcx>(
args.coroutine_captures_by_ref_ty(),
)
} else {
let upvars_projection_def_id =
tcx.require_lang_item(LangItem::AsyncFnKindUpvars, None);
let upvars_projection_def_id = tcx
.require_lang_item(LangItem::AsyncFnKindUpvars, obligation.cause.span);
// When we don't know the closure kind (and therefore also the closure's upvars,
// which are computed at the same time), we must delay the computation of the
// generator's upvars. We do this using the `AsyncFnKindHelper`, which as a trait
@@ -1798,7 +1800,8 @@ fn confirm_async_closure_candidate<'cx, 'tcx>(
let term = match item_name {
sym::CallOnceFuture | sym::CallRefFuture => sig.output(),
sym::Output => {
let future_output_def_id = tcx.require_lang_item(LangItem::FutureOutput, None);
let future_output_def_id =
tcx.require_lang_item(LangItem::FutureOutput, obligation.cause.span);
Ty::new_projection(tcx, future_output_def_id, [sig.output()])
}
name => bug!("no such associated type: {name}"),
@@ -1831,7 +1834,8 @@ fn confirm_async_closure_candidate<'cx, 'tcx>(
let term = match item_name {
sym::CallOnceFuture | sym::CallRefFuture => sig.output(),
sym::Output => {
let future_output_def_id = tcx.require_lang_item(LangItem::FutureOutput, None);
let future_output_def_id =
tcx.require_lang_item(LangItem::FutureOutput, obligation.cause.span);
Ty::new_projection(tcx, future_output_def_id, [sig.output()])
}
name => bug!("no such associated type: {name}"),

28
compiler/rustc_trait_selection/src/traits/select/confirmation.rs
View File

@@ -318,7 +318,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
let make_freeze_obl = |ty| {
let trait_ref = ty::TraitRef::new(
tcx,
tcx.require_lang_item(LangItem::Freeze, None),
tcx.require_lang_item(LangItem::Freeze, obligation.cause.span),
[ty::GenericArg::from(ty)],
);
Obligation::with_depth(
@@ -657,7 +657,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
);
let tr = ty::TraitRef::new(
self.tcx(),
self.tcx().require_lang_item(LangItem::Sized, Some(cause.span)),
self.tcx().require_lang_item(LangItem::Sized, cause.span),
[output_ty],
);
nested.push(Obligation::new(self.infcx.tcx, cause, obligation.param_env, tr));
@@ -877,14 +877,16 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
});
// We must additionally check that the return type impls `Future + Sized`.
let future_trait_def_id = tcx.require_lang_item(LangItem::Future, None);
let future_trait_def_id =
tcx.require_lang_item(LangItem::Future, obligation.cause.span);
nested.push(obligation.with(
tcx,
sig.output().map_bound(|output_ty| {
ty::TraitRef::new(tcx, future_trait_def_id, [output_ty])
}),
));
let sized_trait_def_id = tcx.require_lang_item(LangItem::Sized, None);
let sized_trait_def_id =
tcx.require_lang_item(LangItem::Sized, obligation.cause.span);
nested.push(obligation.with(
tcx,
sig.output().map_bound(|output_ty| {
@@ -906,13 +908,15 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
});
// We must additionally check that the return type impls `Future + Sized`.
let future_trait_def_id = tcx.require_lang_item(LangItem::Future, None);
let future_trait_def_id =
tcx.require_lang_item(LangItem::Future, obligation.cause.span);
let placeholder_output_ty = self.infcx.enter_forall_and_leak_universe(sig.output());
nested.push(obligation.with(
tcx,
ty::TraitRef::new(tcx, future_trait_def_id, [placeholder_output_ty]),
));
let sized_trait_def_id = tcx.require_lang_item(LangItem::Sized, None);
let sized_trait_def_id =
tcx.require_lang_item(LangItem::Sized, obligation.cause.span);
nested.push(obligation.with(
tcx,
sig.output().map_bound(|output_ty| {
@@ -946,10 +950,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
obligation.param_env,
ty::TraitRef::new(
self.tcx(),
self.tcx().require_lang_item(
LangItem::AsyncFnKindHelper,
Some(obligation.cause.span),
),
self.tcx()
.require_lang_item(LangItem::AsyncFnKindHelper, obligation.cause.span),
[kind_ty, Ty::from_closure_kind(self.tcx(), goal_kind)],
),
));
@@ -1165,7 +1167,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
// We can only make objects from sized types.
let tr = ty::TraitRef::new(
tcx,
tcx.require_lang_item(LangItem::Sized, Some(obligation.cause.span)),
tcx.require_lang_item(LangItem::Sized, obligation.cause.span),
[source],
);
nested.push(predicate_to_obligation(tr.upcast(tcx)));
@@ -1359,7 +1361,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
self_ty.map_bound(|ty| {
ty::TraitRef::new(
tcx,
tcx.require_lang_item(LangItem::Copy, Some(obligation.cause.span)),
tcx.require_lang_item(LangItem::Copy, obligation.cause.span),
[ty],
)
}),
@@ -1411,7 +1413,7 @@ fn pointer_like_goal_for_rpitit<'tcx>(
ty::Binder::bind_with_vars(
ty::TraitRef::new(
tcx,
tcx.require_lang_item(LangItem::PointerLike, Some(cause.span)),
tcx.require_lang_item(LangItem::PointerLike, cause.span),
[Ty::new_projection_from_args(tcx, rpitit_item, args)],
),
tcx.mk_bound_variable_kinds(&bound_vars),

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

@@ -541,7 +541,7 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
let cause = self.cause(cause);
let trait_ref = ty::TraitRef::new(
self.tcx(),
self.tcx().require_lang_item(LangItem::Sized, Some(cause.span)),
self.tcx().require_lang_item(LangItem::Sized, cause.span),
[subty],
);
self.out.push(traits::Obligation::with_depth(
@@ -895,7 +895,7 @@ impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for WfPredicates<'a, 'tcx> {
self.tcx(),
self.tcx().require_lang_item(
LangItem::BikeshedGuaranteedNoDrop,
Some(self.span),
self.span,
),
[ty],
)

13
compiler/rustc_ty_utils/src/abi.rs
View File

@@ -11,6 +11,7 @@ use rustc_middle::ty::layout::{
};
use rustc_middle::ty::{self, InstanceKind, Ty, TyCtxt};
use rustc_session::config::OptLevel;
use rustc_span::DUMMY_SP;
use rustc_span::def_id::DefId;
use rustc_target::callconv::{
AbiMap, ArgAbi, ArgAttribute, ArgAttributes, ArgExtension, FnAbi, PassMode,
@@ -124,7 +125,7 @@ fn fn_sig_for_fn_abi<'tcx>(
let env_ty = Ty::new_mut_ref(tcx, tcx.lifetimes.re_erased, ty);
let pin_did = tcx.require_lang_item(LangItem::Pin, None);
let pin_did = tcx.require_lang_item(LangItem::Pin, DUMMY_SP);
let pin_adt_ref = tcx.adt_def(pin_did);
let pin_args = tcx.mk_args(&[env_ty.into()]);
let env_ty = match coroutine_kind {
@@ -149,7 +150,7 @@ fn fn_sig_for_fn_abi<'tcx>(
// The signature should be `Future::poll(_, &mut Context<'_>) -> Poll<Output>`
assert_eq!(sig.yield_ty, tcx.types.unit);
let poll_did = tcx.require_lang_item(LangItem::Poll, None);
let poll_did = tcx.require_lang_item(LangItem::Poll, DUMMY_SP);
let poll_adt_ref = tcx.adt_def(poll_did);
let poll_args = tcx.mk_args(&[sig.return_ty.into()]);
let ret_ty = Ty::new_adt(tcx, poll_adt_ref, poll_args);
@@ -160,7 +161,7 @@ fn fn_sig_for_fn_abi<'tcx>(
{
if let ty::Adt(resume_ty_adt, _) = sig.resume_ty.kind() {
let expected_adt =
tcx.adt_def(tcx.require_lang_item(LangItem::ResumeTy, None));
tcx.adt_def(tcx.require_lang_item(LangItem::ResumeTy, DUMMY_SP));
assert_eq!(*resume_ty_adt, expected_adt);
} else {
panic!("expected `ResumeTy`, found `{:?}`", sig.resume_ty);
@@ -172,7 +173,7 @@ fn fn_sig_for_fn_abi<'tcx>(
}
hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::Gen, _) => {
// The signature should be `Iterator::next(_) -> Option<Yield>`
let option_did = tcx.require_lang_item(LangItem::Option, None);
let option_did = tcx.require_lang_item(LangItem::Option, DUMMY_SP);
let option_adt_ref = tcx.adt_def(option_did);
let option_args = tcx.mk_args(&[sig.yield_ty.into()]);
let ret_ty = Ty::new_adt(tcx, option_adt_ref, option_args);
@@ -196,7 +197,7 @@ fn fn_sig_for_fn_abi<'tcx>(
{
if let ty::Adt(resume_ty_adt, _) = sig.resume_ty.kind() {
let expected_adt =
tcx.adt_def(tcx.require_lang_item(LangItem::ResumeTy, None));
tcx.adt_def(tcx.require_lang_item(LangItem::ResumeTy, DUMMY_SP));
assert_eq!(*resume_ty_adt, expected_adt);
} else {
panic!("expected `ResumeTy`, found `{:?}`", sig.resume_ty);
@@ -208,7 +209,7 @@ fn fn_sig_for_fn_abi<'tcx>(
}
hir::CoroutineKind::Coroutine(_) => {
// The signature should be `Coroutine::resume(_, Resume) -> CoroutineState<Yield, Return>`
let state_did = tcx.require_lang_item(LangItem::CoroutineState, None);
let state_did = tcx.require_lang_item(LangItem::CoroutineState, DUMMY_SP);
let state_adt_ref = tcx.adt_def(state_did);
let state_args = tcx.mk_args(&[sig.yield_ty.into(), sig.return_ty.into()]);
let ret_ty = Ty::new_adt(tcx, state_adt_ref, state_args);

3
compiler/rustc_ty_utils/src/common_traits.rs
View File

@@ -4,6 +4,7 @@ use rustc_hir::lang_items::LangItem;
use rustc_infer::infer::TyCtxtInferExt;
use rustc_middle::query::Providers;
use rustc_middle::ty::{self, Ty, TyCtxt};
use rustc_span::DUMMY_SP;
use rustc_trait_selection::traits;
fn is_copy_raw<'tcx>(tcx: TyCtxt<'tcx>, query: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>) -> bool {
@@ -42,7 +43,7 @@ fn is_item_raw<'tcx>(
item: LangItem,
) -> bool {
let (infcx, param_env) = tcx.infer_ctxt().build_with_typing_env(query.typing_env);
let trait_def_id = tcx.require_lang_item(item, None);
let trait_def_id = tcx.require_lang_item(item, DUMMY_SP);
traits::type_known_to_meet_bound_modulo_regions(&infcx, param_env, query.value, trait_def_id)
}

3
compiler/rustc_ty_utils/src/structural_match.rs
View File

@@ -16,8 +16,7 @@ fn has_structural_eq_impl<'tcx>(tcx: TyCtxt<'tcx>, adt_ty: Ty<'tcx>) -> bool {
let ocx = ObligationCtxt::new(infcx);
// require `#[derive(PartialEq)]`
let structural_peq_def_id =
infcx.tcx.require_lang_item(LangItem::StructuralPeq, Some(cause.span));
let structural_peq_def_id = infcx.tcx.require_lang_item(LangItem::StructuralPeq, cause.span);
ocx.register_bound(cause.clone(), ty::ParamEnv::empty(), adt_ty, structural_peq_def_id);
// We deliberately skip *reporting* fulfillment errors (via

2
compiler/rustc_ty_utils/src/ty.rs
View File

@@ -104,7 +104,7 @@ fn adt_sized_constraint<'tcx>(
// perf hack: if there is a `constraint_ty: Sized` bound, then we know
// that the type is sized and do not need to check it on the impl.
let sized_trait_def_id = tcx.require_lang_item(LangItem::Sized, None);
let sized_trait_def_id = tcx.require_lang_item(LangItem::Sized, DUMMY_SP);
let predicates = tcx.predicates_of(def.did()).predicates;
if predicates.iter().any(|(p, _)| {
p.as_trait_clause().is_some_and(|trait_pred| {

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

@@ -1277,7 +1277,7 @@ impl GenericBound {
}
fn sized_with(cx: &mut DocContext<'_>, modifiers: hir::TraitBoundModifiers) -> GenericBound {
let did = cx.tcx.require_lang_item(LangItem::Sized, None);
let did = cx.tcx.require_lang_item(LangItem::Sized, DUMMY_SP);
let empty = ty::Binder::dummy(ty::GenericArgs::empty());
let path = clean_middle_path(cx, did, false, ThinVec::new(), empty);
inline::record_extern_fqn(cx, did, ItemType::Trait);

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

@@ -439,7 +439,7 @@ fn is_ty_const_destruct<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, body: &Body<'tcx>
tcx,
ObligationCause::dummy_with_span(body.span),
param_env,
TraitRef::new(tcx, tcx.require_lang_item(LangItem::Destruct, Some(body.span)), [ty]),
TraitRef::new(tcx, tcx.require_lang_item(LangItem::Destruct, body.span), [ty]),
);
let mut selcx = SelectionContext::new(&infcx);

2
src/tools/miri/src/shims/panic.rs
View File

@@ -247,7 +247,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
_ => {
// Call the lang item associated with this message.
let fn_item = this.tcx.require_lang_item(msg.panic_function(), None);
let fn_item = this.tcx.require_lang_item(msg.panic_function(), this.tcx.span);
let instance = ty::Instance::mono(this.tcx.tcx, fn_item);
this.call_function(
instance,

3
tests/ui/lang-items/lang-item-generic-requirements.rs
View File

@@ -48,6 +48,7 @@ fn ice() {
// Use index
let arr = [0; 5];
//~^ ERROR requires `copy` lang_item
let _ = arr[2];
//~^ ERROR cannot index into a value of type `[{integer}; 5]`
@@ -61,5 +62,3 @@ fn ice() {
// use `start`
fn main() {}
//~? ERROR requires `copy` lang_item

8
tests/ui/lang-items/lang-item-generic-requirements.stderr
View File

@@ -77,13 +77,13 @@ LL | r + a;
| {integer}
error[E0608]: cannot index into a value of type `[{integer}; 5]`
--> $DIR/lang-item-generic-requirements.rs:51:16
--> $DIR/lang-item-generic-requirements.rs:52:16
|
LL | let _ = arr[2];
| ^^^
error[E0308]: mismatched types
--> $DIR/lang-item-generic-requirements.rs:58:17
--> $DIR/lang-item-generic-requirements.rs:59:17
|
LL | let _: () = Foo;
| -- ^^^ expected `()`, found `Foo`
@@ -91,6 +91,10 @@ LL | let _: () = Foo;
| expected due to this
error: requires `copy` lang_item
--> $DIR/lang-item-generic-requirements.rs:50:16
|
LL | let arr = [0; 5];
| ^
error: aborting due to 12 previous errors