Rollup of 5 pull requests

compiler/rustc_codegen_ssa/src/mir/naked_asm.rs

@@ -181,7 +181,8 @@ fn prefix_and_suffix<'tcx>(
                 }
             }
             Linkage::Internal => {
-                // write nothing
+                // LTO can fail when internal linkage is used.
+                emit_fatal("naked functions may not have internal linkage")
             }
             Linkage::Common => emit_fatal("Functions may not have common linkage"),
             Linkage::AvailableExternally => {

compiler/rustc_expand/src/mbe/transcribe.rs

@@ -558,25 +558,20 @@ fn metavar_expr_concat<'tx>(
             MetaVarExprConcatElem::Ident(elem) => elem.name,
             MetaVarExprConcatElem::Literal(elem) => *elem,
             MetaVarExprConcatElem::Var(ident) => {
-                match matched_from_ident(dcx, *ident, tscx.interp)? {
-                    NamedMatch::MatchedSeq(named_matches) => {
-                        let Some((curr_idx, _)) = tscx.repeats.last() else {
-                            return Err(dcx.struct_span_err(dspan.entire(), "invalid syntax"));
-                        };
-                        match &named_matches[*curr_idx] {
-                            // FIXME(c410-f3r) Nested repetitions are unimplemented
-                            MatchedSeq(_) => {
-                                return Err(dcx.struct_span_err(
-                                    ident.span,
-                                    "nested repetitions with `${concat(...)}` metavariable expressions are not yet supported",
-                                ));
-                            }
-                            MatchedSingle(pnr) => extract_symbol_from_pnr(dcx, pnr, ident.span)?,
-                        }
-                    }
-                    NamedMatch::MatchedSingle(pnr) => {
+                let key = MacroRulesNormalizedIdent::new(*ident);
+                match lookup_cur_matched(key, tscx.interp, &tscx.repeats) {
+                    Some(NamedMatch::MatchedSingle(pnr)) => {
                         extract_symbol_from_pnr(dcx, pnr, ident.span)?
                     }
+                    Some(NamedMatch::MatchedSeq(..)) => {
+                        return Err(dcx.struct_span_err(
+                            ident.span,
+                            "`${concat(...)}` variable is still repeating at this depth",
+                        ));
+                    }
+                    None => {
+                        return Err(dcx.create_err(MveUnrecognizedVar { span: ident.span, key }));
+                    }
                 }
             }
         };

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -1415,9 +1415,15 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 let ct = self.check_param_uses_if_mcg(ct, span, false);
                 Ok(ct)
             }
-            TypeRelativePath::Ctor { ctor_def_id, args } => {
-                return Ok(ty::Const::zero_sized(tcx, Ty::new_fn_def(tcx, ctor_def_id, args)));
-            }
+            TypeRelativePath::Ctor { ctor_def_id, args } => match tcx.def_kind(ctor_def_id) {
+                DefKind::Ctor(_, CtorKind::Fn) => {
+                    Ok(ty::Const::zero_sized(tcx, Ty::new_fn_def(tcx, ctor_def_id, args)))
+                }
+                DefKind::Ctor(ctor_of, CtorKind::Const) => {
+                    Ok(self.construct_const_ctor_value(ctor_def_id, ctor_of, args))
+                }
+                _ => unreachable!(),
+            },
             // FIXME(mgca): implement support for this once ready to support all adt ctor expressions,
             // not just const ctors
             TypeRelativePath::Variant { .. } => {
@@ -1452,7 +1458,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     // FIXME(mgca): do we want constructor resolutions to take priority over
                     // other possible resolutions?
                     if matches!(mode, LowerTypeRelativePathMode::Const)
-                        && let Some((CtorKind::Fn, ctor_def_id)) = variant_def.ctor
+                        && let Some((_, ctor_def_id)) = variant_def.ctor
                     {
                         tcx.check_stability(variant_def.def_id, Some(qpath_hir_id), span, None);
                         let _ = self.prohibit_generic_args(
@@ -2597,14 +2603,29 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 );
                 self.lower_const_param(def_id, hir_id)
             }
-            Res::Def(DefKind::Const | DefKind::Ctor(_, CtorKind::Const), did) => {
+            Res::Def(DefKind::Const, did) => {
                 assert_eq!(opt_self_ty, None);
                 let [leading_segments @ .., segment] = path.segments else { bug!() };
                 let _ = self
                     .prohibit_generic_args(leading_segments.iter(), GenericsArgsErrExtend::None);
                 let args = self.lower_generic_args_of_path_segment(span, did, segment);
                 ty::Const::new_unevaluated(tcx, ty::UnevaluatedConst::new(did, args))
             }
+            Res::Def(DefKind::Ctor(ctor_of, CtorKind::Const), did) => {
+                assert_eq!(opt_self_ty, None);
+                let [leading_segments @ .., segment] = path.segments else { bug!() };
+                let _ = self
+                    .prohibit_generic_args(leading_segments.iter(), GenericsArgsErrExtend::None);
+
+                let parent_did = tcx.parent(did);
+                let generics_did = match ctor_of {
+                    CtorOf::Variant => tcx.parent(parent_did),
+                    CtorOf::Struct => parent_did,
+                };
+                let args = self.lower_generic_args_of_path_segment(span, generics_did, segment);
+
+                self.construct_const_ctor_value(did, ctor_of, args)
+            }
             Res::Def(DefKind::Ctor(_, CtorKind::Fn), did) => {
                 assert_eq!(opt_self_ty, None);
                 let [leading_segments @ .., segment] = path.segments else { bug!() };
@@ -3174,4 +3195,31 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         }
         Some(r)
     }
+
+    fn construct_const_ctor_value(
+        &self,
+        ctor_def_id: DefId,
+        ctor_of: CtorOf,
+        args: GenericArgsRef<'tcx>,
+    ) -> Const<'tcx> {
+        let tcx = self.tcx();
+        let parent_did = tcx.parent(ctor_def_id);
+
+        let adt_def = tcx.adt_def(match ctor_of {
+            CtorOf::Variant => tcx.parent(parent_did),
+            CtorOf::Struct => parent_did,
+        });
+
+        let variant_idx = adt_def.variant_index_with_id(parent_did);
+
+        let valtree = if adt_def.is_enum() {
+            let discr = ty::ValTree::from_scalar_int(tcx, variant_idx.as_u32().into());
+            ty::ValTree::from_branches(tcx, [ty::Const::new_value(tcx, discr, tcx.types.u32)])
+        } else {
+            ty::ValTree::zst(tcx)
+        };
+
+        let adt_ty = Ty::new_adt(tcx, adt_def, args);
+        ty::Const::new_value(tcx, valtree, adt_ty)
+    }
 }

compiler/rustc_middle/src/metadata.rs

@@ -26,7 +26,7 @@ impl Reexport {
     }
 }
 
-/// This structure is supposed to keep enough data to re-create `NameBinding`s for other crates
+/// This structure is supposed to keep enough data to re-create `Decl`s for other crates
 /// during name resolution. Right now the bindings are not recreated entirely precisely so we may
 /// need to add more data in the future to correctly support macros 2.0, for example.
 /// Module child can be either a proper item or a reexport (including private imports).

compiler/rustc_monomorphize/src/partitioning.rs

@@ -580,6 +580,16 @@ fn internalize_symbols<'tcx>(
                 }
             }
 
+            // When LTO inlines the caller of a naked function, it will attempt but fail to make the
+            // naked function symbol visible. To ensure that LTO works correctly, do not default
+            // naked functions to internal linkage and default visibility.
+            if let MonoItem::Fn(instance) = item {
+                let flags = cx.tcx.codegen_instance_attrs(instance.def).flags;
+                if flags.contains(CodegenFnAttrFlags::NAKED) {
+                    continue;
+                }
+            }
+
             // If we got here, we did not find any uses from other CGUs, so
             // it's fine to make this monomorphization internal.
             data.linkage = Linkage::Internal;