Rollup of 13 pull requests

Cargo.lock

@@ -3570,9 +3570,9 @@ dependencies = [
 
 [[package]]
 name = "rustc-demangle"
-version = "0.1.27"
+version = "0.1.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b50b8869d9fc858ce7266cce0194bd74df58b9d0e3f6df3a9fc8eb470d95c09d"
+checksum = "b74b56ffa8bb2830709a538c2cbcae9aa062db0d2a42563bfb09bdaae44020eb"
 
 [[package]]
 name = "rustc-hash"

compiler/rustc_ast/src/visit.rs

@@ -323,7 +323,7 @@ macro_rules! common_visitor_and_walkers {
             Closure(&'a $($mut)? ClosureBinder, &'a $($mut)? Option<CoroutineKind>, &'a $($mut)? Box<FnDecl>, &'a $($mut)? Box<Expr>),
         }
 
-        impl<'a> FnKind<'a> {
+        impl<'a> FnKind<'_> {
             pub fn header(&'a $($mut)? self) -> Option<&'a $($mut)? FnHeader> {
                 match *self {
                     FnKind::Fn(_, _, Fn { sig, .. }) => Some(&$($mut)? sig.header),

compiler/rustc_ast_lowering/src/diagnostics.rs

@@ -365,6 +365,7 @@ pub(crate) struct MatchArmWithNoBody {
     pub span: Span,
     #[suggestion(
         "add a body after the pattern",
+        // ignore-tidy-todo
         code = " => todo!(),",
         applicability = "has-placeholders"
     )]

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -1517,7 +1517,7 @@ impl Visitor<'_> for AstValidator<'_> {
                 }
                 visit::walk_item(self, item)
             }
-            ItemKind::Struct(ident, generics, vdata) => {
+            ItemKind::Struct(.., vdata) => {
                 self.with_tilde_const(Some(TildeConstReason::Struct { span: item.span }), |this| {
                     // Scalable vectors can only be tuple structs
                     let scalable_vector_attr =
@@ -1536,29 +1536,15 @@ impl Visitor<'_> for AstValidator<'_> {
                         }
                     }
 
-                    match vdata {
-                        VariantData::Struct { fields, .. } => {
-                            this.visit_attrs_vis_ident(&item.attrs, &item.vis, ident);
-                            this.visit_generics(generics);
-                            walk_list!(this, visit_field_def, fields);
-                        }
-                        _ => visit::walk_item(this, item),
-                    }
+                    visit::walk_item(this, item);
                 })
             }
-            ItemKind::Union(ident, generics, vdata) => {
+            ItemKind::Union(.., vdata) => {
                 if vdata.fields().is_empty() {
                     self.dcx().emit_err(diagnostics::FieldlessUnion { span: item.span });
                 }
                 self.with_tilde_const(Some(TildeConstReason::Union { span: item.span }), |this| {
-                    match vdata {
-                        VariantData::Struct { fields, .. } => {
-                            this.visit_attrs_vis_ident(&item.attrs, &item.vis, ident);
-                            this.visit_generics(generics);
-                            walk_list!(this, visit_field_def, fields);
-                        }
-                        _ => visit::walk_item(this, item),
-                    }
+                    visit::walk_item(this, item)
                 });
             }
             ItemKind::Const(ConstItem { defaultness, ident, rhs_kind, .. }) => {

compiler/rustc_ast_passes/src/diagnostics.rs

@@ -999,6 +999,7 @@ pub(crate) struct MatchArmWithNoBody {
     // resulting code to be correct.
     #[suggestion(
         "add a body after the pattern",
+        // ignore-tidy-todo
         code = " => {{ todo!() }}",
         applicability = "has-placeholders",
         style = "verbose"

compiler/rustc_attr_parsing/src/attributes/test_attrs.rs

@@ -214,3 +214,14 @@ impl SingleAttributeParser for RustcTestMarkerParser {
         Some(AttributeKind::RustcTestMarker(value_str))
     }
 }
+
+pub(crate) struct RustcTestEntrypointMarkerParser;
+
+impl NoArgsAttributeParser for RustcTestEntrypointMarkerParser {
+    const PATH: &[Symbol] = &[sym::rustc_test_entrypoint_marker];
+    const ALLOWED_TARGETS: AllowedTargets<'_> =
+        AllowedTargets::AllowList(&[Allow(Target::Fn), Allow(Target::Closure)]);
+    const ON_DUPLICATE: OnDuplicate = OnDuplicate::Warn;
+    const STABILITY: AttributeStability = unstable!(rustc_attrs);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcTestEntrypointMarker;
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -328,6 +328,7 @@ attribute_parsers!(
         Single<WithoutArgs<RustcSpecializationTraitParser>>,
         Single<WithoutArgs<RustcStdInternalSymbolParser>>,
         Single<WithoutArgs<RustcStrictCoherenceParser>>,
+        Single<WithoutArgs<RustcTestEntrypointMarkerParser>>,
         Single<WithoutArgs<RustcTrivialFieldReadsParser>>,
         Single<WithoutArgs<RustcUnsafeSpecializationMarkerParser>>,
         Single<WithoutArgs<SplatParser>>,

compiler/rustc_attr_parsing/src/parser.rs

@@ -301,11 +301,13 @@ impl MetaItemOrLitParser {
     }
 }
 
-// FIXME(scrabsha): once #155696 is merged, update this and mention the higher-level APIs.
 /// Utility that deconstructs a MetaItem into usable parts.
 ///
 /// MetaItems are syntactically extremely flexible, but specific attributes want to parse
-/// them in custom, more restricted ways. This can be done using this struct.
+/// them in custom, more restricted ways. For common argument shapes, prefer the higher-level
+/// [`AcceptContext::expect_list`](crate::context::AcceptContext::expect_list) and
+/// [`AcceptContext::expect_single`](crate::context::AcceptContext::expect_single) helpers.
+/// Use this struct when parsing a custom restricted syntax.
 ///
 /// MetaItems consist of some path, and some args. The args could be empty. In other words:
 ///

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -1,4 +1,4 @@
-// ignore-tidy-filelength
+// ignore-tidy-file-filelength
 
 use std::iter;
 use std::ops::ControlFlow;
@@ -681,7 +681,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
             hir::ExprKind::Call(callee, _)
                 if let &ty::FnDef(_, args) = typeck.node_type(callee.hir_id).kind() =>
             {
-                args
+                args.no_bound_vars().unwrap()
             }
             _ => return None,
         };

compiler/rustc_borrowck/src/diagnostics/mod.rs

@@ -985,6 +985,8 @@ impl<'tcx> BorrowedContentSource<'tcx> {
             ty::FnDef(def_id, args) => {
                 let trait_id = tcx.trait_of_assoc(def_id)?;
 
+                let args = args.no_bound_vars().unwrap();
+
                 if tcx.is_lang_item(trait_id, LangItem::Deref)
                     || tcx.is_lang_item(trait_id, LangItem::DerefMut)
                 {

compiler/rustc_borrowck/src/diagnostics/move_errors.rs

@@ -647,7 +647,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
             hir::ExprKind::Call(callee, _) => {
                 let ty = typeck_result.node_type_opt(callee.hir_id)?;
                 let ty::FnDef(fn_def_id, args) = *ty.kind() else { return None };
-                tcx.predicates_of(fn_def_id).instantiate(tcx, args)
+                tcx.predicates_of(fn_def_id).instantiate(tcx, args.no_bound_vars().unwrap())
             }
             hir::ExprKind::MethodCall(..) => {
                 let (_, method) = typeck_result.type_dependent_def(parent.hir_id)?;

compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs

@@ -1241,7 +1241,13 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                             typeck_results.node_type_opt(expr.hir_id).as_ref().map(|ty| ty.kind())
                         {
                             let arg_pos = args.iter().position(|arg| arg.hir_id == closure_id)?;
-                            Some((*def_id, expr.span, arg_pos, arg_pos, generic_args))
+                            Some((
+                                *def_id,
+                                expr.span,
+                                arg_pos,
+                                arg_pos,
+                                generic_args.no_bound_vars().unwrap(),
+                            ))
                         } else {
                             None
                         }
@@ -1914,7 +1920,7 @@ fn suggest_ampmut<'tcx>(
                 let trait_ref = ty::TraitRef::from_assoc(
                     tcx,
                     tcx.require_lang_item(hir::LangItem::IndexMut, rhs_span),
-                    method_args,
+                    method_args.no_bound_vars().unwrap(),
                 );
                 // The type only implements `Index` but not `IndexMut`, we must not suggest `&mut`.
                 if !infcx

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -959,7 +959,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
             tcx,
             self.infcx.typing_env(self.infcx.param_env),
             fn_did,
-            self.infcx.resolve_vars_if_possible(args),
+            self.infcx.resolve_vars_if_possible(args.no_bound_vars().unwrap()),
         ) else {
             return;
         };

compiler/rustc_borrowck/src/places_conflict.rs

@@ -520,7 +520,7 @@ fn place_projection_conflict<'tcx>(
         ),
 
         (ProjectionElem::UnwrapUnsafeBinder(_), _) => {
-            todo!()
+            unimplemented!()
         }
     }
 }

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -1830,6 +1830,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
             }
 
             if let ty::FnDef(def_id, args) = *constant.const_.ty().kind() {
+                let args = args.no_bound_vars().unwrap();
                 let instantiated_predicates = tcx.predicates_of(def_id).instantiate(tcx, args);
                 self.normalize_and_prove_instantiated_predicates(
                     def_id,

compiler/rustc_borrowck/src/universal_regions.rs

@@ -398,7 +398,7 @@ impl<'tcx> UniversalRegions<'tcx> {
                 });
             }
             DefiningTy::CoroutineClosure(..) => {
-                todo!()
+                unimplemented!()
             }
             DefiningTy::Coroutine(def_id, args) => {
                 let v = with_no_trimmed_paths!(
@@ -603,7 +603,9 @@ impl<'cx, 'tcx> UniversalRegionsBuilder<'cx, 'tcx> {
                     ty::CoroutineClosure(def_id, args) => {
                         DefiningTy::CoroutineClosure(def_id, args)
                     }
-                    ty::FnDef(def_id, args) => DefiningTy::FnDef(def_id, args),
+                    ty::FnDef(def_id, args) => {
+                        DefiningTy::FnDef(def_id, args.no_bound_vars().unwrap())
+                    }
                     _ => span_bug!(
                         tcx.def_span(self.mir_def),
                         "expected defining type for `{:?}`: `{:?}`",

compiler/rustc_builtin_macros/src/autodiff.rs

@@ -564,7 +564,7 @@ mod llvm_enzyme {
                 .iter()
                 .map(|arg| match arg.pat.kind {
                     PatKind::Ident(_, ident, _) => ecx.expr_path(ecx.path_ident(span, ident)),
-                    _ => todo!(),
+                    _ => unimplemented!(),
                 })
                 .collect::<ThinVec<_>>(),
         );

compiler/rustc_builtin_macros/src/eii.rs

@@ -203,6 +203,13 @@ fn split_attrs(
                 foreign_item_attributes.push(attr.clone());
                 macro_attributes.push(attr);
             }
+            // `#[track_caller]` goes on the foreign item only: it's the symbol callers link
+            // against, so it must carry the flag for call sites to pass the caller location.
+            // Implementations derive it during codegen (see `EiiImpls` in `codegen_attrs.rs`),
+            // so it must not be routed onto the default impl here.
+            Some(sym::track_caller) => {
+                foreign_item_attributes.push(attr);
+            }
             // Doc attributes should be forwarded to the macro and the foreign item, since those are
             // the two items you interact with as a user.
             // FIXME: idk yet how EIIs show up in docs, might want to customize

compiler/rustc_builtin_macros/src/test.rs

@@ -24,6 +24,9 @@ use crate::util::{check_builtin_macro_attribute, warn_on_duplicate_attribute};
 ///
 /// We mark item with an inert attribute "rustc_test_marker" which the test generation
 /// logic will pick up on.
+///
+/// The test function also gains a `#[rustc_test_entrypoint_marker]` attribute for tools to pick up
+/// on. This behavior is *unstable*.
 pub(crate) fn expand_test_case(
     ecx: &mut ExtCtxt<'_>,
     attr_sp: Span,
@@ -377,6 +380,12 @@ pub(crate) fn expand_test_or_bench(
     let test_extern =
         cx.item(sp, ast::AttrVec::new(), ast::ItemKind::ExternCrate(None, test_ident));
 
+    let item = {
+        let mut item = item;
+        item.attrs.push(cx.attr_word(sym::rustc_test_entrypoint_marker, attr_sp));
+        item
+    };
+
     debug!("synthetic test item:\n{}\n", pprust::item_to_string(&test_const));
 
     if is_stmt {

compiler/rustc_codegen_cranelift/src/abi/mod.rs

@@ -421,7 +421,7 @@ pub(crate) fn codegen_terminator_call<'tcx>(
             fx.tcx,
             ty::TypingEnv::fully_monomorphized(),
             def_id,
-            fn_args,
+            fn_args.no_bound_vars().unwrap(),
             source_info.span,
         );
 

compiler/rustc_codegen_cranelift/src/base.rs

@@ -717,7 +717,7 @@ fn codegen_stmt<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, cur_block: Block, stmt:
                                     fx.tcx,
                                     ty::TypingEnv::fully_monomorphized(),
                                     def_id,
-                                    args,
+                                    args.no_bound_vars().unwrap(),
                                 )
                                 .unwrap(),
                             );

compiler/rustc_codegen_cranelift/src/inline_asm.rs

@@ -117,7 +117,7 @@ pub(crate) fn codegen_inline_asm_terminator<'tcx>(
                         fx.tcx,
                         ty::TypingEnv::fully_monomorphized(),
                         def_id,
-                        args,
+                        args.no_bound_vars().unwrap(),
                     )
                     .unwrap();
                     let symbol = fx.tcx.symbol_name(instance);

compiler/rustc_codegen_gcc/src/common.rs

@@ -2,12 +2,12 @@ use gccjit::{LValue, RValue, ToRValue, Type};
 use rustc_abi::Primitive::Pointer;
 use rustc_abi::{self as abi, HasDataLayout};
 use rustc_codegen_ssa::traits::{
-    BaseTypeCodegenMethods, ConstCodegenMethods, MiscCodegenMethods, PacMetadata,
-    StaticCodegenMethods,
+    BaseTypeCodegenMethods, ConstCodegenMethods, MiscCodegenMethods, StaticCodegenMethods,
 };
 use rustc_middle::mir::Mutability;
 use rustc_middle::mir::interpret::{GlobalAlloc, PointerArithmetic, Scalar};
 use rustc_middle::ty::layout::LayoutOf;
+use rustc_session::PointerAuthSchema;
 
 use crate::consts::const_alloc_to_gcc;
 use crate::context::{CodegenCx, new_array_type};
@@ -247,7 +247,7 @@ impl<'gcc, 'tcx> ConstCodegenMethods for CodegenCx<'gcc, 'tcx> {
         cv: Scalar,
         layout: abi::Scalar,
         ty: Type<'gcc>,
-        _pac: Option<PacMetadata>,
+        _schema: Option<&PointerAuthSchema>,
     ) -> RValue<'gcc> {
         let bitsize = if layout.is_bool() { 1 } else { layout.size(self).bits() };
         match cv {

compiler/rustc_codegen_gcc/src/context.rs

@@ -5,9 +5,7 @@ use gccjit::{Block, CType, Context, Function, FunctionType, LValue, Location, RV
 use rustc_abi::{Align, HasDataLayout, PointeeInfo, Size, TargetDataLayout, VariantIdx};
 use rustc_codegen_ssa::base::wants_msvc_seh;
 use rustc_codegen_ssa::errors as ssa_errors;
-use rustc_codegen_ssa::traits::{
-    BackendTypes, BaseTypeCodegenMethods, MiscCodegenMethods, PacMetadata,
-};
+use rustc_codegen_ssa::traits::{BackendTypes, BaseTypeCodegenMethods, MiscCodegenMethods};
 use rustc_data_structures::base_n::{ALPHANUMERIC_ONLY, ToBaseN};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_middle::mir::interpret::Allocation;
@@ -18,9 +16,9 @@ use rustc_middle::ty::layout::{
     LayoutOfHelpers,
 };
 use rustc_middle::ty::{self, ExistentialTraitRef, Instance, Ty, TyCtxt};
-use rustc_session::Session;
 #[cfg(feature = "master")]
 use rustc_session::config::DebugInfo;
+use rustc_session::{PointerAuthSchema, Session};
 use rustc_span::{DUMMY_SP, Span, Symbol, respan};
 use rustc_target::spec::{HasTargetSpec, HasX86AbiOpt, Target, TlsModel, X86Abi};
 
@@ -400,7 +398,11 @@ impl<'gcc, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
         get_fn(self, instance)
     }
 
-    fn get_fn_addr(&self, instance: Instance<'tcx>, _pac: Option<PacMetadata>) -> RValue<'gcc> {
+    fn get_fn_addr(
+        &self,
+        instance: Instance<'tcx>,
+        _pointer_auth_schema: Option<&PointerAuthSchema>,
+    ) -> RValue<'gcc> {
         let func_name = self.tcx.symbol_name(instance).name;
 
         let func = if let Some(variable) = self.get_declared_value(func_name) {

compiler/rustc_codegen_llvm/Cargo.toml

@@ -17,7 +17,7 @@ libc = "0.2"
 libloading = { version = "0.9.0" }
 measureme = "12.0.1"
 object = { version = "0.37.0", default-features = false, features = ["std", "read"] }
-rustc-demangle = "0.1.21"
+rustc-demangle = "0.1.28"
 rustc_abi = { path = "../rustc_abi" }
 rustc_ast = { path = "../rustc_ast" }
 rustc_codegen_ssa = { path = "../rustc_codegen_ssa" }

compiler/rustc_codegen_llvm/src/attributes.rs

@@ -12,12 +12,9 @@ use rustc_session::config::{
 };
 use rustc_span::sym;
 use rustc_symbol_mangling::mangle_internal_symbol;
-use rustc_target::spec::{
-    Arch, FramePointer, LlvmAbi, SanitizerSet, StackProbeType, StackProtector,
-};
+use rustc_target::spec::{Arch, FramePointer, SanitizerSet, StackProbeType, StackProtector};
 use smallvec::SmallVec;
 
-use crate::common::pauth_fn_attrs;
 use crate::context::SimpleCx;
 use crate::errors::{PackedStackBackchainNeedsSoftfloat, SanitizerMemtagRequiresMte};
 use crate::llvm::AttributePlace::Function;
@@ -668,8 +665,9 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
         }
     }
 
-    if sess.target.llvm_abiname == LlvmAbi::Pauthtest {
-        for &ptrauth_attr in pauth_fn_attrs() {
+    if sess.pointer_authentication() {
+        let cfg = sess.pointer_auth_config.as_ref().unwrap();
+        for ptrauth_attr in cfg.fn_attrs() {
             to_add.push(llvm::CreateAttrString(cx.llcx, ptrauth_attr));
         }
     }