trait_sel: temporary impl Sized for scalable vecs

Scalable vectors should behave like other value types - being permitted
as arguments, locals, return types, etc. This requires that these types
be `Sized`, despite not meeting the definition and requirements of
`Sized`. `feature(sized_hierarchy)` is being implemented to enable
scalable vectors to be non-`const Sized`, but in the mean time, add
a builtin impl for scalable vectors. This must be addressed prior to
stabilisation.

Author: davidtwco

compiler/rustc_middle/src/ty/adt.rs

@@ -208,6 +208,10 @@ impl<'tcx> rustc_type_ir::inherent::AdtDef<TyCtxt<'tcx>> for AdtDef<'tcx> {
         self.is_struct()
     }
 
+    fn is_scalable_vector(self) -> bool {
+        self.repr().scalable()
+    }
+
     fn struct_tail_ty(self, interner: TyCtxt<'tcx>) -> Option<ty::EarlyBinder<'tcx, Ty<'tcx>>> {
         Some(interner.type_of(self.non_enum_variant().tail_opt()?.did))
     }

compiler/rustc_middle/src/ty/sty.rs

@@ -1834,9 +1834,12 @@ impl<'tcx> Ty<'tcx> {
 
             ty::Tuple(tys) => tys.last().is_none_or(|ty| ty.has_trivial_sizedness(tcx, sizedness)),
 
-            ty::Adt(def, args) => def
-                .sizedness_constraint(tcx, sizedness)
-                .is_none_or(|ty| ty.instantiate(tcx, args).has_trivial_sizedness(tcx, sizedness)),
+            ty::Adt(def, args) => {
+                def.repr().scalable() // see comment on `sizedness_conditions`
+                    || def.sizedness_constraint(tcx, sizedness).is_none_or(|ty| {
+                        ty.instantiate(tcx, args).has_trivial_sizedness(tcx, sizedness)
+                    })
+            }
 
             ty::Alias(..) | ty::Param(_) | ty::Placeholder(..) | ty::Bound(..) => false,
 

compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs

@@ -174,6 +174,19 @@ where
         //   "best effort" optimization and `{meta,pointee,}sized_constraint` may return `Some`,
         //   even if the ADT is {meta,pointee,}sized for all possible args.
         ty::Adt(def, args) => {
+            // FIXME(repr_scalable): Scalable vectors aren't actually `Sized`. They will be
+            // non-const `Sized` after the `sized_hierarchy` feature is implemented, but until
+            // then need to act like `Sized` types - either by forcing it in the trait solver,
+            // as below, or by omitting the `Sized` constraints in the first place. Omitting the
+            // constraints would require many small changes throughout the compiler and in some
+            // cases would not be trivially limited to only the `repr(scalable)` types due
+            // to inference variables, etc. When `sized_hierarchy` is fully implemented, this
+            // line will be required anyway and will be correct, just that in the host effect
+            // builtin impl for sizedness, it won't be `const Sized`.
+            if def.is_scalable_vector() {
+                return Ok(ty::Binder::dummy(vec![]));
+            }
+
             if let Some(crit) = def.sizedness_constraint(ecx.cx(), sizedness) {
                 Ok(ty::Binder::dummy(vec![crit.instantiate(ecx.cx(), args)]))
             } else {

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -2148,6 +2148,19 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             ty::Pat(ty, _) => Where(obligation.predicate.rebind(vec![*ty])),
 
             ty::Adt(def, args) => {
+                // FIXME(repr_scalable): Scalable vectors aren't actually `Sized`. They will be
+                // non-const `Sized` after the `sized_hierarchy` feature is implemented, but until
+                // then need to act like `Sized` types - either by forcing it in the trait solver,
+                // as below, or by omitting the `Sized` constraints in the first place. Omitting the
+                // constraints would require many small changes throughout the compiler and in some
+                // cases would not be trivially limited to only the `repr(scalable)` types due
+                // to inference variables, etc. When `sized_hierarchy` is fully implemented, this
+                // line will be required anyway and will be correct, just that in the host effect
+                // builtin impl for sizedness, it won't be `const Sized`.
+                if def.repr().scalable() {
+                    return Where(ty::Binder::dummy(Vec::new()));
+                }
+
                 if let Some(crit) = def.sizedness_constraint(self.tcx(), sizedness) {
                     // (*) binder moved here
                     Where(obligation.predicate.rebind(vec![crit.instantiate(self.tcx(), args)]))

compiler/rustc_type_ir/src/inherent.rs

@@ -597,6 +597,8 @@ pub trait AdtDef<I: Interner>: Copy + Debug + Hash + Eq {
 
     fn is_struct(self) -> bool;
 
+    fn is_scalable_vector(self) -> bool;
+
     /// Returns the type of the struct tail.
     ///
     /// Expects the `AdtDef` to be a struct. If it is not, then this will panic.