hir/trait_sel: prohibit scalable vectors in types

Extend well-formedness checking and HIR analysis to prohibit the use of
scalable vectors in structs, enums, unions, tuples and arrays. LLVM does
not support scalable vectors being members of other types, so these
restrictions are necessary.

Co-authored-by: Jamie Cunliffe <Jamie.Cunliffe@arm.com>

Author: davidtwco

compiler/rustc_hir_analysis/src/check/check.rs

@@ -95,7 +95,11 @@ fn check_struct(tcx: TyCtxt<'_>, def_id: LocalDefId) {
     def.destructor(tcx); // force the destructor to be evaluated
 
     if def.repr().simd() {
-        check_simd(tcx, span, def_id);
+        if def.repr().scalable() {
+            check_scalable_simd(tcx, span, def_id);
+        } else {
+            check_simd(tcx, span, def_id);
+        }
     }
 
     check_transparent(tcx, def);
@@ -1393,6 +1397,54 @@ fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: LocalDefId) {
     }
 }
 
+fn check_scalable_simd(tcx: TyCtxt<'_>, span: Span, def_id: LocalDefId) {
+    let ty = tcx.type_of(def_id).instantiate_identity();
+    let ty::Adt(def, args) = ty.kind() else { return };
+    if !def.is_struct() {
+        tcx.dcx().delayed_bug("`repr(scalable)` applied to non-struct");
+        return;
+    }
+
+    let fields = &def.non_enum_variant().fields;
+    match fields.len() {
+        0 => {
+            let mut err =
+                tcx.dcx().struct_span_err(span, "scalable vectors must have a single field");
+            err.help("scalable vector types' only field must be slice of a primitive scalar type");
+            err.emit();
+            return;
+        }
+        1 => {}
+        2.. => {
+            tcx.dcx().struct_span_err(span, "scalable vectors cannot have multiple fields").emit();
+        }
+    }
+
+    let array_field = &fields[FieldIdx::ZERO];
+    let array_ty = array_field.ty(tcx, args);
+    let ty::Slice(element_ty) = array_ty.kind() else {
+        let mut err =
+            tcx.dcx().struct_span_err(span, "the field of a scalable vector type must be a slice");
+        err.span_label(tcx.def_span(array_field.did), "not a slice");
+        err.emit();
+        return;
+    };
+
+    // Check that `element_ty` only uses types valid in the lanes of a scalable vector register:
+    // scalar types which directly match a "machine" type - e.g. integers, floats, bools, thin ptrs.
+    match element_ty.kind() {
+        ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::RawPtr(_, _) | ty::Bool => (),
+        _ => {
+            let mut err = tcx.dcx().struct_span_err(
+                span,
+                "element type of a scalable vector must be a primitive scalar",
+            );
+            err.help("only `u*`, `i*`, `f*`, `*const`, `*mut` and `bool` types are accepted");
+            err.emit();
+        }
+    }
+}
+
 pub(super) fn check_packed(tcx: TyCtxt<'_>, sp: Span, def: ty::AdtDef<'_>) {
     let repr = def.repr();
     if repr.packed() {

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -1054,10 +1054,9 @@ fn check_type_defn<'tcx>(
             };
             // All fields (except for possibly the last) should be sized.
             let all_sized = all_sized || variant.fields.is_empty() || needs_drop_copy();
-            let unsized_len = if all_sized { 0 } else { 1 };
-            for (idx, field) in
-                variant.fields.raw[..variant.fields.len() - unsized_len].iter().enumerate()
-            {
+            let unsized_len =
+                if all_sized { variant.fields.len() } else { variant.fields.len() - 1 };
+            for (idx, field) in variant.fields.raw.iter().enumerate() {
                 let last = idx == variant.fields.len() - 1;
                 let field_id = field.did.expect_local();
                 let hir::FieldDef { ty: hir_ty, .. } =
@@ -1067,28 +1066,41 @@ fn check_type_defn<'tcx>(
                     None,
                     tcx.type_of(field.did).instantiate_identity(),
                 );
-                wfcx.register_bound(
-                    traits::ObligationCause::new(
+
+                if matches!(ty.kind(), ty::Adt(def, _) if def.repr().scalable()) {
+                    tcx.dcx().span_err(
                         hir_ty.span,
-                        wfcx.body_def_id,
-                        ObligationCauseCode::FieldSized {
-                            adt_kind: match &item.kind {
-                                ItemKind::Struct(..) => AdtKind::Struct,
-                                ItemKind::Union(..) => AdtKind::Union,
-                                ItemKind::Enum(..) => AdtKind::Enum,
-                                kind => span_bug!(
-                                    item.span,
-                                    "should be wfchecking an ADT, got {kind:?}"
-                                ),
+                        format!(
+                            "scalable vectors cannot be fields of a {}",
+                            adt_def.variant_descr()
+                        ),
+                    );
+                }
+
+                if idx < unsized_len {
+                    wfcx.register_bound(
+                        traits::ObligationCause::new(
+                            hir_ty.span,
+                            wfcx.body_def_id,
+                            ObligationCauseCode::FieldSized {
+                                adt_kind: match &item.kind {
+                                    ItemKind::Struct(..) => AdtKind::Struct,
+                                    ItemKind::Union(..) => AdtKind::Union,
+                                    ItemKind::Enum(..) => AdtKind::Enum,
+                                    kind => span_bug!(
+                                        item.span,
+                                        "should be wfchecking an ADT, got {kind:?}"
+                                    ),
+                                },
+                                span: hir_ty.span,
+                                last,
                             },
-                            span: hir_ty.span,
-                            last,
-                        },
-                    ),
-                    wfcx.param_env,
-                    ty,
-                    tcx.require_lang_item(LangItem::Sized, hir_ty.span),
-                );
+                        ),
+                        wfcx.param_env,
+                        ty,
+                        tcx.require_lang_item(LangItem::Sized, hir_ty.span),
+                    );
+                }
             }
 
             // Explicit `enum` discriminant values must const-evaluate successfully.

compiler/rustc_trait_selection/src/traits/wf.rs

@@ -748,6 +748,13 @@ impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for WfPredicates<'a, 'tcx> {
 
             ty::Array(subty, len) => {
                 self.require_sized(subty, ObligationCauseCode::SliceOrArrayElem);
+                if subty.is_scalable_simd() && !self.span.is_dummy() {
+                    self.tcx()
+                        .dcx()
+                        .struct_span_err(self.span, "scalable vectors cannot be array elements")
+                        .emit();
+                }
+
                 // Note that the len being WF is implicitly checked while visiting.
                 // Here we just check that it's of type usize.
                 let cause = self.cause(ObligationCauseCode::ArrayLen(t));
@@ -769,9 +776,25 @@ impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for WfPredicates<'a, 'tcx> {
             }
 
             ty::Tuple(tys) => {
-                if let Some((_last, rest)) = tys.split_last() {
+                if let Some((last, rest)) = tys.split_last() {
                     for &elem in rest {
                         self.require_sized(elem, ObligationCauseCode::TupleElem);
+                        if elem.is_scalable_simd() && !self.span.is_dummy() {
+                            self.tcx()
+                                .dcx()
+                                .struct_span_err(
+                                    self.span,
+                                    "scalable vectors cannot be tuple fields",
+                                )
+                                .emit();
+                        }
+                    }
+
+                    if last.is_scalable_simd() && !self.span.is_dummy() {
+                        self.tcx()
+                            .dcx()
+                            .struct_span_err(self.span, "scalable vectors cannot be tuple fields")
+                            .emit();
                     }
                 }
             }

tests/ui/feature-gates/feature-gate-repr-scalable.rs

@@ -1,7 +1,7 @@
 #![feature(repr_simd)]
 
 #[repr(simd, scalable(16))] //~ ERROR: scalable vector types are experimental
-struct Foo { //~ ERROR: SIMD vector's only field must be an array
+struct Foo {
     _ty: [i8],
 }
 

tests/ui/feature-gates/feature-gate-repr-scalable.stderr

@@ -7,15 +7,6 @@ LL | #[repr(simd, scalable(16))]
    = help: add `#![feature(repr_scalable)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0076]: SIMD vector's only field must be an array
-  --> $DIR/feature-gate-repr-scalable.rs:4:1
-   |
-LL | struct Foo {
-   | ^^^^^^^^^^
-LL |     _ty: [i8],
-   |     --------- not an array
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
-Some errors have detailed explanations: E0076, E0658.
-For more information about an error, try `rustc --explain E0076`.
+For more information about this error, try `rustc --explain E0658`.

tests/ui/simd/scalable/illformed.rs

@@ -0,0 +1,21 @@
+//@ compile-flags: --crate-type=lib
+#![feature(repr_scalable, repr_simd)]
+
+#[repr(simd, scalable(4))]
+struct NoFields {} //~ ERROR: scalable vectors must have a single field
+
+#[repr(simd, scalable(4))]
+struct MultipleFields { //~ ERROR: scalable vectors cannot have multiple fields
+    _ty: [f32], //~ ERROR: the size for values of type `[f32]` cannot be known at compilation time
+    other: u32,
+}
+
+#[repr(simd, scalable(4))]
+struct WrongFieldType { //~ ERROR: the field of a scalable vector type must be a slice
+    _ty: String,
+}
+
+#[repr(simd, scalable(4))]
+struct WrongElementTy { //~ ERROR: element type of a scalable vector must be a primitive scalar
+    _ty: [String],
+}

tests/ui/simd/scalable/illformed.stderr

@@ -0,0 +1,51 @@
+error: scalable vectors must have a single field
+  --> $DIR/illformed.rs:5:1
+   |
+LL | struct NoFields {}
+   | ^^^^^^^^^^^^^^^
+   |
+   = help: scalable vector types' only field must be slice of a primitive scalar type
+
+error: scalable vectors cannot have multiple fields
+  --> $DIR/illformed.rs:8:1
+   |
+LL | struct MultipleFields {
+   | ^^^^^^^^^^^^^^^^^^^^^
+
+error[E0277]: the size for values of type `[f32]` cannot be known at compilation time
+  --> $DIR/illformed.rs:9:10
+   |
+LL |     _ty: [f32],
+   |          ^^^^^ doesn't have a size known at compile-time
+   |
+   = help: the trait `Sized` is not implemented for `[f32]`
+   = note: only the last field of a struct may have a dynamically sized type
+   = help: change the field's type to have a statically known size
+help: borrowed types always have a statically known size
+   |
+LL |     _ty: &[f32],
+   |          +
+help: the `Box` type always has a statically known size and allocates its contents in the heap
+   |
+LL |     _ty: Box<[f32]>,
+   |          ++++     +
+
+error: the field of a scalable vector type must be a slice
+  --> $DIR/illformed.rs:14:1
+   |
+LL | struct WrongFieldType {
+   | ^^^^^^^^^^^^^^^^^^^^^
+LL |     _ty: String,
+   |     ----------- not a slice
+
+error: element type of a scalable vector must be a primitive scalar
+  --> $DIR/illformed.rs:19:1
+   |
+LL | struct WrongElementTy {
+   | ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: only `u*`, `i*`, `f*`, `*const`, `*mut` and `bool` types are accepted
+
+error: aborting due to 5 previous errors
+
+For more information about this error, try `rustc --explain E0277`.

tests/ui/simd/scalable/invalid.rs

@@ -175,21 +175,18 @@ fn main() {
 
 #[repr(transparent, simd, scalable(4))] //~ ERROR: transparent struct cannot have other repr hints
 struct CombinedWithReprTransparent {
-//~^ ERROR: SIMD vector's only field must be an array
     _ty: [f64],
 }
 
 #[repr(Rust, simd, scalable(4))] //~ ERROR: conflicting representation hints
 struct CombinedWithReprRust {
-//~^ ERROR: SIMD vector's only field must be an array
     _ty: [f64],
 }
 
 #[repr(C, simd, scalable(4))]
 //~^ ERROR: conflicting representation hints
 //~^^ WARN: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 struct CombinedWithReprC {
-//~^ ERROR: SIMD vector's only field must be an array
     _ty: [f64],
 }
 
@@ -224,6 +221,5 @@ struct ArgKind {
 
 #[repr(simd, scalable(4))]
 struct Okay {
-//~^ ERROR: SIMD vector's only field must be an array
     _ty: [f64],
 }