Rollup of 22 pull requests

Cargo.lock

@@ -3520,6 +3520,7 @@ dependencies = [
  "similar",
  "tempfile",
  "wasmparser 0.247.0",
+ "windows 0.62.2",
 ]
 
 [[package]]

compiler/rustc_abi/src/lib.rs

@@ -1473,6 +1473,15 @@ impl Float {
             PpcF128 => "ppcf128",
         }
     }
+
+    pub fn is_ieee(self) -> bool {
+        use Float::*;
+
+        match self {
+            F16 | F32 | F64 | F128 => true,
+            F16B | PpcF128 => false,
+        }
+    }
 }
 
 /// Numeric primitives.
@@ -2460,16 +2469,34 @@ impl<FieldIdx: Idx, VariantIdx: Idx> LayoutData<FieldIdx, VariantIdx> {
     /// aggregates are passed via `PassMode::Indirect`, `PassMode::IndirectUnsized` or
     /// `PassMode::Cast`; more strict checks would otherwise be required.
     pub fn eq_abi(&self, other: &Self) -> bool {
+        let LayoutData {
+            size,
+            align,
+            backend_repr,
+            // We assume aggregates are passed via `Cast` or `Indirect*` so their details either
+            // do not matter or they are checked by `PassMode::eq_abi`.
+            fields: _,
+            variants: _,
+            // Inhabitedness and niches are not ABI-relevant.
+            largest_niche: _,
+            uninhabited: _,
+            // max_repr_align, unadjusted_abi_align, repr_c are not read directly by codegen
+            // backends. They are only used to compute `PassMode`. So we can ignore them here, any
+            // differences they may cause are picked up by the `PassMode` check.
+            max_repr_align: _,
+            unadjusted_abi_align: _,
+            repr_c: _,
+            // The seed does not affect the ABI.
+            randomization_seed: _,
+        } = self;
         // The one thing that we are not capturing here is that for unsized types, the metadata must
         // also have the same ABI, and moreover that the same metadata leads to the same size. The
         // 2nd point is quite hard to check though.
-        self.size == other.size
-            && self.is_sized() == other.is_sized()
-            && self.backend_repr.eq_up_to_validity(&other.backend_repr)
-            && self.backend_repr.is_bool() == other.backend_repr.is_bool()
-            && self.align.abi == other.align.abi
-            && self.max_repr_align == other.max_repr_align
-            && self.unadjusted_abi_align == other.unadjusted_abi_align
+        *size == other.size
+            && *align == other.align
+            && backend_repr.eq_up_to_validity(&other.backend_repr)
+            // `is_bool` checks validity and is ABI-relevant, so we need to consider it.
+            && backend_repr.is_bool() == other.backend_repr.is_bool()
     }
 }
 

compiler/rustc_ast_lowering/src/asm.rs

@@ -261,24 +261,45 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         if class == asm::InlineAsmRegClass::Err {
                             continue;
                         }
-                        let valid_modifiers = class.valid_modifiers(asm_arch.unwrap());
+                        let valid_modifiers =
+                            class.valid_modifiers(asm_arch.unwrap(), allow_experimental_reg);
                         if !valid_modifiers.contains(&modifier) {
-                            let sub = if valid_modifiers.is_empty() {
-                                InvalidAsmTemplateModifierRegClassSub::DoesNotSupportModifier {
-                                    class_name: class.name(),
-                                }
+                            // First check if the requested modifier is missing from the valid
+                            // values because experimental registers are disabled.
+                            let unstable_modifiers = class.valid_modifiers(asm_arch.unwrap(), true);
+                            if !allow_experimental_reg && unstable_modifiers.contains(&modifier) {
+                                self.tcx.sess.create_feature_err(
+                                    InvalidAsmTemplateModifierRegClass {
+                                        placeholder_span,
+                                        op_span: op_sp,
+                                        modifier: modifier.to_string(),
+                                        sub: InvalidAsmTemplateModifierRegClassSub::ModifierIsGated {
+                                            class_name: class.name(),
+                                            feature: sym::asm_experimental_reg,
+                                            stable_modifiers: valid_modifiers.to_vec().into(),
+                                            all_modifiers: unstable_modifiers.to_vec().into(),
+                                        },
+                                    },
+                                    sym::asm_experimental_reg,
+                                ).emit();
                             } else {
-                                InvalidAsmTemplateModifierRegClassSub::SupportModifier {
-                                    class_name: class.name(),
-                                    modifiers: valid_modifiers.to_vec().into(),
-                                }
-                            };
-                            self.dcx().emit_err(InvalidAsmTemplateModifierRegClass {
-                                placeholder_span,
-                                op_span: op_sp,
-                                modifier: modifier.to_string(),
-                                sub,
-                            });
+                                let sub = if valid_modifiers.is_empty() {
+                                    InvalidAsmTemplateModifierRegClassSub::DoesNotSupportModifier {
+                                        class_name: class.name(),
+                                    }
+                                } else {
+                                    InvalidAsmTemplateModifierRegClassSub::SupportModifier {
+                                        class_name: class.name(),
+                                        modifiers: valid_modifiers.to_vec().into(),
+                                    }
+                                };
+                                self.dcx().emit_err(InvalidAsmTemplateModifierRegClass {
+                                    placeholder_span,
+                                    op_span: op_sp,
+                                    modifier: modifier.to_string(),
+                                    sub,
+                                });
+                            }
                         }
                     }
                     hir::InlineAsmOperand::Const { .. } => {

compiler/rustc_ast_lowering/src/diagnostics.rs

@@ -266,6 +266,18 @@ pub(crate) enum InvalidAsmTemplateModifierRegClassSub {
     SupportModifier { class_name: Symbol, modifiers: DiagSymbolList<char> },
     #[note("the `{$class_name}` register class does not support template modifiers")]
     DoesNotSupportModifier { class_name: Symbol },
+
+    /// Enabling a feature is needed to use the requested modifier.
+    #[note(
+        "the `{$class_name}` register class only supports the following template modifiers on stable: {$stable_modifiers}"
+    )]
+    #[note("enabling the `{$feature}` feature will allow using: {$all_modifiers}")]
+    ModifierIsGated {
+        class_name: Symbol,
+        feature: Symbol,
+        stable_modifiers: DiagSymbolList<char>,
+        all_modifiers: DiagSymbolList<char>,
+    },
 }
 
 #[derive(Diagnostic)]

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -2235,6 +2235,19 @@ impl Visitor<'_> for AstValidator<'_> {
             Self::check_decl_no_pat(&args.inputs, |span, _, _| {
                 self.dcx().emit_err(diagnostics::PatternParenthesizedArgList { span });
             });
+
+            let mut args = args.inputs.iter().peekable();
+            while let Some(arg) = args.next() {
+                if matches!(arg.ty.kind, TyKind::CVarArgs) {
+                    let sugg_span = arg
+                        .span
+                        .until(args.peek().map(|a| a.span).unwrap_or(arg.span.shrink_to_hi()));
+                    self.dcx().emit_err(diagnostics::PathFoundCVariadicParams {
+                        span: arg.ty.span,
+                        sugg_span,
+                    });
+                }
+            }
         }
         visit::walk_path_segment(self, seg);
     }

compiler/rustc_ast_passes/src/diagnostics.rs

@@ -699,6 +699,15 @@ pub(crate) struct PatternParenthesizedArgList {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag("C-variadic parameters aren't allowed in parenthesized argument lists")]
+pub(crate) struct PathFoundCVariadicParams {
+    #[primary_span]
+    pub span: Span,
+    #[suggestion("remove the C-variadics", applicability = "machine-applicable", code = "")]
+    pub sugg_span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag("only a single explicit lifetime bound is permitted", code = E0226)]
 pub(crate) struct TraitObjectBound {

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -491,7 +491,7 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
     );
     gate_all!(
         named_fn_trait_parameters,
-        "named parameters in parenthesized generic argument lists are experimental"
+        "parameters in parenthesized generic argument lists with names, attributes, or c-variadics are experimental"
     );
 
     // `associated_const_equality` will be stabilized as part of `gca_min_const_items`.

compiler/rustc_attr_ir/src/data_structures.rs

@@ -1514,6 +1514,10 @@ pub enum AttributeKind {
         limit: Limit,
     },
 
+    /// Represents `#[rustc_unchecked_type_alias]`
+    // FIXME(#134963): Temporarily prefixed with `rustc_` to prevent potential name resolution ambiguities.
+    UncheckedTypeAlias,
+
     /// Represents `#[rustc_unroll]`
     // FIXME(#159429): temporarily renamed from `#[unroll]` to mitigate nameres ambiguity
     Unroll(UnrollAttr),

compiler/rustc_attr_ir/src/encode_cross_crate.rs

@@ -207,6 +207,7 @@ impl AttributeKind {
             ThreadLocal => No,
             TrackCaller(..) => Yes,
             TypeLengthLimit { .. } => No,
+            UncheckedTypeAlias => Yes,
             Unroll(..) => No,
             UnstableFeatureBound(..) => No,
             UnstableRemoved(..) => Yes,
@@ -424,6 +425,7 @@ impl AttributeKind {
             ThreadLocal => false,
             TrackCaller(..) => false,
             TypeLengthLimit { .. } => false,
+            UncheckedTypeAlias => false,
             Unroll(..) => false,
             UnstableFeatureBound(..) => false,
             UnstableRemoved(..) => false,

compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs

@@ -1,5 +1,7 @@
 use std::iter;
 
+use rustc_ast::Const;
+use rustc_attr_ir::target::AstTarget;
 use rustc_feature::AttributeStability;
 
 use super::macro_attrs::check_macro_only;
@@ -78,6 +80,22 @@ impl CombineAttributeParser for RustcAllowConstFnUnstableParser {
     ) -> impl IntoIterator<Item = Self::Item> {
         parse_unstable(cx, args, <Self as CombineAttributeParser>::PATH[0])
     }
+
+    fn finalize_check(cx: &mut FinalizeCheckContext<'_, '_>, attr_span: Span) {
+        match cx.ast_target {
+            AstTarget::Fn(_) | AstTarget::Method(_) => {
+                let fn_sig =
+                    cx.ast_target.get_fn_sig().expect("missing fn signature for AST target");
+                if matches!(fn_sig.header.constness, Const::No) {
+                    cx.emit_err(diagnostics::RustcAllowConstFnUnstable {
+                        attr_span,
+                        span: cx.target_span,
+                    });
+                }
+            }
+            _ => {}
+        }
+    }
 }
 
 fn parse_unstable(

compiler/rustc_attr_parsing/src/attributes/semantics.rs

@@ -31,3 +31,12 @@ impl NoArgsAttributeParser for AlwaysGcaParser {
     const STABILITY: AttributeStability = unstable!(gca_min_const_items);
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::AlwaysGca;
 }
+
+pub(crate) struct UncheckedTypeAliasParser;
+impl NoArgsAttributeParser for UncheckedTypeAliasParser {
+    const PATH: &[Symbol] = &[sym::rustc_unchecked_type_alias];
+    const ALLOWED_TARGETS: AllowedTargets<'_> =
+        AllowedTargets::AllowList(&[Allow(Target::TyAlias)]);
+    const STABILITY: AttributeStability = unstable!(marked_unchecked_type_aliases);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::UncheckedTypeAlias;
+}

compiler/rustc_attr_parsing/src/attributes/splat.rs

@@ -10,7 +10,6 @@ pub(crate) struct SplatParser;
 impl NoArgsAttributeParser for SplatParser {
     const PATH: &[Symbol] = &[sym::rustc_splat];
     const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[Allow(Target::Param)]);
-    const STABILITY: AttributeStability =
-        unstable!(splat, "the `rustc_splat` attribute is experimental");
+    const STABILITY: AttributeStability = unstable!(splat);
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::Splat;
 }

compiler/rustc_attr_parsing/src/context.rs

@@ -361,6 +361,7 @@ attribute_parsers!(
         Single<WithoutArgs<SplatParser>>,
         Single<WithoutArgs<ThreadLocalParser>>,
         Single<WithoutArgs<TrackCallerParser>>,
+        Single<WithoutArgs<UncheckedTypeAliasParser>>,
         // tidy-alphabetical-end
     ];
 );

compiler/rustc_attr_parsing/src/diagnostics.rs

@@ -120,6 +120,15 @@ pub(crate) struct UnsafeAttrOutsideUnsafeLint {
     pub suggestion: Option<crate::diagnostics::UnsafeAttrOutsideUnsafeSuggestion>,
 }
 
+#[derive(Diagnostic)]
+#[diag("attribute should be applied to `const fn`")]
+pub(crate) struct RustcAllowConstFnUnstable {
+    #[primary_span]
+    pub attr_span: Span,
+    #[label("not a `const fn`")]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(
     "{$num_suggestions ->