Disallow scalable vectors in async fn.

Scalable vectors are unsized types so we can't hold them across an
await point.

Also clean up the tests to remove unsized features from tests as a
user shouldn't have to enable them when using scalable vectors.

Author: JamieCunliffe

compiler/rustc_hir_analysis/src/check/check.rs

@@ -1740,6 +1740,7 @@ pub(super) fn check_coroutine_obligations(
     }
 
     let errors = ocx.select_all_or_error();
+
     debug!(?errors);
     if !errors.is_empty() {
         return Err(infcx.err_ctxt().report_fulfillment_errors(errors));

compiler/rustc_hir_typeck/src/upvar.rs

@@ -496,7 +496,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let final_upvar_tys = self.final_upvar_tys(closure_def_id);
         debug!(?closure_hir_id, ?args, ?final_upvar_tys);
 
-        if self.tcx.features().unsized_locals || self.tcx.features().unsized_fn_params {
+        if self.tcx.features().unsized_locals
+            || self.tcx.features().unsized_fn_params
+            || self.tcx.features().repr_scalable
+        {
             for capture in
                 self.typeck_results.borrow().closure_min_captures_flattened(closure_def_id)
             {

compiler/rustc_mir_transform/src/coroutine.rs

@@ -1599,7 +1599,11 @@ fn check_field_tys_sized<'tcx>(
 ) {
     // No need to check if unsized_locals/unsized_fn_params is disabled,
     // since we will error during typeck.
-    if !tcx.features().unsized_locals && !tcx.features().unsized_fn_params {
+    // repr scalable will also allow unsized locals so if that's enabled we also have to check.
+    if !tcx.features().unsized_locals
+        && !tcx.features().unsized_fn_params
+        && !tcx.features().repr_scalable
+    {
         return;
     }
 

tests/codegen/simd/allow-scalable-references.rs

@@ -3,14 +3,7 @@
 
 #![crate_type = "lib"]
 #![allow(incomplete_features, internal_features, improper_ctypes)]
-#![feature(
-    repr_simd,
-    repr_scalable,
-    simd_ffi,
-    unsized_locals,
-    unsized_fn_params,
-    link_llvm_intrinsics
-)]
+#![feature(repr_simd, repr_scalable, simd_ffi, link_llvm_intrinsics)]
 
 #[repr(simd, scalable(4))]
 #[allow(non_camel_case_types)]

tests/ui/simd/scalable/disallow-capture-closure.rs

@@ -1,3 +1,5 @@
+//@ only-aarch64
+
 #![allow(incomplete_features, internal_features, improper_ctypes)]
 #![feature(
     repr_simd,
@@ -40,8 +42,10 @@ fn run(f: impl Fn() -> ()) {
 }
 
 fn main() {
-    let a = svdup_n_s32(42);
-    run(move || {
-        svxar_n_s32::<2>(a, a); //~ ERROR E0277
-    });
+    unsafe {
+        let a = svdup_n_s32(42);
+        run(move || {
+            svxar_n_s32::<2>(a, a); //~ ERROR E0277
+        });
+    }
 }

tests/ui/simd/scalable/disallow-capture-closure.stderr

@@ -1,14 +1,14 @@
 error[E0277]: the size for values of type `[i32]` cannot be known at compilation time
-  --> $DIR/disallow-capture-closure.rs:45:26
+  --> $DIR/disallow-capture-closure.rs:48:30
    |
-LL |     run(move || {
-   |              -- this closure captures all values by move
-LL |         svxar_n_s32::<2>(a, a);
-   |                          ^ doesn't have a size known at compile-time
+LL |         run(move || {
+   |                  -- this closure captures all values by move
+LL |             svxar_n_s32::<2>(a, a);
+   |                              ^ doesn't have a size known at compile-time
    |
    = help: within `svint32_t`, the trait `Sized` is not implemented for `[i32]`, which is required by `svint32_t: Sized`
 note: required because it appears within the type `svint32_t`
-  --> $DIR/disallow-capture-closure.rs:13:12
+  --> $DIR/disallow-capture-closure.rs:15:12
    |
 LL | pub struct svint32_t {
    |            ^^^^^^^^^

tests/ui/simd/scalable/no-async.rs

@@ -0,0 +1,45 @@
+//@ only-aarch64
+//@ edition:2021
+
+#![allow(incomplete_features, internal_features, improper_ctypes)]
+#![feature(
+    core_intrinsics,
+    repr_simd,
+    repr_scalable,
+    simd_ffi,
+    link_llvm_intrinsics
+)]
+
+use core::intrinsics::simd::simd_reinterpret;
+
+#[repr(simd, scalable(4))]
+#[allow(non_camel_case_types)]
+pub struct svint32_t {
+    _ty: [i32],
+}
+
+#[target_feature(enable = "sve")]
+pub unsafe fn svdup_n_s32(op: i32) -> svint32_t {
+    extern "C" {
+        #[cfg_attr(target_arch = "aarch64", link_name = "llvm.aarch64.sve.dup.x.nxv4i32")]
+        fn _svdup_n_s32(op: i32) -> svint32_t;
+    }
+    unsafe { _svdup_n_s32(op) }
+}
+
+async fn another() -> i32 {
+    42
+}
+
+#[no_mangle]
+pub async fn test_function() {
+    unsafe {
+        let x = svdup_n_s32(1); //~ ERROR E0277
+        let temp = another().await;
+        let y: svint32_t = simd_reinterpret(x);
+    }
+}
+
+fn main() {
+    let _ = test_function();
+}

tests/ui/simd/scalable/no-async.stderr

@@ -0,0 +1,17 @@
+error[E0277]: the size for values of type `[i32]` cannot be known at compilation time
+  --> $DIR/no-async.rs:37:13
+   |
+LL |         let x = svdup_n_s32(1);
+   |             ^ doesn't have a size known at compile-time
+   |
+   = help: within `svint32_t`, the trait `Sized` is not implemented for `[i32]`, which is required by `svint32_t: Sized`
+note: required because it appears within the type `svint32_t`
+  --> $DIR/no-async.rs:17:12
+   |
+LL | pub struct svint32_t {
+   |            ^^^^^^^^^
+   = note: all values live across `await` must have a statically known size
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.