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_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/intrinsic.rs

@@ -919,7 +919,7 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
         let fn_ty = instance.ty(tcx, self.typing_env());
         let fn_sig = match *fn_ty.kind() {
             ty::FnDef(def_id, args) => tcx.instantiate_bound_regions_with_erased(
-                tcx.fn_sig(def_id).instantiate(tcx, args).skip_norm_wip(),
+                tcx.fn_sig(def_id).instantiate(tcx, args.no_bound_vars().unwrap()).skip_norm_wip(),
             ),
             _ => unreachable!(),
         };
@@ -1762,7 +1762,7 @@ fn codegen_autodiff<'ll, 'tcx>(
     let fn_to_diff = args[0].immediate();
 
     let (diff_id, diff_args) = match fn_args.into_type_list(tcx)[1].kind() {
-        ty::FnDef(def_id, diff_args) => (def_id, diff_args),
+        ty::FnDef(def_id, diff_args) => (def_id, diff_args.no_bound_vars().unwrap()),
         _ => bug!("invalid args"),
     };
 
@@ -1825,7 +1825,7 @@ fn codegen_offload<'ll, 'tcx>(
     let fn_args = instance.args;
 
     let (target_id, target_args) = match fn_args.into_type_list(tcx)[0].kind() {
-        ty::FnDef(def_id, params) => (def_id, params),
+        ty::FnDef(def_id, params) => (def_id, params.no_bound_vars().unwrap()),
         _ => bug!("invalid offload intrinsic arg"),
     };
 

compiler/rustc_codegen_ssa/src/base.rs

@@ -446,7 +446,7 @@ where
                             cx.tcx(),
                             ty::TypingEnv::fully_monomorphized(),
                             def_id,
-                            args,
+                            args.no_bound_vars().unwrap(),
                             expr.span,
                         ),
                         _ => span_bug!(*op_sp, "asm sym is not a function"),

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -264,6 +264,18 @@ fn process_builtin_attrs(
                         Visibility::Default,
                     ));
                     codegen_fn_attrs.flags |= CodegenFnAttrFlags::EXTERNALLY_IMPLEMENTABLE_ITEM;
+
+                    // If the declaration is `#[track_caller]`, derive it onto the implementation
+                    // too. The shim that forwards to this impl (see `add_function_aliases`) takes
+                    // its ABI from the impl's `fn_abi`, so every impl must agree on whether the
+                    // caller-location argument is present, otherwise it would be silently dropped.
+                    if tcx
+                        .codegen_fn_attrs(foreign_item)
+                        .flags
+                        .contains(CodegenFnAttrFlags::TRACK_CALLER)
+                    {
+                        codegen_fn_attrs.flags |= CodegenFnAttrFlags::TRACK_CALLER;
+                    }
                 }
             }
             AttributeKind::ThreadLocal => {

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -949,7 +949,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     bx.tcx(),
                     bx.typing_env(),
                     def_id,
-                    generic_args,
+                    generic_args.no_bound_vars().unwrap(),
                     fn_span,
                 );
 
@@ -1098,7 +1098,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                             bx.tcx(),
                             bx.typing_env(),
                             def_id,
-                            generic_args,
+                            generic_args.no_bound_vars().unwrap(),
                         )
                         .unwrap();
 
@@ -1486,7 +1486,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                             bx.tcx(),
                             bx.typing_env(),
                             def_id,
-                            args,
+                            args.no_bound_vars().unwrap(),
                         )
                         .unwrap();
                         InlineAsmOperandRef::SymFn { instance }