Rollup of 19 pull requests

compiler/rustc_ast_lowering/src/path.rs

@@ -1,10 +1,11 @@
 use std::sync::Arc;
 
 use rustc_ast::{self as ast, *};
+use rustc_attr_ir::target::Target;
 use rustc_errors::StashKey;
 use rustc_hir::def::{DefKind, PerNS, Res};
 use rustc_hir::def_id::DefId;
-use rustc_hir::{self as hir, GenericArg};
+use rustc_hir::{self as hir, GenericArg, HirId};
 use rustc_middle::middle::resolve::PartialRes;
 use rustc_middle::ty;
 use rustc_session::diagnostics::add_feature_diagnostics;
@@ -263,6 +264,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
         bound_modifier_allowed_features: Option<Arc<[Symbol]>>,
     ) -> hir::PathSegment<'hir> {
         debug!("path_span: {:?}, lower_path_segment(segment: {:?})", path_span, segment);
+
+        let res = self.expect_full_res(segment.id);
+        let hir_id = self.lower_node_id(segment.id);
+
         let (mut generic_args, infer_args) = if let Some(generic_args) = segment.args.as_deref() {
             match generic_args {
                 GenericArgs::AngleBracketed(data) => {
@@ -315,6 +320,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             data,
                             itctx,
                             bound_modifier_allowed_features,
+                            hir_id,
                         ),
                     GenericArgsMode::Err => {
                         // Suggest replacing parentheses with angle brackets `Trait(params...)` to `Trait<params...>`
@@ -398,13 +404,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
             );
         }
 
-        let res = self.expect_full_res(segment.id);
-        let hir_id = self.lower_node_id(segment.id);
         debug!(
             "lower_path_segment: ident={:?} original-id={:?} new-id={:?}",
             segment.ident, segment.id, hir_id,
         );
-
         hir::PathSegment {
             ident: self.lower_ident(segment.ident),
             hir_id,
@@ -508,13 +511,21 @@ impl<'hir> LoweringContext<'_, 'hir> {
         data: &ParenthesizedArgs,
         itctx: ImplTraitContext,
         bound_modifier_allowed_features: Option<Arc<[Symbol]>>,
+        segment_hir_id: HirId,
     ) -> (GenericArgsCtor<'hir>, bool) {
         // Switch to `PassThrough` mode for anonymous lifetimes; this
         // means that we permit things like `&Ref<T>`, where `Ref` has
         // a hidden lifetime parameter. This is needed for backwards
         // compatibility, even in contexts like an impl header where
         // we generally don't permit such things (see #51008).
         let ParenthesizedArgs { span, inputs, inputs_span, output } = data;
+
+        // FIXME uses the segments HIR id which is not correct, it should
+        // be the parameters HIR id instead. This is currently not lowered.
+        for input in inputs {
+            self.lower_attrs(segment_hir_id, &input.attrs, input.span, Target::Param);
+        }
+
         let inputs = self.arena.alloc_from_iter(inputs.iter().map(|param| {
             self.lower_ty(&param.ty, ImplTraitContext::Disallowed(ImplTraitPosition::FnTraitParam))
         }));

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -399,7 +399,7 @@ impl<'a> AstValidator<'a> {
         self.check_decl_num_args(fn_decl);
         let c_variadic_span = self.check_decl_cvariadic_pos(fn_decl);
         self.check_decl_splatting(fn_decl, c_variadic_span, splat_semantic);
-        self.check_decl_attrs(fn_decl);
+        self.check_decl_attrs(&fn_decl.inputs);
         self.check_decl_self_param(&fn_decl.inputs, self_semantic);
         self.check_decl_const_param(&fn_decl.inputs);
     }
@@ -518,10 +518,9 @@ impl<'a> AstValidator<'a> {
         }
     }
 
-    fn check_decl_attrs(&self, fn_decl: &FnDecl) {
+    fn check_decl_attrs(&self, fn_inputs: &[Param]) {
         use SyntheticAttr::*;
-        fn_decl
-            .inputs
+        fn_inputs
             .iter()
             .flat_map(|i| i.attrs.as_ref())
             .filter(|attr| match &attr.kind {
@@ -2230,6 +2229,7 @@ impl Visitor<'_> for AstValidator<'_> {
     fn visit_path_segment(&mut self, seg: &PathSegment) -> Self::Result {
         if let Some(Parenthesized(args)) = &seg.args {
             self.check_decl_self_param(&args.inputs, SelfSemantic::No);
+            self.check_decl_attrs(&args.inputs);
             Self::check_decl_no_pat(&args.inputs, |span, _, _| {
                 self.dcx().emit_err(diagnostics::PatternParenthesizedArgList { span });
             });

compiler/rustc_attr_ir/src/data_structures.rs

@@ -859,6 +859,8 @@ pub enum AttributeKind {
     Deprecated {
         deprecation: Deprecation,
         span: Span,
+        /// `true` if this an inner attribute (ie `#![]`).
+        is_inner: bool,
     },
 
     /// Represents `#[diagnostic::do_not_recommend]`.

compiler/rustc_attr_parsing/src/attributes/deprecation.rs

@@ -210,6 +210,7 @@ impl SingleAttributeParser for DeprecatedParser {
         Some(AttributeKind::Deprecated {
             deprecation: Deprecation { since, note, suggestion },
             span: cx.attr_span,
+            is_inner: matches!(cx.attr_style, rustc_ast::AttrStyle::Inner),
         })
     }
 }

compiler/rustc_codegen_cranelift/scripts/test_rustc_tests.sh

@@ -161,9 +161,7 @@ rm -r tests/run-make-cargo/panic-immediate-abort-codegen # same
 rm -r tests/run-make-cargo/panic-strategies # same
 rm -r tests/run-make/missing-unstable-trait-bound # This disables support for unstable features, but running cg_clif needs some unstable features
 rm -r tests/run-make/const-trait-stable-toolchain # same
-rm -r tests/run-make/print-request-help-stable-unstable # same
 rm -r tests/run-make/issue-149402-suggest-unresolve # same
-rm -r tests/run-make/const-destruct-stable-toolchain # same
 rm -r tests/run-make/unstable-target-feature # same
 rm -r tests/run-make/incr-add-rust-src-component
 rm tests/ui/errors/remap-path-prefix-sysroot.rs # different sysroot source path

compiler/rustc_codegen_cranelift/src/driver/aot.rs

@@ -22,8 +22,8 @@ use rustc_errors::{DiagCtxt, DiagCtxtHandle};
 use rustc_middle::dep_graph::WorkProduct;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::mono::{MonoItem, MonoItemData, Visibility};
-use rustc_session::Session;
 use rustc_session::config::{OptLevel, OutputFilenames, OutputType};
+use rustc_session::{BorrowedIncrCompSession, Session};
 use rustc_span::Symbol;
 
 use crate::base::CodegenedFunction;
@@ -341,6 +341,7 @@ impl WriteBackendMethods for AotDriver {
     fn run_thin_lto(
         _cgcx: &CodegenContext,
         _prof: &SelfProfilerRef,
+        _incr_comp_session: Option<&BorrowedIncrCompSession>,
         _dcx: rustc_errors::DiagCtxtHandle<'_>,
         _exported_symbols_for_lto: &[String],
         _each_linked_rlib_for_lto: &[PathBuf],

compiler/rustc_codegen_gcc/src/lib.rs

@@ -92,7 +92,9 @@ use rustc_errors::{DiagCtxt, DiagCtxtHandle};
 use rustc_middle::dep_graph::{WorkProduct, WorkProductMap};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::config::{OptLevel, OutputFilenames};
-use rustc_session::{CodegenBackendInit, EarlySession, IncrCompSession, Session};
+use rustc_session::{
+    BorrowedIncrCompSession, CodegenBackendInit, EarlySession, IncrCompSession, Session,
+};
 use rustc_span::{Symbol, sym};
 use rustc_target::spec::{RelocModel, TargetTuple};
 use tempfile::TempDir;
@@ -427,6 +429,7 @@ impl WriteBackendMethods for GccCodegenBackend {
     fn run_thin_lto(
         _cgcx: &CodegenContext,
         _prof: &SelfProfilerRef,
+        _incr_comp_session: Option<&BorrowedIncrCompSession>,
         _dcx: DiagCtxtHandle<'_>,
         // FIXME(bjorn3): Limit LTO exports to these symbols
         _exported_symbols_for_lto: &[String],

compiler/rustc_codegen_llvm/src/back/llvm_backend.rs

@@ -23,7 +23,9 @@ use rustc_metadata::EncodedMetadata;
 use rustc_middle::dep_graph::{WorkProduct, WorkProductMap};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::config::{OptLevel, OutputFilenames, PrintKind, PrintRequest};
-use rustc_session::{CodegenBackendInit, EarlySession, IncrCompSession, Session};
+use rustc_session::{
+    BorrowedIncrCompSession, CodegenBackendInit, EarlySession, IncrCompSession, Session,
+};
 use rustc_span::{Symbol, sym};
 use rustc_target::spec::{RelocModel, TlsModel};
 
@@ -122,6 +124,7 @@ impl WriteBackendMethods for LlvmCodegenBackend {
     fn run_thin_lto(
         cgcx: &CodegenContext,
         prof: &SelfProfilerRef,
+        incr_comp_session: Option<&BorrowedIncrCompSession>,
         dcx: DiagCtxtHandle<'_>,
         exported_symbols_for_lto: &[String],
         each_linked_rlib_for_lto: &[PathBuf],
@@ -130,6 +133,7 @@ impl WriteBackendMethods for LlvmCodegenBackend {
         back::lto::run_thin(
             cgcx,
             prof,
+            incr_comp_session,
             dcx,
             exported_symbols_for_lto,
             each_linked_rlib_for_lto,
@@ -381,21 +385,35 @@ impl CodegenBackend for LlvmCodegenBackend {
             });
         }
 
-        (compiled_modules, work_products)
-    }
+        if sess.codegen_units().as_usize() == 1 && sess.opts.unstable_opts.time_llvm_passes {
+            let timings =
+                llvm::build_string(|s| unsafe { llvm::LLVMRustPrintPassTimings(s) }).unwrap();
+            print!("{timings}");
+        }
 
-    fn print_pass_timings(&self) {
-        let timings = llvm::build_string(|s| unsafe { llvm::LLVMRustPrintPassTimings(s) }).unwrap();
-        print!("{timings}");
-    }
+        if sess.print_llvm_stats() {
+            let stats =
+                llvm::build_string(|s| unsafe { llvm::LLVMRustPrintStatistics(s) }).unwrap();
+            print!("{stats}");
+        }
 
-    fn print_statistics(&self) {
-        let stats = llvm::build_string(|s| unsafe { llvm::LLVMRustPrintStatistics(s) }).unwrap();
-        print!("{stats}");
-    }
+        if let Some(out_path) = sess.print_llvm_stats_json() {
+            let llvm_stats_json =
+                llvm::build_string(|s| unsafe { llvm::LLVMRustPrintStatisticsJSON(s) }).unwrap();
+
+            if !llvm_stats_json.is_empty() {
+                if let Err(e) = std::fs::write(&out_path, llvm_stats_json) {
+                    sess.dcx().err(format!("failed to write stats to {out_path}: {e}"));
+                }
+            } else {
+                sess.dcx().warn(format!(
+                    "requested to print LLVM statistics to JSON file {out_path}, but the codegen backend \
+                    did not provide any statistics",
+                ));
+            }
+        }
 
-    fn print_statistics_json(&self) -> String {
-        llvm::build_string(|s| unsafe { llvm::LLVMRustPrintStatisticsJSON(s) }).unwrap()
+        (compiled_modules, work_products)
     }
 
     fn link(

compiler/rustc_codegen_llvm/src/back/lto.rs

@@ -19,7 +19,7 @@ use rustc_data_structures::memmap::Mmap;
 use rustc_data_structures::profiling::SelfProfilerRef;
 use rustc_errors::{DiagCtxt, DiagCtxtHandle};
 use rustc_middle::dep_graph::WorkProduct;
-use rustc_session::config;
+use rustc_session::{BorrowedIncrCompSession, config};
 use rustc_span::bug;
 use rustc_structures::SanitizerSet;
 use tracing::{debug, info};
@@ -186,6 +186,7 @@ pub(crate) fn run_fat(
 pub(crate) fn run_thin(
     cgcx: &CodegenContext,
     prof: &SelfProfilerRef,
+    incr_comp_session: Option<&BorrowedIncrCompSession>,
     dcx: DiagCtxtHandle<'_>,
     exported_symbols_for_lto: &[String],
     each_linked_rlib_for_lto: &[PathBuf],
@@ -201,7 +202,7 @@ pub(crate) fn run_thin(
                       is deferred to the linker"
         );
     }
-    thin_lto(cgcx, prof, dcx, modules, upstream_modules, &symbols_below_threshold)
+    thin_lto(prof, incr_comp_session, dcx, modules, upstream_modules, &symbols_below_threshold)
 }
 
 fn fat_lto(
@@ -368,8 +369,8 @@ fn fat_lto(
 /// all of the `LtoModuleCodegen` units returned below and destroyed once
 /// they all go out of scope.
 fn thin_lto(
-    cgcx: &CodegenContext,
     prof: &SelfProfilerRef,
+    incr_comp_session: Option<&BorrowedIncrCompSession>,
     dcx: DiagCtxtHandle<'_>,
     modules: Vec<ThinLtoInput<LlvmCodegenBackend>>,
     serialized_modules: Vec<(SerializedModule<ModuleBuffer>, CString)>,
@@ -460,13 +461,12 @@ fn thin_lto(
 
         info!("thin LTO data created");
 
-        let new_key_map_path = cgcx
-            .new_incr_comp_session_dir
-            .as_ref()
-            .map(|dir| dir.join(THIN_LTO_KEYS_INCR_COMP_FILE_NAME));
+        let new_key_map_path = incr_comp_session.as_ref().map(|incr_comp_session| {
+            incr_comp_session.new_session_directory.join(THIN_LTO_KEYS_INCR_COMP_FILE_NAME)
+        });
 
-        let prev_key_map = if let Some(ref old_incr_comp_session_dir) =
-            cgcx.old_incr_comp_session_dir
+        let prev_key_map = if let Some(ref old_incr_comp_session_dir) = incr_comp_session
+            .and_then(|incr_comp_session| incr_comp_session.old_session_directory.as_deref())
         {
             let old_path = old_incr_comp_session_dir.join(THIN_LTO_KEYS_INCR_COMP_FILE_NAME);
 
@@ -478,7 +478,7 @@ fn thin_lto(
             assert!(green_modules.is_empty());
             None
         };
-        let curr_key_map = if cgcx.new_incr_comp_session_dir.is_some() {
+        let curr_key_map = if incr_comp_session.is_some() {
             ThinLTOKeysMap::from_thin_lto_modules(&data, &thin_modules, &module_names)
         } else {
             assert!(green_modules.is_empty());
@@ -503,8 +503,7 @@ fn thin_lto(
             if let (Some(prev_key_map), true) =
                 (prev_key_map.as_ref(), green_modules.contains_key(module_name))
             {
-                assert!(cgcx.old_incr_comp_session_dir.is_some());
-                assert!(cgcx.new_incr_comp_session_dir.is_some());
+                assert!(incr_comp_session.unwrap().old_session_directory.is_some());
 
                 // If a module exists in both the current and the previous session,
                 // and has the same LTO cache key in both sessions, then we can re-use it

compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs

@@ -6,6 +6,7 @@ use std::{assert_matches, iter, ptr};
 
 use libc::{c_longlong, c_uint};
 use rustc_abi::{Align, Endian, Layout, NumScalableVectors, Size};
+use rustc_ast::{IntTy, UintTy};
 use rustc_codegen_ssa::debuginfo::type_names::{VTableNameKind, cpp_like_debuginfo};
 use rustc_codegen_ssa::traits::*;
 use rustc_hir::def::{CtorKind, DefKind};
@@ -794,9 +795,50 @@ fn build_basic_type_di_node<'ll, 'tcx>(
         _ => bug!("debuginfo::build_basic_type_di_node - `t` is invalid type"),
     };
 
-    let ty_di_node = create_basic_type(cx, name, cx.size_of(t), encoding);
+    // Around LLDB 21 or 22, LLDB started using prebuilt Clang type nodes for primitives rather than
+    // reading the full DWARF data. These nodes are based on the size and signedness of the
+    // primitive, and ignore pretty much all other fields. This causes 2 issues:
+    // 1. type names get normalized to C-style names which isn't ideal. The normalization occurs
+    // even in generic args.
+    // 2. if you have a generic type `S<T>`, and 2 instantiations are `S<u64>`
+    // and `S<usize>` (on a 64-bit target), the use of prebuilt nodes causes a name collision.
+    // Whichever instantiation is interacted with first will work fine, all others will break a
+    // bunch of stuff in the LLDB pipeline. To avoid this, we explicitly treat `usize` and `isize`
+    // as typedefs of their equivalent types. For more info see: llvm/llvm-project#196812
+
+    let mut needs_typedef = cpp_like_debuginfo;
+
+    let ty_di_node = match t.kind() {
+        ty::Uint(UintTy::Usize) => {
+            needs_typedef = true;
+
+            let equivalent = match t.primitive_size(cx.tcx).bits() {
+                8 => cx.tcx.types.u8,
+                16 => cx.tcx.types.u16,
+                32 => cx.tcx.types.u32,
+                64 => cx.tcx.types.u64,
+                128 => cx.tcx.types.u128,
+                x => bug!("Unexpected signed int size {x}"),
+            };
+            type_di_node(cx, equivalent)
+        }
+        ty::Int(IntTy::Isize) => {
+            needs_typedef = true;
+
+            let equivalent = match t.primitive_size(cx.tcx).bits() {
+                8 => cx.tcx.types.i8,
+                16 => cx.tcx.types.i16,
+                32 => cx.tcx.types.i32,
+                64 => cx.tcx.types.i64,
+                128 => cx.tcx.types.i128,
+                x => bug!("Unexpected signed int size: {x}"),
+            };
+            type_di_node(cx, equivalent)
+        }
+        _ => create_basic_type(cx, name, cx.size_of(t), encoding),
+    };
 
-    if !cpp_like_debuginfo {
+    if !needs_typedef {
         return DINodeCreationResult::new(ty_di_node, false);
     }
 

compiler/rustc_codegen_ssa/src/assert_module_sources.rs

@@ -111,7 +111,7 @@ impl<'tcx> AssertModuleSource<'tcx> {
 
             if !self.check_config(cfg) {
                 debug!("check_attr: config does not match, ignoring attr");
-                return;
+                continue;
             }
 
             let user_path = module.as_str();