Rollup of 7 pull requests

compiler/rustc_attr_ir/src/data_structures.rs

@@ -589,6 +589,7 @@ pub enum RustcDumpLayoutKind {
 #[derive(Clone, Debug, StableHash, Encodable, Decodable, PrintAttribute, PartialEq, Eq)]
 pub enum RustcMirKind {
     PrettyLiveLocals,
+    PrettyPreciseLiveness,
     PrettyTransitiveLiveLocals,
     PeekMaybeInit,
     PeekMaybeUninit,

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -672,6 +672,10 @@ impl CombineAttributeParser for RustcMirParser {
                             cx.expect_no_args(mi.args())?;
                             Some(RustcMirKind::PrettyLiveLocals)
                         }
+                        sym::rustc_pretty_precise_liveness => {
+                            cx.expect_no_args(mi.args())?;
+                            Some(RustcMirKind::PrettyPreciseLiveness)
+                        }
                         sym::rustc_pretty_transitive_live_locals => {
                             cx.expect_no_args(mi.args())?;
                             Some(RustcMirKind::PrettyTransitiveLiveLocals)

compiler/rustc_codegen_cranelift/src/abi/mod.rs

@@ -16,7 +16,7 @@ use rustc_abi::{CanonAbi, ExternAbi, X86Call};
 use rustc_codegen_ssa::base::is_call_from_compiler_builtins_to_upstream_monomorphization;
 use rustc_codegen_ssa::diagnostics::CompilerBuiltinsCannotCall;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
-use rustc_middle::ty::layout::FnAbiOf;
+use rustc_middle::ty::layout::{FnAbiOf, HasTypingEnv as _};
 use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_middle::ty::{ShimKind, TypeVisitableExt};
 use rustc_session::Session;
@@ -441,7 +441,7 @@ pub(crate) fn codegen_terminator_call<'tcx>(
     let instance = if let ty::FnDef(def_id, fn_args) = *func.layout().ty.kind() {
         let instance = ty::Instance::expect_resolve(
             fx.tcx,
-            ty::TypingEnv::fully_monomorphized(),
+            fx.typing_env(),
             def_id,
             fn_args.no_bound_vars().unwrap(),
             source_info.span,

compiler/rustc_codegen_cranelift/src/base.rs

@@ -720,7 +720,7 @@ fn codegen_stmt<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, cur_block: Block, stmt:
                             let func_ref = fx.get_function_ref(
                                 Instance::resolve_for_fn_ptr(
                                     fx.tcx,
-                                    ty::TypingEnv::fully_monomorphized(),
+                                    fx.typing_env(),
                                     def_id,
                                     args.no_bound_vars().unwrap(),
                                 )
@@ -771,8 +771,7 @@ fn codegen_stmt<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, cur_block: Block, stmt:
 
                     fn is_wide_ptr<'tcx>(fx: &FunctionCx<'_, '_, 'tcx>, ty: Ty<'tcx>) -> bool {
                         ty.builtin_deref(true).is_some_and(|pointee_ty| {
-                            fx.tcx
-                                .type_has_metadata(pointee_ty, ty::TypingEnv::fully_monomorphized())
+                            fx.tcx.type_has_metadata(pointee_ty, fx.typing_env())
                         })
                     }
 

compiler/rustc_codegen_cranelift/src/common.rs

@@ -4,8 +4,8 @@ use rustc_abi::{Float, Integer, Primitive};
 use rustc_index::IndexVec;
 use rustc_middle::ty::TypeFoldable;
 use rustc_middle::ty::layout::{
-    self, FnAbiError, FnAbiOfHelpers, FnAbiRequest, LayoutError, LayoutOfHelpers,
-    codegen_handle_fn_abi_err,
+    self, FnAbiError, FnAbiOfHelpers, FnAbiRequest, HasTypingEnv as _, LayoutError,
+    LayoutOfHelpers, codegen_handle_fn_abi_err,
 };
 use rustc_span::Symbol;
 use rustc_target::callconv::FnAbi;
@@ -351,7 +351,7 @@ impl<'tcx> FunctionCx<'_, '_, 'tcx> {
     {
         self.instance.instantiate_mir_and_normalize_erasing_regions(
             self.tcx,
-            ty::TypingEnv::fully_monomorphized(),
+            self.typing_env(),
             ty::EarlyBinder::bind(self.tcx, value),
         )
     }

compiler/rustc_codegen_cranelift/src/constant.rs

@@ -9,6 +9,7 @@ use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::mir::interpret::{
     AllocId, GlobalAlloc, PointerArithmetic, Scalar, read_target_uint,
 };
+use rustc_middle::ty::layout::HasTypingEnv as _;
 use rustc_middle::ty::{ExistentialTraitRef, ScalarInt};
 
 use crate::prelude::*;
@@ -81,7 +82,7 @@ pub(crate) fn eval_mir_constant<'tcx>(
     let cv = fx.monomorphize(constant.const_);
     // This cannot fail because we checked all required_consts in advance.
     let val = cv
-        .eval(fx.tcx, ty::TypingEnv::fully_monomorphized(), constant.span)
+        .eval(fx.tcx, fx.typing_env(), constant.span)
         .expect("erroneous constant missed by mono item collection");
     (val, cv.ty())
 }

compiler/rustc_codegen_cranelift/src/inline_asm.rs

@@ -7,7 +7,7 @@ use rustc_abi::CanonAbi;
 use rustc_ast::ast::{InlineAsmOptions, InlineAsmTemplatePiece};
 use rustc_attr_ir::lang_items::LangItem;
 use rustc_middle::mir::interpret::{GlobalAlloc, PointerArithmetic, Scalar as ConstScalar};
-use rustc_middle::ty::layout::FnAbiOf;
+use rustc_middle::ty::layout::{FnAbiOf, HasTypingEnv as _};
 use rustc_span::sym;
 use rustc_target::asm::*;
 use rustc_target::spec::Arch;
@@ -175,7 +175,7 @@ pub(crate) fn codegen_inline_asm_terminator<'tcx>(
                 if let ty::FnDef(def_id, args) = *const_.ty().kind() {
                     let instance = ty::Instance::resolve_for_fn_ptr(
                         fx.tcx,
-                        ty::TypingEnv::fully_monomorphized(),
+                        fx.typing_env(),
                         def_id,
                         args.no_bound_vars().unwrap(),
                     )

compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs

@@ -22,7 +22,7 @@ use cranelift_codegen::ir::{
 };
 use rustc_middle::ty;
 use rustc_middle::ty::GenericArgsRef;
-use rustc_middle::ty::layout::ValidityRequirement;
+use rustc_middle::ty::layout::{HasTypingEnv as _, ValidityRequirement};
 use rustc_middle::ty::print::{with_no_trimmed_paths, with_no_visible_paths};
 use rustc_span::{Spanned, Symbol, sym};
 use rustc_target::spec::PanicStrategy;
@@ -729,10 +729,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
             if let Some(requirement) = requirement {
                 let do_panic = !fx
                     .tcx
-                    .check_validity_requirement((
-                        requirement,
-                        ty::TypingEnv::fully_monomorphized().as_query_input(ty),
-                    ))
+                    .check_validity_requirement((requirement, fx.typing_env().as_query_input(ty)))
                     .expect("expect to have layout during codegen");
 
                 if do_panic {

compiler/rustc_codegen_cranelift/src/num.rs

@@ -1,5 +1,7 @@
 //! Various operations on integer and floating-point numbers
 
+use rustc_middle::ty::layout::HasTypingEnv as _;
+
 use crate::codegen_f16_f128;
 use crate::prelude::*;
 
@@ -437,7 +439,7 @@ fn codegen_ptr_binop<'tcx>(
         .layout()
         .ty
         .builtin_deref(true)
-        .map(|ty| !fx.tcx.type_has_metadata(ty, ty::TypingEnv::fully_monomorphized()))
+        .map(|ty| !fx.tcx.type_has_metadata(ty, fx.typing_env()))
         .unwrap_or(true);
 
     if is_thin_ptr {

compiler/rustc_codegen_cranelift/src/value_and_place.rs

@@ -693,7 +693,7 @@ impl<'tcx> CPlace<'tcx> {
         };
 
         let (field_ptr, field_layout) = codegen_field(fx, base, extra, layout, field);
-        if fx.tcx.type_has_metadata(field_layout.ty, ty::TypingEnv::fully_monomorphized()) {
+        if fx.tcx.type_has_metadata(field_layout.ty, fx.typing_env()) {
             CPlace::for_ptr_with_extra(field_ptr, extra.unwrap(), field_layout)
         } else {
             CPlace::for_ptr(field_ptr, field_layout)
@@ -808,7 +808,7 @@ impl<'tcx> CPlace<'tcx> {
 
     pub(crate) fn place_deref(self, fx: &mut FunctionCx<'_, '_, 'tcx>) -> CPlace<'tcx> {
         let inner_layout = fx.layout_of(self.layout().ty.builtin_deref(true).unwrap());
-        if fx.tcx.type_has_metadata(inner_layout.ty, ty::TypingEnv::fully_monomorphized()) {
+        if fx.tcx.type_has_metadata(inner_layout.ty, fx.typing_env()) {
             let (addr, extra) = self.to_cvalue(fx).load_scalar_pair(fx);
             CPlace::for_ptr_with_extra(Pointer::new(addr), extra, inner_layout)
         } else {
@@ -821,7 +821,7 @@ impl<'tcx> CPlace<'tcx> {
         fx: &mut FunctionCx<'_, '_, 'tcx>,
         layout: TyAndLayout<'tcx>,
     ) -> CValue<'tcx> {
-        if fx.tcx.type_has_metadata(self.layout().ty, ty::TypingEnv::fully_monomorphized()) {
+        if fx.tcx.type_has_metadata(self.layout().ty, fx.typing_env()) {
             let (ptr, extra) = self.to_ptr_unsized();
             CValue::by_val_pair(ptr.get_addr(fx), extra, layout)
         } else {

compiler/rustc_codegen_gcc/src/consts.rs

@@ -16,8 +16,8 @@ use rustc_middle::mir::interpret::{
     self, ConstAllocation, CtfeProvenance, ErrorHandled, Scalar as InterpScalar, read_target_uint,
 };
 use rustc_middle::mono::MonoItem;
-use rustc_middle::ty::layout::LayoutOf;
-use rustc_middle::ty::{self, Instance};
+use rustc_middle::ty::Instance;
+use rustc_middle::ty::layout::{HasTypingEnv as _, LayoutOf};
 use rustc_span::def_id::DefId;
 use rustc_span::{bug, span_bug};
 
@@ -251,7 +251,7 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
         let gcc_type = if nested {
             self.type_i8()
         } else {
-            let ty = instance.ty(self.tcx, ty::TypingEnv::fully_monomorphized());
+            let ty = instance.ty(self.tcx, self.typing_env());
             self.layout_of(ty).gcc_type(self)
         };
 

compiler/rustc_codegen_gcc/src/int.rs

@@ -10,7 +10,8 @@ use gccjit::{
 use rustc_abi::{CanonAbi, Endian, ExternAbi};
 use rustc_codegen_ssa::common::{IntPredicate, TypeKind};
 use rustc_codegen_ssa::traits::{BackendTypes, BaseTypeCodegenMethods, BuilderMethods, OverflowOp};
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::Ty;
+use rustc_middle::ty::layout::HasTypingEnv as _;
 use rustc_target::callconv::{ArgAbi, ArgAttributes, FnAbi, PassMode};
 use rustc_type_ir::{Interner, TyKind};
 
@@ -387,10 +388,7 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
             128 => self.tcx.types.i128,
             _ => unreachable!("unexpected integer size"),
         };
-        let layout = self
-            .tcx
-            .layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(res_ty))
-            .unwrap();
+        let layout = self.tcx.layout_of(self.cx.typing_env().as_query_input(res_ty)).unwrap();
 
         let arg_abi = ArgAbi { layout, mode: PassMode::Direct(ArgAttributes::new()) };
         let mut fn_abi = FnAbi {

compiler/rustc_codegen_gcc/src/intrinsic/simd.rs

@@ -16,7 +16,7 @@ use rustc_codegen_ssa::traits::{BaseTypeCodegenMethods, BuilderMethods, LayoutTy
 use rustc_hir as hir;
 use rustc_middle::mir::BinOp;
 use rustc_middle::ty::consts::ConstExt;
-use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf};
+use rustc_middle::ty::layout::{HasTyCtxt, HasTypingEnv as _, LayoutOf};
 use rustc_middle::ty::{self, Ty};
 use rustc_span::{ErrorGuaranteed, Span, Symbol, span_bug, sym};
 
@@ -540,7 +540,7 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
         match *in_elem.kind() {
             ty::RawPtr(p_ty, _) => {
                 let metadata = p_ty.ptr_metadata_ty(bx.tcx, |ty| {
-                    bx.tcx.normalize_erasing_regions(ty::TypingEnv::fully_monomorphized(), ty)
+                    bx.tcx.normalize_erasing_regions(bx.typing_env(), ty)
                 });
                 require!(
                     metadata.is_unit(),
@@ -554,7 +554,7 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
         match *out_elem.kind() {
             ty::RawPtr(p_ty, _) => {
                 let metadata = p_ty.ptr_metadata_ty(bx.tcx, |ty| {
-                    bx.tcx.normalize_erasing_regions(ty::TypingEnv::fully_monomorphized(), ty)
+                    bx.tcx.normalize_erasing_regions(bx.typing_env(), ty)
                 });
                 require!(
                     metadata.is_unit(),

compiler/rustc_codegen_llvm/src/builder/autodiff.rs

@@ -10,7 +10,7 @@ use rustc_codegen_ssa::mir::place::PlaceValue;
 use rustc_codegen_ssa::traits::{BaseTypeCodegenMethods, BuilderMethods, ReturnSlot};
 use rustc_data_structures::thin_vec::ThinVec;
 use rustc_middle::ty;
-use rustc_middle::ty::{PseudoCanonicalInput, Ty, TyCtxt, TypingEnv};
+use rustc_middle::ty::{Ty, TyCtxt, TypingEnv};
 use rustc_span::bug;
 use rustc_target::callconv::PassMode;
 use tracing::debug;
@@ -50,12 +50,8 @@ pub(crate) fn adjust_activity_to_abi<'tcx>(
             if let ty::Slice(element_ty) = tail_ty.kind() {
                 // Now we need to figure out the size of each slice element in memory to allow
                 // safety checks and usability improvements in the backend.
-                let pci = PseudoCanonicalInput {
-                    typing_env: TypingEnv::fully_monomorphized(),
-                    value: *element_ty,
-                };
 
-                let layout = tcx.layout_of(pci);
+                let layout = tcx.layout_of(typing_env.as_query_input(*element_ty));
                 let elem_size = match layout {
                     Ok(layout) => layout.size,
                     Err(_) => {
@@ -91,9 +87,7 @@ pub(crate) fn adjust_activity_to_abi<'tcx>(
             }
         }
 
-        let pci = PseudoCanonicalInput { typing_env: TypingEnv::fully_monomorphized(), value: *ty };
-
-        let layout = match tcx.layout_of(pci) {
+        let layout = match tcx.layout_of(typing_env.as_query_input(*ty)) {
             Ok(layout) => layout.layout,
             Err(_) => {
                 bug!("failed to compute layout for type {:?}", ty);

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -22,7 +22,7 @@ use rustc_middle::mir::BinOp;
 use rustc_middle::ty::consts::ConstExt;
 use rustc_middle::ty::layout::{FnAbiOf, HasTyCtxt, HasTypingEnv, LayoutOf};
 use rustc_middle::ty::offload_meta::OffloadMetadata;
-use rustc_middle::ty::{self, GenericArgsRef, Instance, SimdAlign, Ty, TyCtxt, TypingEnv};
+use rustc_middle::ty::{self, GenericArgsRef, Instance, SimdAlign, Ty, TyCtxt};
 use rustc_session::diagnostics::feature_err;
 use rustc_span::{ErrorGuaranteed, Span, Symbol, bug, span_bug, sym};
 use rustc_structures::CrateType;
@@ -1886,7 +1886,7 @@ fn codegen_autodiff<'ll, 'tcx>(
     adjust_activity_to_abi(
         tcx,
         source_fn_ptr_ty,
-        TypingEnv::fully_monomorphized(),
+        bx.cx.typing_env(),
         &mut diff_attrs.input_activity,
     );
 

compiler/rustc_codegen_ssa/src/base.rs

@@ -451,7 +451,7 @@ where
                     let instance = match ty.kind() {
                         &ty::FnDef(def_id, args) => Instance::expect_resolve(
                             cx.tcx(),
-                            ty::TypingEnv::fully_monomorphized(),
+                            cx.typing_env(),
                             def_id,
                             args.no_bound_vars().unwrap(),
                             expr.span,

compiler/rustc_codegen_ssa/src/mir/mod.rs

@@ -222,7 +222,7 @@ pub fn codegen_mir<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
     if tcx.features().ergonomic_clones() {
         let monomorphized_mir = instance.instantiate_mir_and_normalize_erasing_regions(
             tcx,
-            ty::TypingEnv::fully_monomorphized(),
+            cx.typing_env(),
             ty::EarlyBinder::bind(tcx, mir.clone()),
         );
         mir = tcx.arena.alloc(optimize_use_clone::<Bx>(cx, monomorphized_mir));

compiler/rustc_driver_impl/src/lib.rs

@@ -391,7 +391,7 @@ fn make_input(early_dcx: &EarlyDiagCtxt, free_matches: &[String]) -> Option<Inpu
                     .early_fatal("couldn't read from stdin, as it did not contain valid UTF-8");
             }
 
-            let name = match env::var("UNSTABLE_RUSTDOC_TEST_PATH") {
+            match env::var("UNSTABLE_RUSTDOC_TEST_PATH") {
                 Ok(path) => {
                     let line = env::var("UNSTABLE_RUSTDOC_TEST_LINE").expect(
                         "when UNSTABLE_RUSTDOC_TEST_PATH is set \
@@ -400,12 +400,13 @@ fn make_input(early_dcx: &EarlyDiagCtxt, free_matches: &[String]) -> Option<Inpu
                     let line = line
                         .parse::<isize>()
                         .expect("UNSTABLE_RUSTDOC_TEST_LINE needs to be a number");
-                    FileName::doc_test_source_code(PathBuf::from(path), line)
+                    Some(Input::DocTestStr { file: PathBuf::from(path), line, input })
                 }
-                Err(_) => FileName::anon_source_code(&input),
-            };
-
-            Some(Input::Str { name, input })
+                Err(_) => {
+                    let name = FileName::anon_source_code(&input);
+                    Some(Input::Str { name, input })
+                }
+            }
         }
         [ifile] => Some(Input::File(PathBuf::from(ifile))),
         [ifile1, ifile2, ..] => early_dcx.early_fatal(format!(
@@ -619,7 +620,7 @@ fn list_metadata(sess: &Session, metadata_loader: &dyn MetadataLoader) {
             }
             safe_println!("{}", String::from_utf8(v).unwrap());
         }
-        Input::Str { .. } => {
+        Input::Str { .. } | Input::DocTestStr { .. } => {
             sess.dcx().fatal("cannot list metadata for stdin");
         }
     }
@@ -1373,12 +1374,14 @@ fn parse_crate_attrs<'a>(sess: &'a Session) -> PResult<'a, ast::AttrVec> {
         Input::File(file) => {
             new_parser_from_file(&sess.psess, file, StripTokens::ShebangAndFrontmatter, None)
         }
-        Input::Str { name, input } => new_parser_from_source_str(
-            &sess.psess,
-            name.clone(),
-            input.clone(),
-            StripTokens::ShebangAndFrontmatter,
-        ),
+        instr @ (Input::Str { input, .. } | Input::DocTestStr { input, .. }) => {
+            new_parser_from_source_str(
+                &sess.psess,
+                instr.file_name(sess),
+                input.clone(),
+                StripTokens::ShebangAndFrontmatter,
+            )
+        }
     });
     parser.parse_inner_attributes()
 }

compiler/rustc_hir_typeck/src/upvar.rs

@@ -1867,7 +1867,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
 
             // Anything else would be completely captured and therefore handled already.
-            _ => unreachable!(),
+            _ => unreachable!("unexpected base_path_ty: {base_path_ty:?}",),
         }
     }