[Sema][SVE] Reject by-copy capture of sizeless types

[rsandifo-arm]

Summary

Since fields can't have sizeless type, it also doesn't make sense
to capture sizeless types by value in lambda expressions. This patch
makes sure that we diagnose that and that we use "sizeless type" rather
"incomplete type" in the associated message. (Both are correct, but
"sizeless type" is more specific and hopefully more user-friendly.)

[efriedma]

LGTM

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_abstract_type_in_decl : Error<
   "synthesized instance variable}0 type %1 is an abstract class">;
 def err_allocation_of_abstract_type : Error<
   "allocating an object of abstract class type %0">;
 def err_throw_abstract_type : Error<
   "cannot throw an object of abstract type %0">;
 def err_array_of_abstract_type : Error<"array of abstract class type %0">;
 def err_capture_of_abstract_type : Error<
   "by-copy capture of value of abstract type %0">;
-def err_capture_of_incomplete_type : Error<
-  "by-copy capture of variable %0 with incomplete type %1">;
+def err_capture_of_incomplete_or_sizeless_type : Error<
+  "by-copy capture of variable %0 with %select{incomplete|sizeless}1 type %2">;
 def err_capture_default_non_local : Error<
   "non-local lambda expression cannot have a capture-default">;
 
 def err_multiple_final_overriders : Error<
   "virtual function %q0 has more than one final overrider in %1">;
 def note_final_overrider : Note<"final overrider of %q0 in %1">;
 
 def err_type_defined_in_type_specifier : Error<

clang/lib/Sema/SemaExpr.cpp

if (!Invalid &&
       } else {
         return false;
       }
     }
 
     // Make sure that by-copy captures are of a complete and non-abstract type.
     if (!Invalid && BuildAndDiagnose) {
       if (!CaptureType->isDependentType() &&
-          S.RequireCompleteType(Loc, CaptureType,
-                                diag::err_capture_of_incomplete_type,
-                                Var->getDeclName()))
+          S.RequireCompleteSizedType(
+              Loc, CaptureType,
+              diag::err_capture_of_incomplete_or_sizeless_type,
         Invalid = true;
       else if (S.RequireNonAbstractType(Loc, CaptureType,
                                         diag::err_capture_of_abstract_type))
         Invalid = true;
     }
   }
 
   // Compute the type of a reference to this captured variable.

clang/test/SemaCXX/sizeless-1.cpp

#if __cplusplus >= 201103L
   constructible_from_sizeless cfs3{local_int8};
 #endif
 
 #if __cplusplus >= 201103L
   local_int8 = ([]() { return svint8_t(); })();
   local_int8 = ([]() -> svint8_t { return svint8_t(); })();
   auto fn1 = [&local_int8](svint8_t x) { local_int8 = x; };
   auto fn2 = [&local_int8](svint8_t *ptr) { *ptr = local_int8; };
+  auto fn3 = [local_int8](svint8_t *ptr) { *ptr = local_int8; }; // expected-error {{by-copy capture of variable 'local_int8' with sizeless type 'svint8_t'}}
 
   for (auto x : local_int8) { // expected-error {{no viable 'begin' function available}}
   }
   for (auto x : wrapper<svint8_t>()) {
     (void)x;
   }
   for (const svint8_t &x : wrapper<svint8_t>()) { // expected-warning {{loop variable 'x' is always a copy because the range of type 'wrapper<svint8_t>' (aka 'wrapper<__SVInt8_t>') does not return a reference}} expected-note {{use non-reference type}}
     (void)x;