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_ast_passes/messages.ftl

@@ -228,6 +228,8 @@ ast_passes_precise_capturing_duplicated = duplicate `use<...>` precise capturing
 
 ast_passes_precise_capturing_not_allowed_here = `use<...>` precise capturing syntax not allowed in {$loc}
 
+ast_passes_scalable_vector_not_tuple_struct = scalable vectors must be tuple structs
+
 ast_passes_static_without_body =
     free static item without body
     .suggestion = provide a definition for the static

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -1182,6 +1182,14 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
             }
             ItemKind::Struct(ident, generics, vdata) => {
                 self.with_tilde_const(Some(TildeConstReason::Struct { span: item.span }), |this| {
+                    // Scalable vectors can only be tuple structs
+                    let is_scalable_vector =
+                        item.attrs.iter().any(|attr| attr.has_name(sym::rustc_scalable_vector));
+                    if is_scalable_vector && !matches!(vdata, VariantData::Tuple(..)) {
+                        this.dcx()
+                            .emit_err(errors::ScalableVectorNotTupleStruct { span: item.span });
+                    }
+
                     match vdata {
                         VariantData::Struct { fields, .. } => {
                             this.visit_attrs_vis_ident(&item.attrs, &item.vis, ident);

compiler/rustc_ast_passes/src/errors.rs

@@ -907,3 +907,10 @@ pub(crate) struct AbiMustNotHaveReturnType {
     pub span: Span,
     pub abi: ExternAbi,
 }
+
+#[derive(Diagnostic)]
+#[diag(ast_passes_scalable_vector_not_tuple_struct)]
+pub(crate) struct ScalableVectorNotTupleStruct {
+    #[primary_span]
+    pub span: Span,
+}

compiler/rustc_hir_analysis/src/check/check.rs

@@ -1,7 +1,7 @@
 use std::cell::LazyCell;
 use std::ops::ControlFlow;
 
-use rustc_abi::{ExternAbi, FieldIdx};
+use rustc_abi::{ExternAbi, FieldIdx, ScalableElt};
 use rustc_data_structures::unord::{UnordMap, UnordSet};
 use rustc_errors::codes::*;
 use rustc_errors::{EmissionGuarantee, MultiSpan};
@@ -94,7 +94,9 @@ fn check_struct(tcx: TyCtxt<'_>, def_id: LocalDefId) {
     let span = tcx.def_span(def_id);
     def.destructor(tcx); // force the destructor to be evaluated
 
-    if def.repr().simd() {
+    if let Some(scalable) = def.repr().scalable {
+        check_scalable_vector(tcx, span, def_id, scalable);
+    } else if def.repr().simd() {
         check_simd(tcx, span, def_id);
     }
 
@@ -1398,6 +1400,83 @@ fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: LocalDefId) {
     }
 }
 
+#[tracing::instrument(skip(tcx), level = "debug")]
+fn check_scalable_vector(tcx: TyCtxt<'_>, span: Span, def_id: LocalDefId, scalable: ScalableElt) {
+    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("`rustc_scalable_vector` applied to non-struct");
+        return;
+    }
+
+    let fields = &def.non_enum_variant().fields;
+    match scalable {
+        ScalableElt::ElementCount(..) if fields.is_empty() => {
+            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 a primitive scalar type");
+            err.emit();
+            return;
+        }
+        ScalableElt::ElementCount(..) if fields.len() >= 2 => {
+            tcx.dcx().struct_span_err(span, "scalable vectors cannot have multiple fields").emit();
+            return;
+        }
+        ScalableElt::Container if fields.is_empty() => {
+            let mut err =
+                tcx.dcx().struct_span_err(span, "scalable vectors must have a single field");
+            err.help("tuples of scalable vectors can only contain multiple of the same scalable vector type");
+            err.emit();
+            return;
+        }
+        _ => {}
+    }
+
+    match scalable {
+        ScalableElt::ElementCount(..) => {
+            let element_ty = &fields[FieldIdx::ZERO].ty(tcx, args);
+
+            // Check that `element_ty` only uses types valid in the lanes of a scalable vector
+            // register: scalar types which directly match a "machine" type - integers, floats and
+            // bools
+            match element_ty.kind() {
+                ty::Int(_) | ty::Uint(_) | ty::Float(_) | 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();
+                }
+            }
+        }
+        ScalableElt::Container => {
+            let mut prev_field_ty = None;
+            for field in fields.iter() {
+                let element_ty = field.ty(tcx, args);
+                if let ty::Adt(def, _) = element_ty.kind()
+                    && !def.repr().scalable()
+                {
+                    tcx.dcx().span_err(
+                        tcx.def_span(field.did),
+                        "scalable vector structs can only have scalable vector fields",
+                    );
+                } else if let Some(prev_ty) = prev_field_ty.replace(element_ty)
+                    && prev_ty != element_ty
+                {
+                    tcx.dcx().span_err(
+                        tcx.def_span(field.did),
+                        "all fields in a scalable vector struct must be the same type",
+                    );
+                }
+            }
+        }
+    }
+}
+
 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

@@ -2,7 +2,7 @@ use std::cell::LazyCell;
 use std::ops::{ControlFlow, Deref};
 
 use hir::intravisit::{self, Visitor};
-use rustc_abi::ExternAbi;
+use rustc_abi::{ExternAbi, ScalableElt};
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_errors::codes::*;
 use rustc_errors::{Applicability, ErrorGuaranteed, pluralize, struct_span_code_err};
@@ -1039,7 +1039,21 @@ fn check_type_defn<'tcx>(
                     hir_ty.span,
                     Some(WellFormedLoc::Ty(field_id)),
                     ty.into(),
-                )
+                );
+
+                if matches!(ty.kind(), ty::Adt(def, _) if def.repr().scalable())
+                    && !matches!(adt_def.repr().scalable, Some(ScalableElt::Container))
+                {
+                    // Scalable vectors can only be fields of structs if the type has an
+                    // `rustc_scalable_vector` attribute w/out specifying an element count
+                    tcx.dcx().span_err(
+                        hir_ty.span,
+                        format!(
+                            "scalable vectors cannot be fields of a {}",
+                            adt_def.variant_descr()
+                        ),
+                    );
+                }
             }
 
             // For DST, or when drop needs to copy things around, all

compiler/rustc_trait_selection/src/traits/wf.rs

@@ -770,9 +770,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_vector() && !self.span.is_dummy() {
+                            self.tcx()
+                                .dcx()
+                                .struct_span_err(
+                                    self.span,
+                                    "scalable vectors cannot be tuple fields",
+                                )
+                                .emit();
+                        }
+                    }
+
+                    if last.is_scalable_vector() && !self.span.is_dummy() {
+                        self.tcx()
+                            .dcx()
+                            .struct_span_err(self.span, "scalable vectors cannot be tuple fields")
+                            .emit();
                     }
                 }
             }

tests/ui/scalable-vectors/illformed-element-type.rs

@@ -0,0 +1,93 @@
+//@ compile-flags: --crate-type=lib
+#![allow(internal_features)]
+#![feature(extern_types)]
+#![feature(never_type)]
+#![feature(rustc_attrs)]
+
+struct Foo;
+enum Bar {}
+union Baz { x: u16 }
+extern "C" {
+    type Qux;
+}
+
+#[rustc_scalable_vector(4)]
+struct TyChar(char);
+//~^ ERROR: element type of a scalable vector must be a primitive scalar
+
+#[rustc_scalable_vector(2)]
+struct TyConstPtr(*const u8);
+//~^ ERROR: element type of a scalable vector must be a primitive scalar
+
+#[rustc_scalable_vector(2)]
+struct TyMutPtr(*mut u8);
+//~^ ERROR: element type of a scalable vector must be a primitive scalar
+
+#[rustc_scalable_vector(4)]
+struct TyStruct(Foo);
+//~^ ERROR: element type of a scalable vector must be a primitive scalar
+
+#[rustc_scalable_vector(4)]
+struct TyEnum(Bar);
+//~^ ERROR: element type of a scalable vector must be a primitive scalar
+
+#[rustc_scalable_vector(4)]
+struct TyUnion(Baz);
+//~^ ERROR: element type of a scalable vector must be a primitive scalar
+
+#[rustc_scalable_vector(4)]
+struct TyForeign(Qux);
+//~^ ERROR: element type of a scalable vector must be a primitive scalar
+
+#[rustc_scalable_vector(4)]
+struct TyArray([u32; 4]);
+//~^ ERROR: element type of a scalable vector must be a primitive scalar
+
+#[rustc_scalable_vector(4)]
+struct TySlice([u32]);
+//~^ ERROR: element type of a scalable vector must be a primitive scalar
+
+#[rustc_scalable_vector(4)]
+struct TyRef<'a>(&'a u32);
+//~^ ERROR: element type of a scalable vector must be a primitive scalar
+
+#[rustc_scalable_vector(4)]
+struct TyFnPtr(fn(u32) -> u32);
+//~^ ERROR: element type of a scalable vector must be a primitive scalar
+
+#[rustc_scalable_vector(4)]
+struct TyDyn(dyn std::io::Write);
+//~^ ERROR: element type of a scalable vector must be a primitive scalar
+
+#[rustc_scalable_vector(4)]
+struct TyNever(!);
+//~^ ERROR: element type of a scalable vector must be a primitive scalar
+
+#[rustc_scalable_vector(4)]
+struct TyTuple((u32, u32));
+//~^ ERROR: element type of a scalable vector must be a primitive scalar
+
+type ValidAlias = u32;
+type InvalidAlias = String;
+
+#[rustc_scalable_vector(4)]
+struct TyValidAlias(ValidAlias);
+
+#[rustc_scalable_vector(4)]
+struct TyInvalidAlias(InvalidAlias);
+//~^ ERROR: element type of a scalable vector must be a primitive scalar
+
+trait Tr {
+    type Valid;
+    type Invalid;
+}
+
+impl Tr for () {
+    type Valid = u32;
+    type Invalid = String;
+}
+
+struct TyValidProjection(<() as Tr>::Valid);
+
+struct TyInvalidProjection(<() as Tr>::Invalid);
+// FIXME: element type of a scalable vector must be a primitive scalar