[Sema][SVE] Allow casting SVE types to themselves in C

[rsandifo-arm]

Summary

Casts from an SVE type to itself aren't very useful, but they are
supposed to be valid, and could occur in things like macro expansions.

Such casts already work for C++ and are tested by sizeless-1.cpp.
This patch makes them work for C too.

[efriedma]

Is it not legal to cast an SVE type to any type other than itself?

[rsandifo-arm]

In D76694#1939863, @efriedma wrote:

Is it not legal to cast an SVE type to any type other than itself?

Not in normal length-agnostic mode. Instead we provide reinterpret intrinsics for type changes that are supposed to be bitcasts and conversion intrinsics for type changes that are supposed to be arithmetic operations. The types are really just opaque blobs that hold the inputs to and outputs from intrinsics.

For length-specific mode, we eventually want to allow casts to and from equivalent "normal" fixed-length vector types. Those conversions would also be implicit, so that fixed-length vectors of the right type and length can be used directly with intrinsics.

[efriedma]

Okay, then LGTM.

clang/lib/Sema/SemaCast.cpp

if (SrcExpr.isInvalid())
     return;
 
   if (Self.RequireCompleteType(OpRange.getBegin(), DestType,
                                diag::err_typecheck_cast_to_incomplete)) {
     SrcExpr = ExprError();
     return;
   }
 
+  // Allow casting a sizeless built-in type to itself.
+  if (DestType->isSizelessBuiltinType() &&
+      Self.Context.hasSameUnqualifiedType(DestType, SrcType)) {
+    Kind = CK_NoOp;
+    return;
+  }
+
   if (!DestType->isScalarType() && !DestType->isVectorType()) {
     const RecordType *DestRecordTy = DestType->getAs<RecordType>();
 
     if (DestRecordTy && Self.Context.hasSameUnqualifiedType(DestType, SrcType)){
       // GCC struct/union extension: allow cast to self.
       Self.Diag(OpRange.getBegin(), diag::ext_typecheck_cast_nonscalar)
         << DestType << SrcExpr.get()->getSourceRange();
       Kind = CK_NoOp;

clang/test/Sema/sizeless-1.c

void func(int sel) {
   int int_int8 = init_int8; // expected-error {{initializing 'int' with an expression of incompatible type 'svint8_t'}}
 
   init_int8 = local_int8;
   init_int8 = local_int16; // expected-error {{assigning to 'svint8_t' (aka '__SVInt8_t') from incompatible type 'svint16_t'}}
   init_int8 = sel;         // expected-error {{assigning to 'svint8_t' (aka '__SVInt8_t') from incompatible type 'int'}}
 
   sel = local_int8; // expected-error {{assigning to 'int' from incompatible type 'svint8_t'}}
 
+  local_int8 = (svint8_t)local_int8;
+  local_int8 = (const svint8_t)local_int8;
   local_int8 = (svint8_t)local_int16; // expected-error {{used type 'svint8_t' (aka '__SVInt8_t') where arithmetic or pointer type is required}}
   local_int8 = (svint8_t)0;           // expected-error {{used type 'svint8_t' (aka '__SVInt8_t') where arithmetic or pointer type is required}}
   sel = (int)local_int8;              // expected-error {{operand of type 'svint8_t' (aka '__SVInt8_t') where arithmetic or pointer type is required}}
 
   init_int8 = local_int8;
   init_int8 = const_int8;
   init_int8 = volatile_int8;
   init_int8 = const_volatile_int8;