[PATCH 2/3] [RFC only] clang implementation of sizeless types

[rsandifo-arm]

Summary

`[ Not intended for commit. I'm just posting it to back up an

RFC on cfe-dev. ]

This patch adds the concept of "sizeless" types to core C and C++.
It's a prerequisite for adding AArch64 SVE intrinsics.

The patch relies on two new type categorisations:

• sized vs. sizeless
  
  All standard types are "sized" (even void). Sizeless types are purely an extension.

• indefinite vs. definite
  
  Indefinite types can be used to declare objects but can't be used to construct them. For sized types, "indefinite" is the same as the standard definition of "incomplete".

The patch then redefines "complete" to mean "sized and definite".
All sizeless types are permanently incomplete, since their size is
never known at compile time.

The cfe-dev RFC will have more details; the above is only a summary.

The patch doesn't reword the diagnostics to talk about "indefinite" rather
than "incomplete" since "indefinite" won't mean much to most users.

The FIXMEs about inline asms are resolved by later SVE patches.`

[rsandifo-arm]

Abandoning in favour of:

https://reviews.llvm.org/D62960
https://reviews.llvm.org/D62961
https://reviews.llvm.org/D62962

include/clang/AST/CanonicalType.h

template<typename U> CanProxy<U> getAs() const {
     return this->Stored.template getAs<U>();
   }
 
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(Type::TypeClass, getTypeClass)
 
   // Type predicates
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjectType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isIncompleteType)
+  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isDefiniteType)
+  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isIndefiniteType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isSizelessType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isSizelessBuiltinType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isIncompleteOrObjectType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isVariablyModifiedType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isIntegerType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isEnumeralType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isBooleanType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isCharType)

include/clang/AST/Expr.h

public:
 
   enum isModifiableLvalueResult {
     MLV_Valid,
     MLV_NotObjectType,
     MLV_IncompleteVoidType,
     MLV_DuplicateVectorComponents,
     MLV_InvalidExpression,
     MLV_LValueCast,           // Specialized form of MLV_InvalidExpression.
-    MLV_IncompleteType,
+    MLV_IndefiniteType,
     MLV_ConstQualified,
     MLV_ConstQualifiedField,
     MLV_ConstAddrSpace,
     MLV_ArrayType,
     MLV_NoSetterProperty,
     MLV_MemberFunction,
     MLV_SubObjCPropertySetting,
     MLV_InvalidMessageExpression,
enum ModifiableType {
       CM_RValue, // Not modifiable because it's an rvalue
       CM_Function, // Not modifiable because it's a function; C++ only
       CM_LValueCast, // Same as CM_RValue, but indicates GCC cast-as-lvalue ext
       CM_NoSetterProperty,// Implicit assignment to ObjC property without setter
       CM_ConstQualified,
       CM_ConstQualifiedField,
       CM_ConstAddrSpace,
       CM_ArrayType,
-      CM_IncompleteType
+      CM_IndefiniteType
     };
 
   private:
     friend class Expr;
 
     unsigned short Kind;
     unsigned short Modifiable;
 

include/clang/AST/Type.h

public:
   /// every type is one or the other.  Standard types are all sized;
   /// sizeless types are purely an extension.
   ///
   /// Sizeless types contain data with no specified size, alignment,
   /// or layout.  They are always incomplete.
   bool isSizelessType() const;
   bool isSizelessBuiltinType() const;
 
+  /// As an extension, we classify types as one of "definite" or "indefinite";
+  /// every type is one or the other.  Indefinite types are types that can
+  /// describe objects but don't have enough information to construct them.
+  /// This is true iff the type is both "sized" and incomplete according
+  /// to the standard definition.
+  ///
+  /// \brief Def If non-null, and the type refers to some kind of declaration
+  /// that can be made definite (such as a C struct, C++ class, or Objective-C
+  /// class), will be set to the declaration.
+  bool isIndefiniteType(NamedDecl **Def = nullptr) const;
+  bool isDefiniteType(NamedDecl **Def = nullptr) const {
+    return !isIndefiniteType(Def);
+  }
+
   /// Types are partitioned into 3 broad categories (C99 6.2.5p1):
   /// object types, function types, and incomplete types.
 
   /// Return true if this is an incomplete type.
   /// A type that can describe objects, but which lacks information needed to
   /// determine its size (e.g. void, or a fwd declared struct). Clients of this
   /// routine will need to determine if the size is actually required.
   ///
-  /// \brief Def If non-null, and the type refers to some kind of declaration
-  /// that can be completed (such as a C struct, C++ class, or Objective-C
-  /// class), will be set to the declaration.
-  bool isIncompleteType(NamedDecl **Def = nullptr) const;
+  /// A type is incomplete according to our definition iff:
+  /// - it is incomplete according to the standard definition; or
+  /// - it is "sizeless"
+  ///
+  /// The intention is that the usual rules for incomplete types will
+  /// by default apply to sizeless types as well.  Specifically-chosen
+  /// rules can then be redefined in terms of "definite" and "indefinite"
+  /// if sizeless definite types are acceptable.
+  bool isIncompleteType() const {
+    return isIndefiniteType() || isSizelessType();
+  }
 
   /// Return true if this is an incomplete or object
   /// type, in other words, not a function type.
   bool isIncompleteOrObjectType() const {
     return !isFunctionType();
   }
 
   /// \brief Determine whether this type is an object type.

include/clang/Basic/DiagnosticSemaKinds.td

def err_alignas_attribute_wrong_decl_type : Error<
   "variable with 'register' storage class|'catch' variable|bit-field}1">;
 def err_alignas_missing_on_definition : Error<
   "%0 must be specified on definition if it is specified on any declaration">;
 def note_alignas_on_declaration : Note<"declared with %0 attribute here">;
 def err_alignas_mismatch : Error<
   "redeclaration has different alignment requirement (%1 vs %0)">;
 def err_alignas_underaligned : Error<
   "requested alignment is less than minimum alignment of %1 for type %0">;
+def err_attribute_sizeless_type : Error<
+  "%0 attribute cannot be applied to sizeless type %1">;
 def err_attribute_argument_n_type : Error<
   "%0 attribute requires parameter %1 to be %select{int or bool|an integer "
   "constant|a string|an identifier}2">;
 def err_attribute_argument_type : Error<
   "%0 attribute requires %select{int or bool|an integer "
   "constant|a string|an identifier}1">;
 def err_attribute_argument_outof_range : Error<
   "%0 attribute requires integer constant between %1 and %2 inclusive">;
def note_array_size_conversion : Note<
   "conversion to %select{integral|enumeration}0 type %1 declared here">;
 def err_array_size_ambiguous_conversion : Error<
   "ambiguous conversion of array size expression of type %0 to an integral or "
   "enumeration type">;
 def ext_array_size_conversion : Extension<
   "implicit conversion from array size expression of type %0 to "
   "%select{integral|enumeration}1 type %2 is a C++11 extension">,
   InGroup<CXX11>;
+def err_array_of_sizeless : Error<
+  "array has sizeless element type %0">;
 def warn_cxx98_compat_array_size_conversion : Warning<
   "implicit conversion from array size expression of type %0 to "
   "%select{integral|enumeration}1 type %2 is incompatible with C++98">,
   InGroup<CXX98CompatPedantic>, DefaultIgnore;
 def err_address_space_qualified_new : Error<
   "'new' cannot allocate objects of type %0 in address space '%1'">;
 def err_address_space_qualified_delete : Error<
   "'delete' cannot delete objects of type %0 in address space '%1'">;
def note_carries_dependency_missing_first_decl : Note<
   "declaration missing '[[carries_dependency]]' attribute is here">;
 def err_carries_dependency_param_not_function_decl : Error<
   "'[[carries_dependency]]' attribute only allowed on parameter in a function "
   "declaration or lambda">;
 def err_block_on_nonlocal : Error<
   "__block attribute not allowed, only allowed on local variables">;
 def err_block_on_vm : Error<
   "__block attribute not allowed on declaration with a variably modified type">;
+def err_sizeless_nonlocal : Error<
+  "non-local variable with sizeless type %0">;
 
 def err_vec_builtin_non_vector : Error<
  "first two arguments to %0 must be vectors">;
 def err_vec_builtin_incompatible_vector : Error<
   "first two arguments to %0 must have the same type">;
 def err_vsx_builtin_nonconstant_argument : Error<
   "argument %0 to %1 must be a 2-bit unsigned literal (i.e. 0, 1, 2 or 3)">;
 

include/clang/Sema/Initialization.h

enum FailureKind {
     FK_ConstructorOverloadFailed,
 
     /// \brief Overloading for list-initialization by constructor failed.
     FK_ListConstructorOverloadFailed,
 
     /// \brief Default-initialization of a 'const' object.
     FK_DefaultInitOfConst,
 
-    /// \brief Initialization of an incomplete type.
-    FK_Incomplete,
+    /// \brief Initialization of an indefinite type.
+    FK_Indefinite,
 
     /// \brief Variable-length array must not have an initializer.
     FK_VariableLengthArrayHasInitializer,
 
     /// \brief List initialization failed at some point.
     FK_ListInitializationFailed,
 
     /// \brief Initializer has a placeholder type which cannot be
private:
   FailureKind Failure;
 
   /// \brief The failed result of overload resolution.
   OverloadingResult FailedOverloadResult;
   
   /// \brief The candidate set created when initialization failed.
   OverloadCandidateSet FailedCandidateSet;
 
-  /// \brief The incomplete type that caused a failure.
-  QualType FailedIncompleteType;
+  /// \brief The indefinite type that caused a failure.
+  QualType FailedIndefiniteType;
 
   /// \brief The fixit that needs to be applied to make this initialization
   /// succeed.
   std::string ZeroInitializationFixit;
   SourceLocation ZeroInitializationFixitLoc;
 
 public:
   /// \brief Call for initializations are invalid but that would be valid
public:
   /// \brief Add steps to unwrap a initializer list for a reference around a
   /// single element and rewrap it at the end.
   void RewrapReferenceInitList(QualType T, InitListExpr *Syntactic);
 
   /// \brief Note that this initialization sequence failed.
   void SetFailed(FailureKind Failure) {
     SequenceKind = FailedSequence;
     this->Failure = Failure;
-    assert((Failure != FK_Incomplete || !FailedIncompleteType.isNull()) &&
-           "Incomplete type failure requires a type!");
+    assert((Failure != FK_Indefinite || !FailedIndefiniteType.isNull()) &&
+           "Indefinite type failure requires a type!");
   }
   
   /// \brief Note that this initialization sequence failed due to failed
   /// overload resolution.
   void SetOverloadFailure(FailureKind Failure, OverloadingResult Result);
   
   /// \brief Retrieve a reference to the candidate set when overload
   /// resolution fails.
   OverloadCandidateSet &getFailedCandidateSet() {
     return FailedCandidateSet;
   }
 
   /// \brief Get the overloading result, for when the initialization
   /// sequence failed due to a bad overload.
   OverloadingResult getFailedOverloadResult() const {
     return FailedOverloadResult;
   }
 
   /// \brief Note that this initialization sequence failed due to an
-  /// incomplete type.
-  void setIncompleteTypeFailure(QualType IncompleteType) {
-    FailedIncompleteType = IncompleteType;
-    SetFailed(FK_Incomplete);
+  /// indefinite type.
+  void setIndefiniteTypeFailure(QualType IndefiniteType) {
+    FailedIndefiniteType = IndefiniteType;
+    SetFailed(FK_Indefinite);
   }
 
   /// \brief Determine why initialization failed.
   FailureKind getFailureKind() const {
     assert(Failed() && "Not an initialization failure!");
     return Failure;
   }
 

include/clang/Sema/Sema.h

public:
     void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
       const SemaDiagnosticBuilder &DB = S.Diag(Loc, DiagID);
       emit(DB, llvm::index_sequence_for<Ts...>());
       DB << T;
     }
   };
 
 private:
-  bool RequireCompleteTypeImpl(SourceLocation Loc, QualType T,
+  bool RequireDefiniteTypeImpl(SourceLocation Loc, QualType T,
+                               bool AllowSizeless,
                                TypeDiagnoser *Diagnoser);
 
   struct ModuleScope {
     clang::Module *Module = nullptr;
     bool ModuleInterface = false;
     VisibleModuleSet OuterVisibleModules;
   };
   /// The modules we're currently parsing.
public:
   /// from different modules, and thus an ambiguity error can be downgraded to
   /// an extension warning.
   bool isEquivalentInternalLinkageDeclaration(const NamedDecl *A,
                                               const NamedDecl *B);
   void diagnoseEquivalentInternalLinkageDeclarations(
       SourceLocation Loc, const NamedDecl *D,
       ArrayRef<const NamedDecl *> Equiv);
 
+  bool isDefiniteType(SourceLocation Loc, QualType T) {
+    return !RequireDefiniteTypeImpl(Loc, T, true, nullptr);
+  }
+  bool isIndefiniteType(SourceLocation Loc, QualType T) {
+    return !isDefiniteType(Loc, T);
+  }
   bool isCompleteType(SourceLocation Loc, QualType T) {
-    return !RequireCompleteTypeImpl(Loc, T, nullptr);
+    return !RequireDefiniteTypeImpl(Loc, T, false, nullptr);
   }
-  bool RequireCompleteType(SourceLocation Loc, QualType T,
+  bool RequireDefiniteType(SourceLocation Loc, QualType T, bool AllowSizeless,
                            TypeDiagnoser &Diagnoser);
-  bool RequireCompleteType(SourceLocation Loc, QualType T,
+  bool RequireDefiniteType(SourceLocation Loc, QualType T, bool AllowSizeless,
                            unsigned DiagID);
-
+  template <typename... Ts>
+  bool RequireDefiniteType(SourceLocation Loc, QualType T, bool AllowSizeless,
+                           unsigned DiagID, const Ts &...Args) {
+    BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
+    return RequireDefiniteType(Loc, T, AllowSizeless, Diagnoser);
+  }
+  bool RequireCompleteType(SourceLocation Loc, QualType T,
+                           TypeDiagnoser &Diagnoser) {
+    return RequireDefiniteType(Loc, T, false, Diagnoser);
+  }
+  bool RequireCompleteType(SourceLocation Loc, QualType T,
+                           unsigned DiagID) {
+    return RequireDefiniteType(Loc, T, false, DiagID);
+  }
   template <typename... Ts>
   bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned DiagID,
                            const Ts &...Args) {
     BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
     return RequireCompleteType(Loc, T, Diagnoser);
   }
 
   void completeExprArrayBound(Expr *E);

lib/AST/ASTContext.cpp

if (Ty->isRecordType()) {
 
     Optional<int64_t> StructSize =
         structHasUniqueObjectRepresentations(*this, Record);
 
     return StructSize &&
            StructSize.getValue() == static_cast<int64_t>(getTypeSize(Ty));
   }
 
+  // Sizeless built-in types have a unique representation.
+  if (Ty->isSizelessBuiltinType())
+    return true;
+
   // FIXME: More cases to handle here (list by rsmith):
   // vectors (careful about, eg, vector of 3 foo)
   // _Complex int and friends
   // _Atomic T
   // Obj-C block pointers
   // Obj-C object pointers
   // and perhaps OpenCL's various builtin types (pipe, sampler_t, event_t,
   // clk_event_t, queue_t, reserve_id_t)

lib/AST/ExprClassification.cpp

if (CT.isConstQualified())
     return Cl::CM_ConstQualified;
   if (Ctx.getLangOpts().OpenCL &&
       CT.getQualifiers().getAddressSpace() == LangAS::opencl_constant)
     return Cl::CM_ConstAddrSpace;
 
   // Arrays are not modifiable, only their elements are.
   if (CT->isArrayType())
     return Cl::CM_ArrayType;
-  // Incomplete types are not modifiable.
-  if (CT->isIncompleteType())
-    return Cl::CM_IncompleteType;
+  // Incomplete types are not modifiable (C11 6.3.2.1/1).  The sizeless type
+  // extension replaces "incomplete" with "indefinite", so that sizeless
+  // definite types are modifiable lvalues.
+  if (CT->isIndefiniteType())
+    return Cl::CM_IndefiniteType;
 
   // Records with any const fields (recursively) are not modifiable.
   if (const RecordType *R = CT->getAs<RecordType>())
     if (R->hasConstFields())
       return Cl::CM_ConstQualifiedField;
 
   return Cl::CM_Modifiable;
 }
Expr::isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc) const {
   case Cl::CM_Function: return MLV_NotObjectType;
   case Cl::CM_LValueCast:
     llvm_unreachable("CM_LValueCast and CL_LValue don't match");
   case Cl::CM_NoSetterProperty: return MLV_NoSetterProperty;
   case Cl::CM_ConstQualified: return MLV_ConstQualified;
   case Cl::CM_ConstQualifiedField: return MLV_ConstQualifiedField;
   case Cl::CM_ConstAddrSpace: return MLV_ConstAddrSpace;
   case Cl::CM_ArrayType: return MLV_ArrayType;
-  case Cl::CM_IncompleteType: return MLV_IncompleteType;
+  case Cl::CM_IndefiniteType: return MLV_IndefiniteType;
   }
   llvm_unreachable("Unhandled modifiable type");
 }

lib/AST/Type.cpp

 /// incomplete types or dependent types.
 bool Type::isConstantSizeType() const {
   assert(!isIncompleteType() && "This doesn't make sense for incomplete types");
   assert(!isDependentType() && "This doesn't make sense for dependent types");
   // The VAT must have a size, as it is known to be complete.
   return !isa<VariableArrayType>(CanonicalType);
 }
 
-/// isIncompleteType - Return true if this is an incomplete type (C99 6.2.5p1)
-/// - a type that can describe objects, but which lacks information needed to
-/// determine its size.
-bool Type::isIncompleteType(NamedDecl **Def) const {
+/// isIndefiniteType - Return true if this is an indefinite type - a type that
+/// can describe objects, but which lacks information needed to construct
+/// them.  For sized types, "indefinite" is equivalent to "incomplete"
+/// (C99 6.2.5p1).
+bool Type::isIndefiniteType(NamedDecl **Def) const {
   if (Def)
     *Def = nullptr;
 
   switch (CanonicalType->getTypeClass()) {
   default: return false;
   case Builtin:
     // Void is the only incomplete builtin type.  Per C99 6.2.5p19, it can never
     // be completed.
case Record: {
     return !Rec->isCompleteDefinition();
   }
   case ConstantArray:
     // An array is incomplete if its element type is incomplete
     // (C++ [dcl.array]p1).
     // We don't handle variable arrays (they're not allowed in C++) or
     // dependent-sized arrays (dependent types are never treated as incomplete).
     return cast<ArrayType>(CanonicalType)->getElementType()
-             ->isIncompleteType(Def);
+             ->isIndefiniteType(Def);
   case IncompleteArray:
     // An array of unknown size is an incomplete type (C99 6.2.5p22).
     return true;
   case MemberPointer: {
     // Member pointers in the MS ABI have special behavior in
     // RequireCompleteType: they attach a MSInheritanceAttr to the CXXRecordDecl
     // to indicate which inheritance model to use.
     auto *MPTy = cast<MemberPointerType>(CanonicalType);
case MemberPointer: {
     RD = RD->getMostRecentDecl();
     // Nothing interesting to do if the inheritance attribute is already set.
     if (RD->hasAttr<MSInheritanceAttr>())
       return false;
     return true;
   }
   case ObjCObject:
     return cast<ObjCObjectType>(CanonicalType)->getBaseType()
-             ->isIncompleteType(Def);
+             ->isIndefiniteType(Def);
   case ObjCInterface: {
     // ObjC interfaces are incomplete if they are @class, not @interface.
     ObjCInterfaceDecl *Interface
       = cast<ObjCInterfaceType>(CanonicalType)->getDecl();
     if (Def)
       *Def = Interface;
     return !Interface->hasDefinition();
   }
bool QualType::isPODType(const ASTContext &Context) const {
   // C++11 has a more relaxed definition of POD.
   if (Context.getLangOpts().CPlusPlus11)
     return isCXX11PODType(Context);
 
   return isCXX98PODType(Context);
 }
 
 bool QualType::isCXX98PODType(const ASTContext &Context) const {
-  // The compiler shouldn't query this for incomplete types, but the user might.
+  // The compiler shouldn't query this for indefinite types, but the user might.
   // We return false for that case. Except for incomplete arrays of PODs, which
   // are PODs according to the standard.
+  //
+  // Sizeless built-in types (like other built-in types) are POD.
   if (isNull())
     return false;
   
   if ((*this)->isIncompleteArrayType())
     return Context.getBaseElementType(*this).isCXX98PODType(Context);
     
-  if ((*this)->isIncompleteType())
+  if ((*this)->isIndefiniteType())
     return false;
 
   if (hasNonTrivialObjCLifetime())
     return false;
   
   QualType CanonicalType = getTypePtr()->CanonicalType;
   switch (CanonicalType->getTypeClass()) {
     // Everything not explicitly mentioned is not POD.
bool QualType::isTrivialType(const ASTContext &Context) const {
   // We return false for that case. Except for incomplete arrays of PODs, which
   // are PODs according to the standard.
   if (isNull())
     return false;
   
   if ((*this)->isArrayType())
     return Context.getBaseElementType(*this).isTrivialType(Context);
   
-  // Return false for incomplete types after skipping any incomplete array
+  // Return false for indefinite types after skipping any incomplete array
   // types which are expressly allowed by the standard and thus our API.
-  if ((*this)->isIncompleteType())
+  // Fall through to the code below for (incomplete) sizeless definite types.
+  if ((*this)->isIndefiniteType())
     return false;
   
   if (hasNonTrivialObjCLifetime())
     return false;
   
   QualType CanonicalType = getTypePtr()->CanonicalType;
   if (CanonicalType->isDependentType())
     return false;
   
   // C++0x [basic.types]p9:
   //   Scalar types, trivial class types, arrays of such types, and
   //   cv-qualified versions of these types are collectively called trivial
   //   types.
   
   // As an extension, Clang treats vector types as Scalar types.
-  if (CanonicalType->isScalarType() || CanonicalType->isVectorType())
+  // Built-in sizeless types are an extension to the standard and they
+  // are all trivial.
+  if (CanonicalType->isScalarType() ||
+      CanonicalType->isSizelessBuiltinType() ||
+      CanonicalType->isVectorType())
     return true;
   if (const auto *RT = CanonicalType->getAs<RecordType>()) {
     if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
       // C++11 [class]p6:
       //   A trivial class is a class that has a default constructor,
       //   has no non-trivial default constructors, and is trivially
       //   copyable.
       return ClassDecl->hasDefaultConstructor() &&
bool QualType::isTriviallyCopyableType(const ASTContext &Context) const {
   //   Scalar types, trivially copyable class types, arrays of such types, and
   //   cv-qualified versions of these types are collectively
   //   called trivially copyable types.
 
   QualType CanonicalType = getCanonicalType();
   if (CanonicalType->isDependentType())
     return false;
 
-  // Return false for incomplete types after skipping any incomplete array types
+  // Return false for indefinite types after skipping any incomplete array types
   // which are expressly allowed by the standard and thus our API.
-  if (CanonicalType->isIncompleteType())
+  // Fall through to the code below for (incomplete) sizeless definite types.
+  if (CanonicalType->isIndefiniteType())
     return false;
- 
   // As an extension, Clang treats vector types as Scalar types.
-  if (CanonicalType->isScalarType() || CanonicalType->isVectorType())
+  // Built-in sizeless types are an extension to the standard and they
+  // are all trivially copyable.
+  if (CanonicalType->isScalarType() ||
+      CanonicalType->isSizelessBuiltinType() ||
+      CanonicalType->isVectorType())
     return true;
 
   if (const auto *RT = CanonicalType->getAs<RecordType>()) {
     if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
       if (!ClassDecl->isTriviallyCopyable()) return false;
     }
 
     return true;
if (hasNonTrivialObjCLifetime())
     return false;
 
   // C++11 [basic.types]p9:
   //   Scalar types, POD classes, arrays of such types, and cv-qualified
   //   versions of these types are collectively called trivial types.
   const Type *BaseTy = ty->getBaseElementTypeUnsafe();
   assert(BaseTy && "NULL element type");
 
-  // Return false for incomplete types after skipping any incomplete array
+  // Return false for indefinite types after skipping any incomplete array
   // types which are expressly allowed by the standard and thus our API.
-  if (BaseTy->isIncompleteType())
+  // Fall through to the code below for (incomplete) sizeless definite types.
+  if (BaseTy->isIndefiniteType())
     return false;
 
   // As an extension, Clang treats vector types as Scalar types.
-  if (BaseTy->isScalarType() || BaseTy->isVectorType()) return true;
+  // Built-in sizeless types are an extension to the standard and they
+  // are all POD.
+  if (BaseTy->isScalarType() ||
+      BaseTy->isSizelessBuiltinType() ||
+      BaseTy->isVectorType())
+    return true;
   if (const auto *RT = BaseTy->getAs<RecordType>()) {
     if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
       // C++11 [class]p10:
       //   A POD struct is a non-union class that is both a trivial class [...]
       if (!ClassDecl->isTrivial()) return false;
 
       // C++11 [class]p10:
       //   A POD struct is a non-union class that is both a trivial class and

lib/Sema/SemaChecking.cpp

 bool Sema::CheckParmsForFunctionDef(ArrayRef<ParmVarDecl *> Parameters,
                                     bool CheckParameterNames) {
   bool HasInvalidParm = false;
   for (ParmVarDecl *Param : Parameters) {
     // C99 6.7.5.3p4: the parameters in a parameter type list in a
     // function declarator that is part of a function definition of
     // that function shall not have incomplete type.
     //
+    // The sizeless type extension replaces "incomplete" with "indefinite",
+    // so that (incomplete) sizeless definite types can be passed to functions.
+    //
     // This is also C++ [dcl.fct]p6.
     if (!Param->isInvalidDecl() &&
-        RequireCompleteType(Param->getLocation(), Param->getType(),
+        RequireDefiniteType(Param->getLocation(), Param->getType(), true,
                             diag::err_typecheck_decl_incomplete_type)) {
       Param->setInvalidDecl();
       HasInvalidParm = true;
     }
 
     // C99 6.9.1p5: If the declarator includes a parameter type list, the
     // declaration of each parameter shall include an identifier.
     if (CheckParameterNames &&

lib/Sema/SemaCodeComplete.cpp

CodeCompleteOverloadResults(*this, S, Results, Args.size(),
                               !CandidateSet.empty());
 }
 
 void Sema::CodeCompleteConstructor(Scope *S, QualType Type, SourceLocation Loc,
                                    ArrayRef<Expr *> Args) {
   if (!CodeCompleter)
     return;
 
-  // A complete type is needed to lookup for constructors.
-  if (!isCompleteType(Loc, Type))
+  // A definite type is needed to lookup for constructors.  Fall through
+  // to the handling below for (incomplete) sizeless definite types.
+  if (!isDefiniteType(Loc, Type))
     return;
 
   CXXRecordDecl *RD = Type->getAsCXXRecordDecl();
   if (!RD) {
     CodeCompleteExpression(S, Type);
     return;
   }
 

lib/Sema/SemaDecl.cpp

static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) {
 
   if (isa<TypedefNameDecl>(D))
     return true;
 
   // White-list anything that isn't a local variable.
   if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D))
     return false;
 
-  // Types of valid local variables should be complete, so this should succeed.
+  // Types of valid local variables should be definite, so this should succeed.
   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
 
     // White-list anything with an __attribute__((unused)) type.
     const auto *Ty = VD->getType().getTypePtr();
 
     // Only look at the outermost level of typedef.
     if (const TypedefType *TT = Ty->getAs<TypedefType>()) {
       if (TT->getDecl()->hasAttr<UnusedAttr>())
         return false;
     }
 
-    // If we failed to complete the type for some reason, or if the type is
-    // dependent, don't diagnose the variable.
-    if (Ty->isIncompleteType() || Ty->isDependentType())
+    // If we failed to make the type definite for some reason, or if the type
+    // is dependent, don't diagnose the variable.
+    if (Ty->isIndefiniteType() || Ty->isDependentType())
       return false;
 
     // Look at the element type to ensure that the warning behaviour is
     // consistent for both scalars and arrays.
     Ty = Ty->getBaseElementTypeUnsafe();
 
     if (const TagType *TT = Ty->getAs<TagType>()) {
       const TagDecl *Tag = TT->getDecl();
void Sema::CheckVariableDeclarationType(VarDecl *NewVD) {
   }
 
   if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) {
     Diag(NewVD->getLocation(), diag::err_block_on_nonlocal);
     NewVD->setInvalidDecl();
     return;
   }
 
+  if (!NewVD->hasLocalStorage() && T->isSizelessType()) {
+    Diag(NewVD->getLocation(), diag::err_sizeless_nonlocal) << T;
+    NewVD->setInvalidDecl();
+    return;
+  }
+
   if (isVM && NewVD->hasAttr<BlocksAttr>()) {
     Diag(NewVD->getLocation(), diag::err_block_on_vm);
     NewVD->setInvalidDecl();
     return;
   }
 
   if (NewVD->isConstexpr() && !T->isDependentType() &&
       RequireLiteralType(NewVD->getLocation(), T,
if (getLangOpts().CPlusPlus) {
     }
 
     // If this function is declared as being extern "C", then check to see if
     // the function returns a UDT (class, struct, or union type) that is not C
     // compatible, and if it does, warn the user.
     // But, issue any diagnostic on the first declaration only.
     if (Previous.empty() && NewFD->isExternC()) {
       QualType R = NewFD->getReturnType();
-      if (R->isIncompleteType() && !R->isVoidType())
+      // "Indefinite" rather than "incomplete" because C functions can
+      // return (incomplete) sizeless definite types.
+      if (R->isIndefiniteType() && !R->isVoidType())
         Diag(NewFD->getLocation(), diag::warn_return_value_udt_incomplete)
             << NewFD << R;
       else if (!R.isPODType(Context) && !R->isVoidType() &&
                !R->isObjCObjectPointerType())
         Diag(NewFD->getLocation(), diag::warn_return_value_udt) << NewFD << R;
     }
 
     // C++1z [dcl.fct]p6:
void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init, bool DirectInit) {
 
   if (!VDecl->getType()->isDependentType()) {
     // A definition must end up with a complete type, which means it must be
     // complete with the restriction that an array type might be completed by
     // the initializer; note that later code assumes this restriction.
     QualType BaseDeclType = VDecl->getType();
     if (const ArrayType *Array = Context.getAsIncompleteArrayType(BaseDeclType))
       BaseDeclType = Array->getElementType();
-    if (RequireCompleteType(VDecl->getLocation(), BaseDeclType,
+    // The sizeless type extension replaces "complete object type" with
+    // "definite object type" in C11 6.7.9/3, to allow initialization of
+    // identifiers with sizeless definite type.
+    if (RequireDefiniteType(VDecl->getLocation(), BaseDeclType, true,
                             diag::err_typecheck_decl_incomplete_type)) {
       RealDecl->setInvalidDecl();
       return;
     }
 
     // The variable can not have an abstract class type.
     if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(),
                                diag::err_abstract_type_in_decl,
void Sema::ActOnInitializerError(Decl *D) {
   if (ParsingInitForAutoVars.count(D)) {
     D->setInvalidDecl();
     return;
   }
 
   QualType Ty = VD->getType();
   if (Ty->isDependentType()) return;
 
-  // Require a complete type.
-  if (RequireCompleteType(VD->getLocation(),
-                          Context.getBaseElementType(Ty),
+  // The sizeless type extension replaces "complete object type" with
+  // "definite object type" in C11 6.7.9/3, to allow initialization of
+  // identifiers with sizeless definite type.
+  if (RequireDefiniteType(VD->getLocation(),
+                          Context.getBaseElementType(Ty), true,
                           diag::err_typecheck_decl_incomplete_type)) {
     VD->setInvalidDecl();
     return;
   }
 
   // Require a non-abstract type.
   if (RequireNonAbstractType(VD->getLocation(), Ty,
                              diag::err_abstract_type_in_decl,
case VarDecl::Definition:
       LLVM_FALLTHROUGH;
 
     case VarDecl::DeclarationOnly:
       // It's only a declaration.
 
       // Block scope. C99 6.7p7: If an identifier for an object is
       // declared with no linkage (C99 6.2.2p6), the type for the
       // object shall be complete.
+      //
+      // In practice this if statement appears to be dead, since no such
+      // variable would be classified as DeclarationOnly.  Logically it
+      // should include (incomplete) sizeless definite types though.
       if (!Type->isDependentType() && Var->isLocalVarDecl() &&
           !Var->hasLinkage() && !Var->isInvalidDecl() &&
-          RequireCompleteType(Var->getLocation(), Type,
+          RequireDefiniteType(Var->getLocation(), Type, true,
                               diag::err_typecheck_decl_incomplete_type))
         Var->setInvalidDecl();
 
       // Make sure that the type is not abstract.
       if (!Type->isDependentType() && !Var->isInvalidDecl() &&
           RequireNonAbstractType(Var->getLocation(), Type,
                                  diag::err_abstract_type_in_decl,
                                  AbstractVariableType))
if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
     // variable with dependent type.
     if (Type->isDependentType())
       return;
 
     if (Var->isInvalidDecl())
       return;
 
     if (!Var->hasAttr<AliasAttr>()) {
-      if (RequireCompleteType(Var->getLocation(),
-                              Context.getBaseElementType(Type),
+      // The sizeless type extension replaces "complete" with "definite"
+      // in C11 6.7/7, to allow declarations with sizeless definite type.
+      if (RequireDefiniteType(Var->getLocation(),
+                              Context.getBaseElementType(Type), true,
                               diag::err_typecheck_decl_incomplete_type)) {
         Var->setInvalidDecl();
         return;
       }
     } else {
       return;
     }
 
if (unsigned BuiltinID = FD->getBuiltinID()) {
     if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID) &&
         !Context.BuiltinInfo.isPredefinedRuntimeFunction(BuiltinID)) {
       Diag(FD->getLocation(), diag::err_builtin_definition) << FD;
       FD->setInvalidDecl();
     }
   }
 
   // The return type of a function definition must be complete
-  // (C99 6.9.1p3, C++ [dcl.fct]p6).
+  // (C99 6.9.1p3, C++ [dcl.fct]p6).  The sizeless type extension replaces
+  // "complete object type" with "definite object type", so that functions
+  // can return sizeless definite types.
   QualType ResultType = FD->getReturnType();
   if (!ResultType->isDependentType() && !ResultType->isVoidType() &&
       !FD->isInvalidDecl() &&
-      RequireCompleteType(FD->getLocation(), ResultType,
+      RequireDefiniteType(FD->getLocation(), ResultType, true,
                           diag::err_func_def_incomplete_result))
     FD->setInvalidDecl();
 
   if (FnBodyScope)
     PushDeclContext(FnBodyScope, FD);
 
   // Check the validity of our function parameters
   CheckParmsForFunctionDef(FD->parameters(),
FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T,
   QualType EltTy = Context.getBaseElementType(T);
   if (!EltTy->isDependentType()) {
     if (RequireCompleteType(Loc, EltTy, diag::err_field_incomplete)) {
       // Fields of incomplete type force their record to be invalid.
       Record->setInvalidDecl();
       InvalidDecl = true;
     } else {
       NamedDecl *Def;
-      EltTy->isIncompleteType(&Def);
+      EltTy->isIndefiniteType(&Def);
       if (Def && Def->isInvalidDecl()) {
         Record->setInvalidDecl();
         InvalidDecl = true;
       }
     }
   }
 
   // OpenCL v1.2 s6.9.c: bitfields are not supported.

lib/Sema/SemaDeclAttr.cpp

void Sema::CheckAlignasUnderalignment(Decl *D) {
   QualType UnderlyingTy, DiagTy;
   if (const auto *VD = dyn_cast<ValueDecl>(D)) {
     UnderlyingTy = DiagTy = VD->getType();
   } else {
     UnderlyingTy = DiagTy = Context.getTagDeclType(cast<TagDecl>(D));
     if (const auto *ED = dyn_cast<EnumDecl>(D))
       UnderlyingTy = ED->getIntegerType();
   }
-  if (DiagTy->isDependentType() || DiagTy->isIncompleteType())
+  // "Indefinite" rather than "incomplete" because we want to raise an
+  // error for (incomplete) sizeless definite types below.
+  if (DiagTy->isDependentType() || DiagTy->isIndefiniteType())
     return;
 
   // C++11 [dcl.align]p5, C11 6.7.5/4:
   //   The combined effect of all alignment attributes in a declaration shall
   //   not specify an alignment that is less strict than the alignment that
   //   would otherwise be required for the entity being declared.
   AlignedAttr *AlignasAttr = nullptr;
+  AlignedAttr *LastAlignedAttr = nullptr;
   unsigned Align = 0;
   for (auto *I : D->specific_attrs<AlignedAttr>()) {
     if (I->isAlignmentDependent())
       return;
     if (I->isAlignas())
       AlignasAttr = I;
     Align = std::max(Align, I->getAlignment(Context));
+    LastAlignedAttr = I;
   }
 
-  if (AlignasAttr && Align) {
+  if (Align && DiagTy->isSizelessType()) {
+    Diag(LastAlignedAttr->getLocation(), diag::err_attribute_sizeless_type)
+      << LastAlignedAttr->getSpelling() << DiagTy;
+  } else if (AlignasAttr && Align) {
     CharUnits RequestedAlign = Context.toCharUnitsFromBits(Align);
     CharUnits NaturalAlign = Context.getTypeAlignInChars(UnderlyingTy);
     if (NaturalAlign > RequestedAlign)
       Diag(AlignasAttr->getLocation(), diag::err_alignas_underaligned)
         << DiagTy << (unsigned)NaturalAlign.getQuantity();
   }
 }
 

lib/Sema/SemaDeclCXX.cpp

void Sema::ImplicitExceptionSpecification::CalledExpr(Expr *E) {
 
   if (Self->canThrow(E))
     ComputedEST = EST_None;
 }
 
 bool
 Sema::SetParamDefaultArgument(ParmVarDecl *Param, Expr *Arg,
                               SourceLocation EqualLoc) {
-  if (RequireCompleteType(Param->getLocation(), Param->getType(),
+  // C++ [dcl.fct]/9: "the type of a parameter ... shall not be an
+  // incomplete class type".  The sizeless type extension leaves this
+  // wording as-is, so that it doesn't apply to sizeless definite types,
+  // which at present are never class types.
+  if (RequireDefiniteType(Param->getLocation(), Param->getType(), true,
                           diag::err_typecheck_decl_incomplete_type)) {
     Param->setInvalidDecl();
     return true;
   }
 
   // C++ [dcl.fct.default]p5
   //   A default argument expression is implicitly converted (clause
   //   4) to the parameter type. The default argument expression has

lib/Sema/SemaExpr.cpp

ExprResult Sema::DefaultArgumentPromotion(Expr *E) {
 
   return E;
 }
 
 /// Determine the degree of POD-ness for an expression.
 /// Incomplete types are considered POD, since this check can be performed
 /// when we're in an unevaluated context.
 Sema::VarArgKind Sema::isValidVarArgType(const QualType &Ty) {
-  if (Ty->isIncompleteType()) {
+  // "Indefinite" rather than "incomplete" since (incomplete) sizeless definite
+  // types can be passed to functions.
+  if (Ty->isIndefiniteType()) {
     // C++11 [expr.call]p7:
     //   After these conversions, if the argument does not have arithmetic,
     //   enumeration, pointer, pointer to member, or class type, the program
     //   is ill-formed.
     //
     // Since we've already performed array-to-pointer and function-to-pointer
     // decay, the only such type in C++ is cv void. This also handles
     // initializer lists as variadic arguments.
if (isValidVarArgType(E->getType()) == VAK_Undefined) {
 
     ExprResult Comma = ActOnBinOp(TUScope, E->getLocStart(), tok::comma,
                                   Call.get(), E);
     if (Comma.isInvalid())
       return ExprError();
     return Comma.get();
   }
 
+  // The sizeless type extension replaces "complete object type" with
+  // "definite object type" in C11 6.5.2.2/4, so that arguments can
+  // have sizeless definite type.
   if (!getLangOpts().CPlusPlus &&
-      RequireCompleteType(E->getExprLoc(), E->getType(),
+      RequireDefiniteType(E->getExprLoc(), E->getType(), true,
                           diag::err_call_incomplete_argument))
     return ExprError();
 
   return E;
 }
 
 /// \brief Converts an integer to complex float type.  Helper function of
 /// UsualArithmeticConversions()
if (Types[i]) {
       if (Types[i]->getType()->containsUnexpandedParameterPack())
         ContainsUnexpandedParameterPack = true;
 
       if (Types[i]->getType()->isDependentType()) {
         IsResultDependent = true;
       } else {
         // C11 6.5.1.1p2 "The type name in a generic association shall specify a
         // complete object type other than a variably modified type."
+        //
+        // The sizeless type extension replaces "complete" with "definite",
+        // so that _Generic can be used with sizeless definite types.
         unsigned D = 0;
-        if (Types[i]->getType()->isIncompleteType())
+        if (Types[i]->getType()->isIndefiniteType())
           D = diag::err_assoc_type_incomplete;
         else if (!Types[i]->getType()->isObjectType())
           D = diag::err_assoc_type_nonobject;
         else if (Types[i]->getType()->isVariablyModifiedType())
           D = diag::err_assoc_type_variably_modified;
 
         if (D != 0) {
           Diag(Types[i]->getTypeLoc().getBeginLoc(), D)
bool Sema::GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl,
   for (unsigned i = FirstParam; i < NumParams; i++) {
     QualType ProtoArgType = Proto->getParamType(i);
 
     Expr *Arg;
     ParmVarDecl *Param = FDecl ? FDecl->getParamDecl(i) : nullptr;
     if (ArgIx < Args.size()) {
       Arg = Args[ArgIx++];
 
-      if (RequireCompleteType(Arg->getLocStart(),
-                              ProtoArgType,
+      // The sizeless type extension replaces "complete object type" with
+      // "definite object type" in C11 6.5.2.2/4, so that arguments can
+      // have sizeless definite type.
+      if (RequireDefiniteType(Arg->getLocStart(), ProtoArgType, true,
                               diag::err_call_incomplete_argument, Arg))
         return true;
 
       // Strip the unbridged-cast placeholder expression off, if applicable.
       bool CFAudited = false;
       if (Arg->getType() == Context.ARCUnbridgedCastTy &&
           FDecl && FDecl->hasAttr<CFAuditedTransferAttr>() &&
           (!Param || !Param->hasAttr<CFConsumedAttr>()))
for (unsigned i = 0, e = Args.size(); i != e; i++) {
         ExprResult ArgE = DefaultArgumentPromotion(Arg);
 
         if (ArgE.isInvalid())
           return true;
 
         Arg = ArgE.getAs<Expr>();
       }
       
-      if (RequireCompleteType(Arg->getLocStart(),
-                              Arg->getType(),
+      // The sizeless type extension replaces "complete object type" with
+      // "definite object type" in C11 6.5.2.2/4, so that arguments can
+      // have sizeless definite type.
+      if (RequireDefiniteType(Arg->getLocStart(), Arg->getType(), true,
                               diag::err_call_incomplete_argument, Arg))
         return ExprError();
 
       TheCall->setArg(i, Arg);
     }
   }
 
   if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
if (RequireCompleteType(LParenLoc, Context.getBaseElementType(literalType),
           diag::err_illegal_decl_array_incomplete_type,
           SourceRange(LParenLoc,
                       LiteralExpr->getSourceRange().getEnd())))
       return ExprError();
     if (literalType->isVariableArrayType())
       return ExprError(Diag(LParenLoc, diag::err_variable_object_no_init)
         << SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd()));
   } else if (!literalType->isDependentType() &&
-             RequireCompleteType(LParenLoc, literalType,
+             // The sizeless type extension replaces "complete object type"
+             // with "definite object type" in C11 6.5.2.5/1, so that compound
+             // literals can have sizeless definite type.
+             RequireDefiniteType(LParenLoc, literalType, true,
                diag::err_typecheck_decl_incomplete_type,
                SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd())))
     return ExprError();
 
   InitializedEntity Entity
     = InitializedEntity::InitializeCompoundLiteralInit(TInfo);
   InitializationKind Kind
     = InitializationKind::CreateCStyleCast(LParenLoc, 
QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
   // null pointers have been filtered out by this point.
   if (checkPointerIntegerMismatch(*this, LHS, RHS.get(), QuestionLoc,
       /*isIntFirstExpr=*/true))
     return RHSTy;
   if (checkPointerIntegerMismatch(*this, RHS, LHS.get(), QuestionLoc,
       /*isIntFirstExpr=*/false))
     return LHSTy;
 
+  // Allow ?: operations in which both operands have the same sizeless type.
+  if (LHSTy->isSizelessType() && LHSTy == RHSTy)
+    return LHSTy;
+
   // Emit a better diagnostic if one of the expressions is a null pointer
   // constant and the other is not a pointer type. In this case, the user most
   // likely forgot to take the address of the other expression.
   if (DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc))
     return QualType();
 
   // Otherwise, the operands are not compatible.
   Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
case Expr::MLV_LValueCast:
     break;
   case Expr::MLV_Valid:
     llvm_unreachable("did not take early return for MLV_Valid");
   case Expr::MLV_InvalidExpression:
   case Expr::MLV_MemberFunction:
   case Expr::MLV_ClassTemporary:
     DiagID = diag::err_typecheck_expression_not_modifiable_lvalue;
     break;
-  case Expr::MLV_IncompleteType:
+  case Expr::MLV_IndefiniteType:
   case Expr::MLV_IncompleteVoidType:
     return S.RequireCompleteType(Loc, E->getType(),
              diag::err_typecheck_incomplete_type_not_modifiable_lvalue, E);
   case Expr::MLV_DuplicateVectorComponents:
     DiagID = diag::err_typecheck_duplicate_vector_components_not_mlvalue;
     break;
   case Expr::MLV_NoSetterProperty:
     llvm_unreachable("readonly properties should be processed differently");
static QualType CheckCommaOperands(Sema &S, ExprResult &LHS, ExprResult &RHS,
 
   S.DiagnoseUnusedExprResult(LHS.get());
 
   if (!S.getLangOpts().CPlusPlus) {
     RHS = S.DefaultFunctionArrayLvalueConversion(RHS.get());
     if (RHS.isInvalid())
       return QualType();
     if (!RHS.get()->getType()->isVoidType())
-      S.RequireCompleteType(Loc, RHS.get()->getType(),
+      // The test is for definiteness rather than completeness because
+      // the sizeless type extension allows (incomplete) sized definite
+      // types on the rhs of a comma operator.
+      S.RequireDefiniteType(Loc, RHS.get()->getType(), true,
                             diag::err_incomplete_type);
   }
 
   if (!S.getDiagnostics().isIgnored(diag::warn_comma_operator, Loc))
     S.DiagnoseCommaOperator(LHS.get(), Loc);
 
   return RHS.get()->getType();
 }
ExprResult Sema::BuildVAArgExpr(SourceLocation BuiltinLoc,
 
   if (!IsMS && !E->isTypeDependent() &&
       !Context.hasSameType(VaListType, E->getType()))
     return ExprError(Diag(E->getLocStart(),
                          diag::err_first_argument_to_va_arg_not_of_type_va_list)
       << OrigExpr->getType() << E->getSourceRange());
 
   if (!TInfo->getType()->isDependentType()) {
-    if (RequireCompleteType(TInfo->getTypeLoc().getBeginLoc(), TInfo->getType(),
+    // The test is for definiteness rather than completeness because the
+    // sizeless type extensions allows (incomplete) sizeless definite types
+    // to be passed to functions.
+    if (RequireDefiniteType(TInfo->getTypeLoc().getBeginLoc(),
+                            TInfo->getType(), true,
                             diag::err_second_parameter_to_va_arg_incomplete,
                             TInfo->getTypeLoc()))
       return ExprError();
 
     if (RequireNonAbstractType(TInfo->getTypeLoc().getBeginLoc(),
                                TInfo->getType(),
                                diag::err_second_parameter_to_va_arg_abstract,
                                TInfo->getTypeLoc()))
case ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed:
     return true;
   }
 
   return false;
 }
 
 bool Sema::CheckCallReturnType(QualType ReturnType, SourceLocation Loc,
                                CallExpr *CE, FunctionDecl *FD) {
-  if (ReturnType->isVoidType() || !ReturnType->isIncompleteType())
+  // The sizeless type extension replaces "complete object type" with
+  // "definite object type" in C11 6.5.2.2/1, so that functions can
+  // return sizeless definite types.
+  if (ReturnType->isVoidType() || ReturnType->isDefiniteType())
     return false;
 
   // If we're inside a decltype's expression, don't check for a valid return
   // type or construct temporaries until we know whether this is the last call.
   if (ExprEvalContexts.back().IsDecltype) {
     ExprEvalContexts.back().DelayedDecltypeCalls.push_back(CE);
     return false;
   }
void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
       }
       
       S.Diag(Loc, diag::err_call_function_incomplete_return)
         << CE->getSourceRange() << FD->getDeclName() << T;
       S.Diag(FD->getLocation(), diag::note_entity_declared_at)
           << FD->getDeclName();
     }
   } Diagnoser(FD, CE);
-  
-  if (RequireCompleteType(Loc, ReturnType, Diagnoser))
+  if (RequireDefiniteType(Loc, ReturnType, true, Diagnoser))
     return true;
 
   return false;
 }
 
 // Diagnose the s/=/==/ and s/\|=/!=/ typos. Note that adding parentheses
 // will prevent this condition from triggering, which is what we want.
 void Sema::DiagnoseAssignmentAsCondition(Expr *E) {

lib/Sema/SemaExprCXX.cpp

Sema::BuildCXXTypeConstructExpr(TypeSourceInfo *TInfo,
   // we only construct objects with object types.
   if (Ty->isFunctionType())
     return ExprError(Diag(TyBeginLoc, diag::err_init_for_function_type)
                        << Ty << FullRange);
 
   // C++17 [expr.type.conv]p2:
   //   If the type is cv void and the initializer is (), the expression is a
   //   prvalue of the specified type that performs no initialization.
+  //
+  //   The sizeless type extension replaces "complete" with "definite",
+  //   so that sizeless definite types can be zero-initialized using ().
   if (!Ty->isVoidType() &&
-      RequireCompleteType(TyBeginLoc, ElemTy,
+      RequireDefiniteType(TyBeginLoc, ElemTy, true,
                           diag::err_invalid_incomplete_type_use, FullRange))
     return ExprError();
 
   //   Otherwise, the expression is a prvalue of the specified type whose
   //   result object is direct-initialized (11.6) with the initializer.
   InitializationSequence InitSeq(*this, Entity, Kind, Exprs);
   ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Exprs);
 
static bool CheckUnaryTypeTraitTypeCompleteness(Sema &S, TypeTrait UTT,
   case UTT_IsSealed:
     if (ArgTy->getAsCXXRecordDecl())
       return !S.RequireCompleteType(
           Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
     return true;
 
   // C++1z [meta.unary.prop]:
   //   remove_all_extents_t<T> shall be a complete type or cv void.
+  //
+  // The sizeless type extension replaces "complete" with "definite",
+  // so that it's possible to apply traits to sizeless definite types.
   case UTT_IsAggregate:
   case UTT_IsTrivial:
   case UTT_IsTriviallyCopyable:
   case UTT_IsStandardLayout:
   case UTT_IsPOD:
   case UTT_IsLiteral:
   // Per the GCC type traits documentation, T shall be a complete type, cv void,
   // or an array of unknown bound. But GCC actually imposes the same constraints
static bool CheckUnaryTypeTraitTypeCompleteness(Sema &S, TypeTrait UTT,
   //   T shall be a complete type, cv void, or an array of unknown bound.
   case UTT_IsDestructible:
   case UTT_IsNothrowDestructible:
   case UTT_IsTriviallyDestructible:
   case UTT_HasUniqueObjectRepresentations:
     if (ArgTy->isIncompleteArrayType() || ArgTy->isVoidType())
       return true;
 
-    return !S.RequireCompleteType(
-        Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
+    return !S.RequireDefiniteType(
+        Loc, ArgTy, true, diag::err_incomplete_type_used_in_type_trait_expr);
   }
 }
 
 static bool HasNoThrowOperator(const RecordType *RT, OverloadedOperatorKind Op,
                                Sema &Self, SourceLocation KeyLoc, ASTContext &C,
                                bool (CXXRecordDecl::*HasTrivial)() const,
                                bool (CXXRecordDecl::*HasNonTrivial)() const,
                                bool (CXXMethodDecl::*IsDesiredOp)() const)
case UTT_IsNothrowDestructible:
     // Objective-C++ ARC: autorelease types don't require destruction.
     if (T->isObjCLifetimeType() &&
         T.getObjCLifetime() == Qualifiers::OCL_Autoreleasing)
       return true;
 
     // C++14 [meta.unary.prop]:
     //   For incomplete types and function types, is_destructible<T>::value is
     //   false.
-    if (T->isIncompleteType() || T->isFunctionType())
+    //
+    // The sizeless type extension replaces "incomplete" with "indefinite",
+    // since sizeless definite types can be created with automatic storage
+    // duration and must therefore be destructible.
+    if (T->isIndefiniteType() || T->isFunctionType())
       return false;
 
     // A type that requires destruction (via a non-trivial destructor or ARC
     // lifetime semantics) is not trivially-destructible.
     if (UTT == UTT_IsTriviallyDestructible && T.isDestructedType())
       return false;
 
     // C++14 [meta.unary.prop]:
case clang::TT_IsTriviallyConstructible: {
     //   variable t:
     //
     //     T t(create<Args>()...);
     assert(!Args.empty());
 
     // Precondition: T and all types in the parameter pack Args shall be
     // complete types, (possibly cv-qualified) void, or arrays of
     // unknown bound.
+    //
+    // The sizeless type extension replaces "complete" with "definite",
+    // so that sizeless definite types can be used with the traits.
     for (const auto *TSI : Args) {
       QualType ArgTy = TSI->getType();
       if (ArgTy->isVoidType() || ArgTy->isIncompleteArrayType())
         continue;
 
-      if (S.RequireCompleteType(KWLoc, ArgTy,
+      if (S.RequireDefiniteType(KWLoc, ArgTy, true,
           diag::err_incomplete_type_used_in_type_trait_expr))
         return false;
     }
 
     // Make sure the first argument is not incomplete nor a function type.
+    //
+    // The sizeless type extension replaces "incomplete" with "indefinite",
+    // so that sizeless definite types can be used with the traits.
     QualType T = Args[0]->getType();
-    if (T->isIncompleteType() || T->isFunctionType())
+    if (T->isIndefiniteType() || T->isFunctionType())
       return false;
 
     // Make sure the first argument is not an abstract type.
     CXXRecordDecl *RD = T->getAsCXXRecordDecl();
     if (RD && RD->isAbstract())
       return false;
 
     SmallVector<OpaqueValueExpr, 2> OpaqueArgExprs;
if (!rhsRecord || !lhsRecord) {
       if (!LHSObjTy || !RHSObjTy)
         return false;
 
       ObjCInterfaceDecl *BaseInterface = LHSObjTy->getInterface();
       ObjCInterfaceDecl *DerivedInterface = RHSObjTy->getInterface();
       if (!BaseInterface || !DerivedInterface)
         return false;
 
-      if (Self.RequireCompleteType(
-              KeyLoc, RhsT, diag::err_incomplete_type_used_in_type_trait_expr))
+      // The sizeless type extension replaces "complete" with "definite",
+      // so that sizeless definite types can be used with the traits.
+      if (Self.RequireDefiniteType(
+              KeyLoc, RhsT, true,
+              diag::err_incomplete_type_used_in_type_trait_expr))
         return false;
 
       return BaseInterface->isSuperClassOf(DerivedInterface);
     }
 
     assert(Self.Context.hasSameUnqualifiedType(LhsT, RhsT)
              == (lhsRecord == rhsRecord));
 
case BTT_IsConvertibleTo: {
     if (RhsT->isFunctionType() || RhsT->isArrayType())
       return false;
 
     // A return statement in a void function must have void type.
     if (RhsT->isVoidType())
       return LhsT->isVoidType();
 
     // A function definition requires a complete, non-abstract return type.
-    if (!Self.isCompleteType(KeyLoc, RhsT) || Self.isAbstractType(KeyLoc, RhsT))
+    //
+    // The sizeless type extension replaces "complete" with "definite",
+    // so that functions can return sizeless definite types.
+    if (!Self.isDefiniteType(KeyLoc, RhsT) || Self.isAbstractType(KeyLoc, RhsT))
       return false;
 
     // Compute the result of add_rvalue_reference.
     if (LhsT->isObjectType() || LhsT->isFunctionType())
       LhsT = Self.Context.getRValueReferenceType(LhsT);
 
     // Build a fake source and destination for initialization.
     InitializedEntity To(InitializedEntity::InitializeTemporary(RhsT));
case BTT_IsTriviallyAssignable: {
     //     is_assignable, is known to call no operation that is not trivial
     //
     //   is_assignable is defined as:
     //     The expression declval<T>() = declval<U>() is well-formed when
     //     treated as an unevaluated operand (Clause 5).
     //
     //   For both, T and U shall be complete types, (possibly cv-qualified)
     //   void, or arrays of unknown bound.
+    //
+    //   The sizeless type extension replaces "complete" with "definite",
+    //   so that functions can return sizeless definite types.
     if (!LhsT->isVoidType() && !LhsT->isIncompleteArrayType() &&
-        Self.RequireCompleteType(KeyLoc, LhsT,
+        Self.RequireDefiniteType(KeyLoc, LhsT, true,
           diag::err_incomplete_type_used_in_type_trait_expr))
       return false;
     if (!RhsT->isVoidType() && !RhsT->isIncompleteArrayType() &&
-        Self.RequireCompleteType(KeyLoc, RhsT,
+        Self.RequireDefiniteType(KeyLoc, RhsT, true,
           diag::err_incomplete_type_used_in_type_trait_expr))
       return false;
 
     // cv void is never assignable.
     if (LhsT->isVoidType() || RhsT->isVoidType())
       return false;
 
     // Build expressions that emulate the effect of declval<T>() and
ExprResult Sema::IgnoredValueConversions(Expr *E) {
   }
 
   ExprResult Res = DefaultFunctionArrayLvalueConversion(E);
   if (Res.isInvalid())
     return E;
   E = Res.get();
 
   if (!E->getType()->isVoidType())
-    RequireCompleteType(E->getExprLoc(), E->getType(),
+    // The test is based on definiteness rather than completeness
+    // because (incomplete) sized definite types can be used in an
+    // ignored result.
+    RequireDefiniteType(E->getExprLoc(), E->getType(), true,
                         diag::err_incomplete_type);
   return E;
 }
 
 // If we can unambiguously determine whether Var can never be used
 // in a constant expression, return true.
 //  - if the variable and its initializer are non-dependent, then
 //    we can unambiguously check if the variable is a constant expression.

lib/Sema/SemaFixItUtils.cpp

if (T.isChar16Type())
     return "u'\\0'";
   if (T.isChar32Type())
     return "U'\\0'";
   return "0";
 }
 
 std::string
 Sema::getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const {
+  if (T->isSizelessBuiltinType() && LangOpts.CPlusPlus)
+    return std::string(" = ") + T.getAsString() + "()";
+
   if (T->isScalarType()) {
     std::string s = getScalarZeroExpressionForType(*T, Loc, *this);
     if (!s.empty())
       s = " = " + s;
     return s;
   }
 
   const CXXRecordDecl *RD = T->getAsCXXRecordDecl();

lib/Sema/SemaInit.cpp

if (StructuredIndex == 1 &&
       unsigned DK = diag::ext_excess_initializers_in_char_array_initializer;
       if (SemaRef.getLangOpts().CPlusPlus) {
         DK = diag::err_excess_initializers_in_char_array_initializer;
         hadError = true;
       }
       // Special-case
       SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
         << IList->getInit(Index)->getSourceRange();
-    } else if (!T->isIncompleteType()) {
-      // Don't complain for incomplete types, since we'll get an error
+    } else if (!T->isIndefiniteType()) {
+      // Don't complain for indefinite types, since we'll get an error
       // elsewhere
       QualType CurrentObjectType = StructuredList->getType();
       int initKind =
         CurrentObjectType->isArrayType()? 0 :
         CurrentObjectType->isVectorType()? 1 :
-        CurrentObjectType->isScalarType()? 2 :
+        CurrentObjectType->isScalarType() ||
+        // Treat sizeless builtin types as scalars for the purposes of
+        // this diagnostic, since the rules are the same.  Calling them
+        // out as a special case is unlikely to be helpful.
+        CurrentObjectType->isSizelessBuiltinType()? 2 :
         CurrentObjectType->isUnionType()? 3 :
         4;
 
       unsigned DK = diag::ext_excess_initializers;
       if (SemaRef.getLangOpts().CPlusPlus) {
         DK = diag::err_excess_initializers;
         hadError = true;
       }
void InitListChecker::CheckListElementTypes(const InitializedEntity &Entity,
                                             InitListExpr *StructuredList,
                                             unsigned &StructuredIndex,
                                             bool TopLevelObject) {
   if (DeclType->isAnyComplexType() && SubobjectIsDesignatorContext) {
     // Explicitly braced initializer for complex type can be real+imaginary
     // parts.
     CheckComplexType(Entity, IList, DeclType, Index,
                      StructuredList, StructuredIndex);
-  } else if (DeclType->isScalarType()) {
+  } else if (DeclType->isScalarType() || DeclType->isSizelessBuiltinType()) {
     CheckScalarType(Entity, IList, DeclType, Index,
                     StructuredList, StructuredIndex);
   } else if (DeclType->isVectorType()) {
     CheckVectorType(Entity, IList, DeclType, Index,
                     StructuredList, StructuredIndex);
   } else if (DeclType->isRecordType()) {
     assert(DeclType->isAggregateType() &&
            "non-aggregate records should be handed in CheckSubElementType");
if (Seq || isa<InitListExpr>(expr)) {
                                     Result.getAs<Expr>());
       } else if (!Seq)
         hadError = true;
       ++Index;
       return;
     }
 
     // Fall through for subaggregate initialization
-  } else if (ElemType->isScalarType() || ElemType->isAtomicType()) {
+  } else if (ElemType->isScalarType() || ElemType->isAtomicType() ||
+             ElemType->isSizelessBuiltinType()) {
     // FIXME: Need to handle atomic aggregate types with implicit init lists.
     return CheckScalarType(Entity, IList, ElemType, Index,
                            StructuredList, StructuredIndex);
   } else if (const ArrayType *arrayType =
                  SemaRef.Context.getAsArrayType(ElemType)) {
     // arrayType can be incomplete if we're initializing a flexible
     // array member.  There's nothing we can do with the completed
     // type here, though.
bool InitializationSequence::isAmbiguous() const {
   case FK_ReferenceInitFailed:
   case FK_ConversionFailed:
   case FK_ConversionFromPropertyFailed:
   case FK_TooManyInitsForScalar:
   case FK_ParenthesizedListInitForScalar:
   case FK_ReferenceBindingToInitList:
   case FK_InitListBadDestinationType:
   case FK_DefaultInitOfConst:
-  case FK_Incomplete:
+  case FK_Indefinite:
   case FK_ArrayTypeMismatch:
   case FK_NonConstantArrayInit:
   case FK_ListInitializationFailed:
   case FK_VariableLengthArrayHasInitializer:
   case FK_PlaceholderType:
   case FK_ExplicitConstructor:
   case FK_AddressOfUnaddressableFunction:
     return false;
static bool TryInitializerListConstruction(Sema &S,
                                            InitListExpr *List,
                                            QualType DestType,
                                            InitializationSequence &Sequence,
                                            bool TreatUnavailableAsInvalid) {
   QualType E;
   if (!S.isStdInitializerList(DestType, &E))
     return false;
 
+  // "Complete" and "definite" are the same here, because
+  // std::initializer_list<T> is always sized.
   if (!S.isCompleteType(List->getExprLoc(), E)) {
-    Sequence.setIncompleteTypeFailure(E);
+    Sequence.setIndefiniteTypeFailure(E);
     return true;
   }
 
   // Try initializing a temporary array from the init list.
   QualType ArrayType = S.Context.getConstantArrayType(
       E.withConst(), llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
                                  List->getNumInits()),
       clang::ArrayType::Normal, 0);
assert(((!IsListInit && !IsInitListCopy) ||
          "IsListInit/IsInitListCopy must come with a single initializer list "
          "argument.");
   InitListExpr *ILE =
       (IsListInit || IsInitListCopy) ? cast<InitListExpr>(Args[0]) : nullptr;
   MultiExprArg UnwrappedArgs =
       ILE ? MultiExprArg(ILE->getInits(), ILE->getNumInits()) : Args;
 
   // The type we're constructing needs to be complete.
+  //
+  // "Complete" and "definite" are the same here, since we don't yet support
+  // sizeless structures.
   if (!S.isCompleteType(Kind.getLocation(), DestType)) {
-    Sequence.setIncompleteTypeFailure(DestType);
+    Sequence.setIndefiniteTypeFailure(DestType);
     return;
   }
 
   // C++17 [dcl.init]p17:
   //     - If the initializer expression is a prvalue and the cv-unqualified
   //       version of the source type is the same class as the class of the
   //       destination, the initializer expression is used to initialize the
   //       destination object.
static void TryListInitialization(Sema &S,
   }
   if (DestType->isReferenceType()) {
     TryReferenceListInitialization(S, Entity, Kind, InitList, Sequence,
                                    TreatUnavailableAsInvalid);
     return;
   }
 
   if (DestType->isRecordType() &&
+      // "Complete" and "definite" are the same here, since we don't yet
+      // support sizeless structures.
       !S.isCompleteType(InitList->getLocStart(), DestType)) {
-    Sequence.setIncompleteTypeFailure(DestType);
+    Sequence.setIndefiniteTypeFailure(DestType);
     return;
   }
 
   // C++11 [dcl.init.list]p3, per DR1467:
   // - If T is a class type and the initializer list has a single element of
   //   type cv U, where U is T or a class derived from T, the object is
   //   initialized from that element (by copy-initialization for
   //   copy-list-initialization, or by direct-initialization for
for (NamedDecl *D : S.LookupConstructors(T1RecordDecl)) {
       }
     }
   }
   if (T1RecordType && T1RecordType->getDecl()->isInvalidDecl())
     return OR_No_Viable_Function;
 
   const RecordType *T2RecordType = nullptr;
   if ((T2RecordType = T2->getAs<RecordType>()) &&
-      S.isCompleteType(Kind.getLocation(), T2)) {
+      // "Complete" and "definite" are the same here, since we don't yet
+      // support sizeless structures.
+      S.isDefiniteType(Kind.getLocation(), T2)) {
     // The type we're converting from is a class type, enumerate its conversion
     // functions.
     CXXRecordDecl *T2RecordDecl = cast<CXXRecordDecl>(T2RecordType->getDecl());
 
     const auto &Conversions = T2RecordDecl->getVisibleConversionFunctions();
     for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
       NamedDecl *D = *I;
       CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
if (IsExtraneousCopy) {
     // infinite recursion, where each step adds another extraneous,
     // elidable copy.
 
     // Instantiate the default arguments of any extra parameters in
     // the selected copy constructor, as if we were going to create a
     // proper call to the copy constructor.
     for (unsigned I = 1, N = Constructor->getNumParams(); I != N; ++I) {
       ParmVarDecl *Parm = Constructor->getParamDecl(I);
-      if (S.RequireCompleteType(Loc, Parm->getType(),
+      // C++ [dcl.fct]/9: "the type of a parameter ... shall not be an
+      // incomplete class type".  The sizeless type extension leaves this
+      // wording as-is, so that it doesn't apply to sizeless definite types,
+      // which at present are never class types.
+      if (S.RequireDefiniteType(Loc, Parm->getType(), true,
                                 diag::err_call_incomplete_argument))
         break;
 
       // Build the default argument expression; we don't actually care
       // if this succeeds or not, because this routine will complain
       // if there was a problem.
       S.BuildCXXDefaultArgExpr(Loc, Constructor, Parm);
     }
ExprResult Sema::TemporaryMaterializationConversion(Expr *E) {
   // In C++98, we don't want to implicitly create an xvalue.
   // FIXME: This means that AST consumers need to deal with "prvalues" that
   // denote materialized temporaries. Maybe we should add another ValueKind
   // for "xvalue pretending to be a prvalue" for C++98 support.
   if (!E->isRValue() || !getLangOpts().CPlusPlus11)
     return E;
 
   // C++1z [conv.rval]/1: T shall be a complete type.
+  // The sizeless type extension replaces "complete" with "definite",
+  // so that temporaries with sizeless definite type can be created.
+  //
   // FIXME: Does this ever matter (can we form a prvalue of incomplete type)?
   // If so, we should check for a non-abstract class type here too.
   QualType T = E->getType();
-  if (RequireCompleteType(E->getExprLoc(), T, diag::err_incomplete_type))
+  if (RequireDefiniteType(E->getExprLoc(), T, true, diag::err_incomplete_type))
     return ExprError();
 
   return CreateMaterializeTemporaryExpr(E->getType(), E, false);
 }
 
 ExprResult
 InitializationSequence::Perform(Sema &S,
                                 const InitializedEntity &Entity,
case OR_Ambiguous:
         S.Diag(Kind.getLocation(), diag::err_ref_init_ambiguous)
           << DestType << Args[0]->getType()
           << Args[0]->getSourceRange();
 
       FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, Args);
       break;
 
     case OR_No_Viable_Function:
-      if (!S.RequireCompleteType(Kind.getLocation(),
-                                 DestType.getNonReferenceType(),
+      // The condition is "definiteness" rather than "completeness" because
+      // (incomplete) sizeless definite types are never completed, and so
+      // completeness itself is not the problem.  The usual "not viable"
+      // diagnostics are better in that case.
+      if (!S.RequireDefiniteType(Kind.getLocation(),
+                                 DestType.getNonReferenceType(), true,
                           diag::err_typecheck_nonviable_condition_incomplete,
                                Args[0]->getType(), Args[0]->getSourceRange()))
         S.Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition)
           << (Entity.getKind() == InitializedEntity::EK_Result)
           << Args[0]->getType() << Args[0]->getSourceRange()
           << DestType.getNonReferenceType();
 
       FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, Args);
if (Entity.getKind() == InitializedEntity::EK_Member &&
       S.Diag(Entity.getDecl()->getLocation(), diag::note_previous_decl)
         << Entity.getName();
     } else {
       S.Diag(Kind.getLocation(), diag::err_default_init_const)
           << DestType << (bool)DestType->getAs<RecordType>();
     }
     break;
 
-  case FK_Incomplete:
-    S.RequireCompleteType(Kind.getLocation(), FailedIncompleteType,
-                          diag::err_init_incomplete_type);
+  case FK_Indefinite:
+    S.RequireDefiniteType(Kind.getLocation(), FailedIndefiniteType,
+                          true, diag::err_init_incomplete_type);
     break;
 
   case FK_ListInitializationFailed: {
     // Run the init list checker again to emit diagnostics.
     InitListExpr *InitList = cast<InitListExpr>(Args[0]);
     diagnoseListInit(S, Entity, InitList);
     break;
   }
case FailedSequence: {
     case FK_ConstructorOverloadFailed:
       OS << "constructor overloading failed";
       break;
 
     case FK_DefaultInitOfConst:
       OS << "default initialization of a const variable";
       break;
 
-    case FK_Incomplete:
-      OS << "initialization of incomplete type";
+    case FK_Indefinite:
+      OS << "initialization of indefinite type";
       break;
 
     case FK_ListInitializationFailed:
       OS << "list initialization checker failure";
       break;
 
     case FK_VariableLengthArrayHasInitializer:
       OS << "variable length array has an initializer";

lib/Sema/SemaLambda.cpp

void Sema::buildLambdaScope(LambdaScopeInfo *LSI,
   LSI->ExplicitParams = ExplicitParams;
   LSI->Mutable = Mutable;
 
   if (ExplicitResultType) {
     LSI->ReturnType = CallOperator->getReturnType();
 
     if (!LSI->ReturnType->isDependentType() &&
         !LSI->ReturnType->isVoidType()) {
-      if (RequireCompleteType(CallOperator->getLocStart(), LSI->ReturnType,
-                              diag::err_lambda_incomplete_result)) {
+      // The sizeless type extension allows (incomplete) sizeless
+      // definite types to be returned from functions.
+      if (RequireDefiniteType(CallOperator->getLocStart(), LSI->ReturnType,
+                              true, diag::err_lambda_incomplete_result)) {
         // Do nothing.
       }
     }
   } else {
     LSI->HasImplicitReturnType = true;
   }
 }
 

lib/Sema/SemaOpenMP.cpp

OMPClause *Sema::ActOnOpenMPDeviceClause(Expr *Device, SourceLocation StartLoc,
 
   return new (Context) OMPDeviceClause(ValExpr, HelperValStmt, CaptureRegion,
                                        StartLoc, LParenLoc, EndLoc);
 }
 
 static bool checkTypeMappable(SourceLocation SL, SourceRange SR, Sema &SemaRef,
                               DSAStackTy *Stack, QualType QTy,
                               bool FullCheck = true) {
-  NamedDecl *ND;
-  if (QTy->isIncompleteType(&ND)) {
+  if (QTy->isIncompleteType()) {
     SemaRef.Diag(SL, diag::err_incomplete_type) << QTy << SR;
     return false;
   }
   if (FullCheck && !SemaRef.CurContext->isDependentContext() &&
       !QTy.isTrivialType(SemaRef.Context))
     SemaRef.Diag(SL, diag::warn_omp_non_trivial_type_mapped) << QTy << SR;
   return true;
 }

lib/Sema/SemaOverload.cpp

OverloadCandidateSet CandidateSet(From->getExprLoc(),
                                     OverloadCandidateSet::CSK_Normal);
   OverloadingResult OvResult =
     IsUserDefinedConversion(*this, From, ToType, ICS.UserDefined,
                             CandidateSet, false, false);
   if (OvResult == OR_Ambiguous)
     Diag(From->getLocStart(), diag::err_typecheck_ambiguous_condition)
         << From->getType() << ToType << From->getSourceRange();
   else if (OvResult == OR_No_Viable_Function && !CandidateSet.empty()) {
-    if (!RequireCompleteType(From->getLocStart(), ToType,
+    // Allow user-defined conversions to (incomplete) sizeless definite types.
+    if (!RequireDefiniteType(From->getLocStart(), ToType, true,
                              diag::err_typecheck_nonviable_condition_incomplete,
                              From->getType(), From->getSourceRange()))
       Diag(From->getLocStart(), diag::err_typecheck_nonviable_condition)
           << false << From->getType() << From->getSourceRange() << ToType;
   } else
     return false;
   CandidateSet.NoteCandidates(*this, OCD_AllCandidates, From);
   return true;
TryListConversion(Sema &S, InitListExpr *From, QualType ToType,
                   bool AllowObjCWritebackConversion) {
   // C++11 [over.ics.list]p1:
   //   When an argument is an initializer list, it is not an expression and
   //   special rules apply for converting it to a parameter type.
 
   ImplicitConversionSequence Result;
   Result.setBad(BadConversionSequence::no_conversion, From, ToType);
 
-  // We need a complete type for what follows. Incomplete types can never be
+  // We need a definite type for what follows. Indefinite types can never be
   // initialized from init lists.
-  if (!S.isCompleteType(From->getLocStart(), ToType))
+  //
+  // The condition is "definiteness" rather than "completeness" because the
+  // sizeless type extension allows list construction of (incomplete) sized
+  // definite types.
+  if (!S.isDefiniteType(From->getLocStart(), ToType))
     return Result;
 
   // Per DR1467:
   //   If the parameter type is a class X and the initializer list has a single
   //   element of type cv U, where U is X or a class derived from X, the
   //   implicit conversion sequence is the one required to convert the element
   //   to the parameter type.
   //
Sema::AddConversionCandidate(CXXConversionDecl *Conversion,
   DeclRefExpr ConversionRef(Conversion, false, Conversion->getType(),
                             VK_LValue, From->getLocStart());
   ImplicitCastExpr ConversionFn(ImplicitCastExpr::OnStack,
                                 Context.getPointerType(Conversion->getType()),
                                 CK_FunctionToPointerDecay,
                                 &ConversionRef, VK_RValue);
 
   QualType ConversionType = Conversion->getConversionType();
-  if (!isCompleteType(From->getLocStart(), ConversionType)) {
+  // The condition is "definiteness" rather than "completeness" because the
+  // sizeless type extension allows user-defined conversions to (incomplete)
+  // sized definite types.
+  if (!isDefiniteType(From->getLocStart(), ConversionType)) {
     Candidate.Viable = false;
     Candidate.FailureKind = ovl_fail_bad_final_conversion;
     return;
   }
 
   ExprValueKind VK = Expr::getValueKindForType(ConversionType);
 
   // Note that it is safe to allocate CallExpr on the stack here because
if (FromExpr && isa<InitListExpr>(FromExpr)) {
     S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_list_argument)
       << (unsigned) FnKind << FnDesc
       << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
       << FromTy << ToTy << (unsigned) isObjectArgument << I+1;
     MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
     return;
   }
 
-  // Diagnose references or pointers to incomplete types differently,
-  // since it's far from impossible that the incompleteness triggered
+  // Diagnose references or pointers to indefinite types differently,
+  // since it's far from impossible that the indefiniteness triggered
   // the failure.
+  //
+  // The condition is "indefinite" rather than "incomplete" because
+  // (incomplete) sized definite types are never completed.  The diagnostics
+  // below are a better fit for them.
   QualType TempFromTy = FromTy.getNonReferenceType();
   if (const PointerType *PTy = TempFromTy->getAs<PointerType>())
     TempFromTy = PTy->getPointeeType();
-  if (TempFromTy->isIncompleteType()) {
+  if (TempFromTy->isIndefiniteType()) {
     // Emit the generic diagnostic and, optionally, add the hints to it.
     S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_conv_incomplete)
       << (unsigned) FnKind << FnDesc
       << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
       << FromTy << ToTy << (unsigned) isObjectArgument << I+1
       << (unsigned) (Cand->Fix.Kind);
 
     MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);

lib/Sema/SemaPseudoObject.cpp

void setResultToLastSemantic() {
         OVE->setIsUnique(false);
     }
 
     /// Return true if assignments have a non-void result.
     static bool CanCaptureValue(Expr *exp) {
       if (exp->isGLValue())
         return true;
       QualType ty = exp->getType();
-      assert(!ty->isIncompleteType());
+      assert(ty->isDefiniteType());
       assert(!ty->isDependentType());
 
       if (const CXXRecordDecl *ClassDecl = ty->getAsCXXRecordDecl())
         return ClassDecl->isTriviallyCopyable();
       return true;
     }
 
     virtual Expr *rebuildAndCaptureObject(Expr *) = 0;

lib/Sema/SemaStmt.cpp

static void DiagnoseForRangeVariableCopies(Sema &SemaRef,
   }
 
   const VarDecl *VD = ForStmt->getLoopVariable();
   if (!VD)
     return;
 
   QualType VariableType = VD->getType();
 
-  if (VariableType->isIncompleteType())
+  // "Indefinite" rather than "incomplete" since ranges can yield (incomplete)
+  // sizeless definite types.
+  if (VariableType->isIndefiniteType())
     return;
 
   const Expr *InitExpr = VD->getInit();
   if (!InitExpr)
     return;
 
   if (VariableType->isReferenceType()) {
     DiagnoseForRangeReferenceVariableCopies(SemaRef, VD,

lib/Sema/SemaStmtAsm.cpp

case Expr::MLV_LValueCast: {
             << OutputExpr->getSourceRange();
       } else {
         Diag(LVal->getLocStart(), diag::warn_invalid_asm_cast_lvalue)
             << OutputExpr->getSourceRange();
       }
       // Accept, even if we emitted an error diagnostic.
       break;
     }
-    case Expr::MLV_IncompleteType:
+    case Expr::MLV_IndefiniteType:
     case Expr::MLV_IncompleteVoidType:
-      if (RequireCompleteType(OutputExpr->getLocStart(), Exprs[i]->getType(),
-                              diag::err_dereference_incomplete_type))
+      if (RequireDefiniteType(OutputExpr->getLocStart(), Exprs[i]->getType(),
+                              true, diag::err_dereference_incomplete_type))
         return StmtError();
       LLVM_FALLTHROUGH;
     default:
       return StmtError(Diag(OutputExpr->getLocStart(),
                             diag::err_asm_invalid_lvalue_in_output)
                        << OutputExpr->getSourceRange());
     }
 
+    // FIXME: should have a mechanism for sizeless types too.
+    if (OutputExpr->getType()->isSizelessType())
+      continue;
+
     unsigned Size = Context.getTypeSize(OutputExpr->getType());
     if (!Context.getTargetInfo().validateOutputSize(Literal->getString(),
                                                     Size))
       return StmtError(Diag(OutputExpr->getLocStart(),
                             diag::err_asm_invalid_output_size)
                        << Info.getConstraintStr());
   }
 
for (unsigned i = NumOutputs, e = NumOutputs + NumInputs; i != e; i++) {
 
     InputConstraintInfos.push_back(Info);
 
     const Type *Ty = Exprs[i]->getType().getTypePtr();
     if (Ty->isDependentType())
       continue;
 
     if (!Ty->isVoidType() || !Info.allowsMemory())
-      if (RequireCompleteType(InputExpr->getLocStart(), Exprs[i]->getType(),
-                              diag::err_dereference_incomplete_type))
+      // The test is for definiteness rather than completeness because
+      // the sizeless type extension allows sizeless types to be bound
+      // to register operands.
+      if (RequireDefiniteType(InputExpr->getLocStart(), Exprs[i]->getType(),
+                              true, diag::err_dereference_incomplete_type))
         return StmtError();
 
+    // FIXME: should have a mechanism for sizeless types too.
+    if (Ty->isSizelessType())
+      continue;
+
     unsigned Size = Context.getTypeSize(Ty);
     if (!Context.getTargetInfo().validateInputSize(Literal->getString(),
                                                    Size))
       return StmtError(Diag(InputExpr->getLocStart(),
                             diag::err_asm_invalid_input_size)
                        << Info.getConstraintStr());
   }
 
if (ConstraintIdx >= NumOperands) {
 
       assert(I != E && "Invalid operand number should have been caught in "
                        " AnalyzeAsmString");
     }
 
     // Now that we have the right indexes go ahead and check.
     StringLiteral *Literal = Constraints[ConstraintIdx];
     const Type *Ty = Exprs[ConstraintIdx]->getType().getTypePtr();
+    // FIXME: should have a mechanism for sizeless types too.
     if (Ty->isDependentType() || Ty->isIncompleteType())
       continue;
 
     unsigned Size = Context.getTypeSize(Ty);
     std::string SuggestedModifier;
     if (!Context.getTargetInfo().validateConstraintModifier(
             Literal->getString(), Piece.getModifier(), Size,
             SuggestedModifier)) {
for (unsigned i = 0, e = InputConstraintInfos.size(); i != e; ++i) {
     if (OutputExpr->isTypeDependent() || InputExpr->isTypeDependent())
       continue;
 
     QualType InTy = InputExpr->getType();
     QualType OutTy = OutputExpr->getType();
     if (Context.hasSameType(InTy, OutTy))
       continue;  // All types can be tied to themselves.
 
+    // FIXME: should have a mechanism for sizeless types too.
+    if (InTy->isSizelessType() || OutTy->isSizelessType())
+      continue;
+
     // Decide if the input and output are in the same domain (integer/ptr or
     // floating point.
     enum AsmDomain {
       AD_Int, AD_FP, AD_Other
     } InputDomain, OutputDomain;
 
     if (InTy->isIntegerType() || InTy->isPointerType())
       InputDomain = AD_Int;
ExprResult Sema::LookupInlineAsmIdentifier(CXXScopeSpec &SS,
   }
 
   // Any sort of function type is fine.
   if (T->isFunctionType()) {
     return Result;
   }
 
   // Otherwise, it needs to be a complete type.
+  // FIXME: should have a mechanism for sizeless types too.
   if (RequireCompleteExprType(Result.get(), diag::err_asm_incomplete_type)) {
     return ExprError();
   }
 
   return Result;
 }
 
 bool Sema::LookupInlineAsmField(StringRef Base, StringRef Member,

lib/Sema/SemaType.cpp

 ///
 /// \returns A suitable array type, if there are no errors. Otherwise,
 /// returns a NULL type.
 QualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
                               Expr *ArraySize, unsigned Quals,
                               SourceRange Brackets, DeclarationName Entity) {
 
   SourceLocation Loc = Brackets.getBegin();
+
+  if (T->isSizelessType()) {
+    Diag(Loc, diag::err_array_of_sizeless) << T;
+    return QualType();
+  }
+
   if (getLangOpts().CPlusPlus) {
     // C++ [dcl.array]p1:
     //   T is called the array element type; this type shall not be a reference
     //   type, the (possibly cv-qualified) type void, a function type or an
     //   abstract class type.
     //
     // C++ [dcl.array]p3:
     //   When several "array of" specifications are adjacent, [...] only the
bool Sema::RequireCompleteExprType(Expr *E, TypeDiagnoser &Diagnoser) {
   return RequireCompleteType(E->getExprLoc(), T, Diagnoser);
 }
 
 bool Sema::RequireCompleteExprType(Expr *E, unsigned DiagID) {
   BoundTypeDiagnoser<> Diagnoser(DiagID);
   return RequireCompleteExprType(E, Diagnoser);
 }
 
-/// @brief Ensure that the type T is a complete type.
+/// @brief Ensure that the type T is a definite type.
 ///
-/// This routine checks whether the type @p T is complete in any
-/// context where a complete type is required. If @p T is a complete
-/// type, returns false. If @p T is a class template specialization,
-/// this routine then attempts to perform class template
-/// instantiation. If instantiation fails, or if @p T is incomplete
-/// and cannot be completed, issues the diagnostic @p diag (giving it
-/// the type @p T) and returns true.
+/// This routine checks whether the type @p T is definite in any
+/// context where a definite type is required.  @p AllowSizeless
+/// says whether sizeless types are allowed; it is false if
+/// completed (i.e. definite and sized) types are required.
+/// If @p T meets these conditions, returns false. If @p T is a class
+/// template specialization, this routine then attempts to perform class
+/// template instantiation. If instantiation fails, or if @p T is
+/// indefinite and cannot be made definite, issues the diagnostic @p diag
+/// (giving it the type @p T) and returns true.
 ///
 /// @param Loc  The location in the source that the incomplete type
 /// diagnostic should refer to.
 ///
 /// @param T  The type that this routine is examining for completeness.
 ///
+/// @param AllowSizeless  Whether to allow sizeless types.
+///
 /// @returns @c true if @p T is incomplete and a diagnostic was emitted,
 /// @c false otherwise.
-bool Sema::RequireCompleteType(SourceLocation Loc, QualType T,
-                               TypeDiagnoser &Diagnoser) {
-  if (RequireCompleteTypeImpl(Loc, T, &Diagnoser))
+bool Sema::RequireDefiniteType(SourceLocation Loc, QualType T,
+                               bool AllowSizeless, TypeDiagnoser &Diagnoser) {
+  if (RequireDefiniteTypeImpl(Loc, T, AllowSizeless, &Diagnoser))
     return true;
   if (const TagType *Tag = T->getAs<TagType>()) {
     if (!Tag->getDecl()->isCompleteDefinitionRequired()) {
       Tag->getDecl()->setCompleteDefinitionRequired();
       Consumer.HandleTagDeclRequiredDefinition(Tag->getDecl());
     }
   }
   return false;
RD->addAttr(MSInheritanceAttr::CreateImplicit(
             LangOptions::PPTMK_BestCase,
         S.ImplicitMSInheritanceAttrLoc.isValid()
             ? S.ImplicitMSInheritanceAttrLoc
             : RD->getSourceRange()));
     S.Consumer.AssignInheritanceModel(RD);
   }
 }
 
-/// \brief The implementation of RequireCompleteType
-bool Sema::RequireCompleteTypeImpl(SourceLocation Loc, QualType T,
+/// \brief The implementation of RequireDefiniteType
+bool Sema::RequireDefiniteTypeImpl(SourceLocation Loc, QualType T,
+                                   bool AllowSizeless,
                                    TypeDiagnoser *Diagnoser) {
   // FIXME: Add this assertion to make sure we always get instantiation points.
-  //  assert(!Loc.isInvalid() && "Invalid location in RequireCompleteType");
+  //  assert(!Loc.isInvalid() && "Invalid location in RequireDefiniteType");
   // FIXME: Add this assertion to help us flush out problems with
   // checking for dependent types and type-dependent expressions.
   //
   //  assert(!T->isDependentType() &&
   //         "Can't ask whether a dependent type is complete");
 
   // We lock in the inheritance model once somebody has asked us to ensure
   // that a pointer-to-member type is complete.
   if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
     if (const MemberPointerType *MPTy = T->getAs<MemberPointerType>()) {
       if (!MPTy->getClass()->isDependentType()) {
         (void)isCompleteType(Loc, QualType(MPTy->getClass(), 0));
         assignInheritanceModel(*this, MPTy->getMostRecentCXXRecordDecl());
       }
     }
   }
 
   NamedDecl *Def = nullptr;
-  bool Incomplete = T->isIncompleteType(&Def);
+  bool Indefinite = T->isIndefiniteType(&Def);
 
   // Check that any necessary explicit specializations are visible. For an
   // enum, we just need the declaration, so don't check this.
   if (Def && !isa<EnumDecl>(Def))
     checkSpecializationVisibility(Loc, Def);
 
   // If we have a complete type, we're done.
-  if (!Incomplete) {
+  if (!Indefinite &&
+      (AllowSizeless || !T->isSizelessType())) {
     // If we know about the definition but it is not visible, complain.
     NamedDecl *SuggestedDef = nullptr;
     if (Def &&
         !hasVisibleDefinition(Def, &SuggestedDef, /*OnlyNeedComplete*/true)) {
       // If the user is going to see an error here, recover by making the
       // definition visible.
       bool TreatAsComplete = Diagnoser && !isSFINAEContext();
       if (Diagnoser)
if (auto *Source = Context.getExternalSource()) {
           Source->CompleteType(TagD);
       } else {
         ObjCInterfaceDecl *IFaceD = IFace->getDecl();
         if (IFaceD->hasExternalLexicalStorage())
           Source->CompleteType(IFace->getDecl());
       }
       // If the external source completed the type, go through the motions
       // again to ensure we're allowed to use the completed type.
-      if (!T->isIncompleteType())
-        return RequireCompleteTypeImpl(Loc, T, Diagnoser);
+      if (T->isDefiniteType(&Def) &&
+          (AllowSizeless || !T->isSizelessType()))
+        return RequireDefiniteTypeImpl(Loc, T, AllowSizeless, Diagnoser);
     }
   }
 
   // If we have a class template specialization or a class member of a
   // class template specialization, or an array with known size of such,
   // try to instantiate it.
   QualType MaybeTemplate = T;
   while (const ConstantArrayType *Array
if (const RecordType *Record = MaybeTemplate->getAs<RecordType>()) {
     if (Instantiated) {
       // Instantiate* might have already complained that the template is not
       // defined, if we asked it to.
       if (Diagnoser && Diagnosed)
         return true;
       // If we instantiated a definition, check that it's usable, even if
       // instantiation produced an error, so that repeated calls to this
       // function give consistent answers.
-      if (!T->isIncompleteType())
-        return RequireCompleteTypeImpl(Loc, T, Diagnoser);
+      if (T->isDefiniteType(&Def) &&
+          (AllowSizeless || !T->isSizelessType()))
+        return RequireDefiniteTypeImpl(Loc, T, AllowSizeless, Diagnoser);
     }
   }
 
   // FIXME: If we didn't instantiate a definition because of an explicit
   // specialization declaration, check that it's visible.
 
   if (!Diagnoser)
     return true;
bool Sema::RequireDefiniteTypeImpl(SourceLocation Loc, QualType T,
   // If we have external information that we can use to suggest a fix,
   // produce a note.
   if (ExternalSource)
     ExternalSource->MaybeDiagnoseMissingCompleteType(Loc, T);
 
   return true;
 }
 
-bool Sema::RequireCompleteType(SourceLocation Loc, QualType T,
-                               unsigned DiagID) {
+bool Sema::RequireDefiniteType(SourceLocation Loc, QualType T,
+                               bool AllowSizeless, unsigned DiagID) {
   BoundTypeDiagnoser<> Diagnoser(DiagID);
-  return RequireCompleteType(Loc, T, Diagnoser);
+  return RequireDefiniteType(Loc, T, AllowSizeless, Diagnoser);
 }
 
 /// \brief Get diagnostic %select index for tag kind for
 /// literal type diagnostic message.
 /// WARNING: Indexes apply to particular diagnostics only!
 ///
 /// \returns diagnostic %select index.
 static unsigned getLiteralDiagFromTagKind(TagTypeKind Tag) {
if (!BaseType->isDependentType() && !BaseType->isEnumeralType()) {
       Diag(Loc, diag::err_only_enums_have_underlying_types);
       return QualType();
     } else {
       QualType Underlying = BaseType;
       if (!BaseType->isDependentType()) {
         // The enum could be incomplete if we're parsing its definition or
         // recovering from an error.
         NamedDecl *FwdDecl = nullptr;
-        if (BaseType->isIncompleteType(&FwdDecl)) {
+        // "Complete" and "definite" are the same here, since enums are
+        // never sizeless.
+        if (BaseType->isIndefiniteType(&FwdDecl)) {
           Diag(Loc, diag::err_underlying_type_of_incomplete_enum) << BaseType;
           Diag(FwdDecl->getLocation(), diag::note_forward_declaration) << FwdDecl;
           return QualType();
         }
 
         EnumDecl *ED = BaseType->getAs<EnumType>()->getDecl();
         assert(ED && "EnumType has no EnumDecl");
 

test/Sema/sizeless-1.c

+// RUN: %clang_cc1 -fsyntax-only -verify -Wall -W -Wno-comment -triple arm64-linux-gnu -target-feature +sve -std=c90 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -Wall -W -triple arm64-linux-gnu -target-feature +sve -std=gnu90 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -Wall -W -triple arm64-linux-gnu -target-feature +sve -std=c99 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -Wall -W -triple arm64-linux-gnu -target-feature +sve -std=gnu99 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -Wall -W -triple arm64-linux-gnu -target-feature +sve -std=c11 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -Wall -W -triple arm64-linux-gnu -target-feature +sve -std=gnu11 %s
+
+typedef __SVInt8_t svint8_t;
+typedef __SVInt16_t svint16_t;
+
+svint8_t global_int8; // expected-error {{non-local variable with sizeless type}}
+extern svint8_t extern_int8; // expected-error {{non-local variable with sizeless type}}
+static svint8_t static_int8; // expected-error {{non-local variable with sizeless type}}
+
+typedef svint8_t int8_typedef;
+typedef svint8_t *int8_ptr_typedef;
+
+int sizeof_int8 = sizeof(svint8_t); // expected-error {{incomplete type}}
+
+int alignof_int8 = _Alignof(svint8_t); // expected-error {{incomplete type}}
+
+void pass_int8(svint8_t); // expected-note {{passing argument to parameter here}}
+
+svint8_t return_int8();
+
+typedef svint8_t vec_int8 __attribute__((vector_size(64))); // expected-error {{invalid vector element type}}
+
+void dump(const volatile void *);
+
+void __attribute__((overloadable)) overf(svint8_t);
+void __attribute__((overloadable)) overf(svint16_t);
+
+void __attribute__((overloadable)) overf8(svint8_t); // expected-note + {{not viable}}
+void __attribute__((overloadable)) overf8(int); // expected-note + {{not viable}}
+
+void __attribute__((overloadable)) overf16(svint16_t); // expected-note + {{not viable}}
+void __attribute__((overloadable)) overf16(int); // expected-note + {{not viable}}
+
+void varargs(int, ...);
+
+void unused() {
+  svint8_t unused_int8; // expected-warning {{unused}}
+}
+
+void func(int sel) {
+  svint8_t local_int8;
+  svint16_t local_int16;
+
+  svint8_t __attribute__((aligned)) aligned_int8_1; // expected-error {{sizeless type}}
+  svint8_t __attribute__((aligned(4))) aligned_int8_2; // expected-error {{sizeless type}}
+  svint8_t _Alignas(int) aligned_int8_3; // expected-error {{sizeless type}}
+  int _Alignas(svint8_t) aligned_int; // expected-error {{incomplete type}}
+
+  local_int8; // expected-warning {{expression result unused}}
+
+  (void)local_int8;
+
+  local_int8, 0; // expected-warning + {{expression result unused}}
+
+  0, local_int8; // expected-warning + {{expression result unused}}
+
+  svint8_t init_int8 = local_int8;
+
+  int empty_brace_init_int = {}; // expected-error {{scalar initializer cannot be empty}}
+  svint8_t empty_brace_init_int8 = {}; // expected-error {{scalar initializer cannot be empty}}
+  svint8_t brace_init_int8 = { local_int8 };
+  svint8_t bad_brace_init_int8 = { local_int8, 0 }; // expected-warning {{excess elements in scalar initializer}}
+
+  const svint8_t const_int8 = local_int8; // expected-note {{declared const here}}
+
+  const svint8_t uninit_const_int8;
+
+  volatile svint8_t volatile_int8;
+
+  const volatile svint8_t const_volatile_int8; // expected-note {{declared const here}}
+
+  _Atomic svint8_t atomic_int8; // expected-error {{_Atomic cannot be applied to incomplete type}}
+  __restrict svint8_t restrict_int8; // expected-error {{requires a pointer or reference}}
+
+  svint8_t array_int8[1]; // expected-error {{array has sizeless element type}}
+
+  _Bool test_int8 = init_int8; // expected-error {{incompatible type}}
+
+  int int_int8 = init_int8; // expected-error {{incompatible type}}
+
+  init_int8 = local_int8;
+  init_int8 = local_int16; // expected-error {{incompatible type}}
+  init_int8 = sel; // expected-error {{incompatible type}}
+
+  sel = local_int8; // expected-error {{incompatible type}}
+
+  local_int8 = (svint8_t)local_int8; // expected-error {{cast to incomplete type}}
+  local_int8 = (const svint8_t)local_int8; // expected-error {{cast to incomplete type}}
+  local_int8 = (svint8_t)local_int8; // expected-error {{cast to incomplete type}}
+
+  init_int8 = local_int8;
+  init_int8 = const_int8;
+  init_int8 = volatile_int8;
+  init_int8 = const_volatile_int8;
+
+  const_int8 = local_int8; // expected-error {{const-qualified type}}
+
+  volatile_int8 = local_int8;
+  volatile_int8 = const_int8;
+  volatile_int8 = volatile_int8;
+  volatile_int8 = const_volatile_int8;
+
+  const_volatile_int8 = local_int8; // expected-error {{const-qualified type}}
+
+  init_int8 = sel ? init_int8 : local_int8;
+  init_int8 = sel ? init_int8 : const_int8;
+  init_int8 = sel ? volatile_int8 : const_int8;
+  init_int8 = sel ? volatile_int8 : const_volatile_int8;
+
+  pass_int8(local_int8);
+  pass_int8(local_int16); // expected-error {{incompatible type}}
+
+  local_int8 = return_int8();
+  local_int16 = return_int8(); // expected-error {{incompatible type}}
+
+  dump(&local_int8);
+  dump(&const_int8);
+  dump(&volatile_int8);
+  dump(&const_volatile_int8);
+
+  dump(&local_int8 + 1); // expected-error {{arithmetic on a pointer to an incomplete type}}
+
+  *&local_int8 = local_int8;
+  *&const_int8 = local_int8; // expected-error {{read-only variable}}
+  *&volatile_int8 = local_int8;
+  *&const_volatile_int8 = local_int8; // expected-error {{read-only variable}}
+
+  overf(local_int8);
+  overf(local_int16);
+
+  overf8(local_int8);
+  overf8(local_int16); // expected-error {{no matching function}}
+
+  overf16(local_int8); // expected-error {{no matching function}}
+  overf16(local_int16);
+
+  varargs(1, local_int8, local_int16);
+
+  +init_int8; // expected-error {{invalid argument type}}
+  ++init_int8; // expected-error {{cannot increment}}
+  -init_int8; // expected-error {{invalid argument type}}
+  --init_int8; // expected-error {{cannot decrement}}
+  ~init_int8; // expected-error {{invalid argument type}}
+  !init_int8; // expected-error {{invalid argument type}}
+  *init_int8; // expected-error {{requires pointer operand}}
+  __real init_int8; // expected-error {{invalid type}}
+  __imag init_int8; // expected-error {{invalid type}}
+
+  local_int8 + init_int8; // expected-error {{invalid operands}}
+  local_int8 - init_int8; // expected-error {{invalid operands}}
+  local_int8 * init_int8; // expected-error {{invalid operands}}
+  local_int8 / init_int8; // expected-error {{invalid operands}}
+  local_int8 % init_int8; // expected-error {{invalid operands}}
+  local_int8 & init_int8; // expected-error {{invalid operands}}
+  local_int8 | init_int8; // expected-error {{invalid operands}}
+  local_int8 ^ init_int8; // expected-error {{invalid operands}}
+  local_int8 << init_int8; // expected-error {{invalid operands}}
+  local_int8 >> init_int8; // expected-error {{invalid operands}}
+  local_int8 < init_int8; // expected-error {{invalid operands}}
+  local_int8 <= init_int8; // expected-error {{invalid operands}}
+  local_int8 == init_int8; // expected-error {{invalid operands}}
+  local_int8 != init_int8; // expected-error {{invalid operands}}
+  local_int8 >= init_int8; // expected-error {{invalid operands}}
+  local_int8 > init_int8; // expected-error {{invalid operands}}
+  local_int8 && init_int8; // expected-error {{invalid operands}}
+  local_int8 || init_int8; // expected-error {{invalid operands}}
+
+  local_int8 += init_int8; // expected-error {{invalid operands}}
+  local_int8 -= init_int8; // expected-error {{invalid operands}}
+  local_int8 *= init_int8; // expected-error {{invalid operands}}
+  local_int8 /= init_int8; // expected-error {{invalid operands}}
+  local_int8 %= init_int8; // expected-error {{invalid operands}}
+  local_int8 &= init_int8; // expected-error {{invalid operands}}
+  local_int8 |= init_int8; // expected-error {{invalid operands}}
+  local_int8 ^= init_int8; // expected-error {{invalid operands}}
+  local_int8 <<= init_int8; // expected-error {{invalid operands}}
+  local_int8 >>= init_int8; // expected-error {{invalid operands}}
+
+  local_int8 + 0; // expected-error {{invalid operands}}
+  local_int8 - 0; // expected-error {{invalid operands}}
+  local_int8 * 0; // expected-error {{invalid operands}}
+  local_int8 / 0; // expected-error {{invalid operands}}
+  local_int8 % 0; // expected-error {{invalid operands}}
+  local_int8 & 0; // expected-error {{invalid operands}}
+  local_int8 | 0; // expected-error {{invalid operands}}
+  local_int8 ^ 0; // expected-error {{invalid operands}}
+  local_int8 << 0; // expected-error {{invalid operands}}
+  local_int8 >> 0; // expected-error {{invalid operands}}
+  local_int8 < 0; // expected-error {{invalid operands}}
+  local_int8 <= 0; // expected-error {{invalid operands}}
+  local_int8 == 0; // expected-error {{invalid operands}}
+  local_int8 != 0; // expected-error {{invalid operands}}
+  local_int8 >= 0; // expected-error {{invalid operands}}
+  local_int8 > 0; // expected-error {{invalid operands}}
+  local_int8 && 0; // expected-error {{invalid operands}}
+  local_int8 || 0; // expected-error {{invalid operands}}
+
+  if (local_int8) {} // expected-error {{statement requires expression of scalar type}}
+  while (local_int8) {} // expected-error {{statement requires expression of scalar type}}
+  do {} while (local_int8); // expected-error {{statement requires expression of scalar type}}
+  switch (local_int8) { default:; } // expected-error {{integer type}}
+}
+
+int vararg_receiver(int count, svint8_t first, ...) {
+  __builtin_va_list va;
+
+  __builtin_va_start(va, first);
+  __builtin_va_arg(va, svint8_t);
+  __builtin_va_end(va);
+  return count;
+}
+
+struct sized_struct {
+  int f1;
+  svint8_t f2; // expected-error {{field has incomplete type}}
+  svint8_t f3 : 2; // expected-error {{incomplete type}}
+};
+
+union sized_union {
+  int f1;
+  svint8_t f2; // expected-error {{field has incomplete type}}
+  svint8_t f3 : 2; // expected-error {{incomplete type}}
+};
+
+#if __STDC_VERSION__ >= 201112L
+void test_generic(void) {
+  svint8_t local_int8;
+  svint16_t local_int16;
+
+  int a1[_Generic (local_int8, svint8_t: 1, svint16_t: 2, default: 3) == 1 ? 1 : -1];
+  int a2[_Generic (local_int16, svint8_t: 1, svint16_t: 2, default: 3) == 2 ? 1 : -1];
+  int a3[_Generic (0, svint8_t: 1, svint16_t: 2, default: 3) == 3 ? 1 : -1];
+  (void)_Generic (0, svint8_t: 1, svint8_t: 2, default: 3); // expected-error {{compatible with previously specified}} expected-note {{compatible type}}
+}
+
+void test_compound_literal(void) {
+  svint8_t local_int8;
+
+  (void) (svint8_t) { local_int8 };
+}
+#endif

test/SemaCXX/sizeless-1.cpp

+// RUN: %clang_cc1 -fcxx-exceptions -fsyntax-only -verify -W -Wall -Wrange-loop-analysis -triple arm64-linux-gnu -target-feature +sve -std=c++98 %s
+// RUN: %clang_cc1 -fcxx-exceptions -fsyntax-only -verify -W -Wall -Wrange-loop-analysis -triple arm64-linux-gnu -target-feature +sve -std=gnu++98 %s
+// RUN: %clang_cc1 -fcxx-exceptions -fsyntax-only -verify -W -Wall -Wrange-loop-analysis -triple arm64-linux-gnu -target-feature +sve -std=c++11 %s
+// RUN: %clang_cc1 -fcxx-exceptions -fsyntax-only -verify -W -Wall -Wrange-loop-analysis -triple arm64-linux-gnu -target-feature +sve -std=gnu++11 %s
+// RUN: %clang_cc1 -fcxx-exceptions -fsyntax-only -verify -W -Wall -Wrange-loop-analysis -triple arm64-linux-gnu -target-feature +sve -std=c++14 %s
+// RUN: %clang_cc1 -fcxx-exceptions -fsyntax-only -verify -W -Wall -Wrange-loop-analysis -triple arm64-linux-gnu -target-feature +sve -std=gnu++14 %s
+// RUN: %clang_cc1 -fcxx-exceptions -fsyntax-only -verify -W -Wall -Wrange-loop-analysis -triple arm64-linux-gnu -target-feature +sve -std=c++17 %s
+// RUN: %clang_cc1 -fcxx-exceptions -fsyntax-only -verify -W -Wall -Wrange-loop-analysis -triple arm64-linux-gnu -target-feature +sve -std=gnu++17 %s
+
+typedef __SVInt8_t svint8_t;
+typedef __SVInt16_t svint16_t;
+
+svint8_t global_int8; // expected-error {{non-local variable with sizeless type}}
+extern svint8_t extern_int8; // expected-error {{non-local variable with sizeless type}}
+static svint8_t static_int8; // expected-error {{non-local variable with sizeless type}}
+
+typedef svint8_t int8_typedef;
+typedef svint8_t *int8_ptr_typedef;
+
+int sizeof_int8 = sizeof(svint8_t); // expected-error {{incomplete type}}
+
+int alignof_int8 = _Alignof(svint8_t); // expected-error {{incomplete type}}
+
+void pass_int8(svint8_t); // expected-note {{no known conversion}}
+
+extern "C" svint8_t return_int8();
+
+typedef svint8_t vec_int8 __attribute__((vector_size(64))); // expected-error {{invalid vector element type}}
+
+void dump(const volatile void *);
+
+void overf(svint8_t);
+void overf(svint16_t);
+
+void overf8(svint8_t); // expected-note + {{not viable}}
+void overf8(int); // expected-note + {{not viable}}
+
+void overf16(svint16_t); // expected-note + {{not viable}}
+void overf16(int); // expected-note + {{not viable}}
+
+void varargs(int, ...);
+
+void unused() {
+  svint8_t unused_int8; // expected-warning {{unused}}
+}
+
+void func(int sel) {
+  svint8_t local_int8;
+  svint16_t local_int16;
+
+  svint8_t __attribute__((aligned)) aligned_int8_1; // expected-error {{sizeless type}}
+  svint8_t __attribute__((aligned(4))) aligned_int8_2; // expected-error {{sizeless type}}
+  svint8_t _Alignas(int) aligned_int8_3; // expected-error {{sizeless type}}
+  int _Alignas(svint8_t) aligned_int; // expected-error {{incomplete type}}
+
+  (void)__atomic_is_lock_free(1, &local_int8);
+  (void)__atomic_always_lock_free(1, &local_int8);
+
+  local_int8; // expected-warning {{expression result unused}}
+
+  (void)local_int8;
+
+  local_int8, 0; // expected-warning + {{expression result unused}}
+
+  0, local_int8; // expected-warning + {{expression result unused}}
+
+  svint8_t init_int8 = local_int8;
+
+#if __cplusplus >= 201103L
+  int empty_brace_init_int = {};
+  svint8_t empty_brace_init_int8 = {};
+#else
+  int empty_brace_init_int = {}; // expected-error {{scalar initializer cannot be empty}}
+  svint8_t empty_brace_init_int8 = {}; // expected-error {{scalar initializer cannot be empty}}
+#endif
+  svint8_t brace_init_int8 = { local_int8 };
+  svint8_t bad_brace_init_int8 = { local_int8, 0 }; // expected-error {{excess elements in scalar initializer}}
+
+  const svint8_t const_int8 = local_int8; // expected-note {{declared const here}}
+
+  const svint8_t uninit_const_int8; // expected-error {{default initialization}}
+
+  volatile svint8_t volatile_int8;
+
+  const volatile svint8_t const_volatile_int8; // expected-error {{default initialization}} expected-note {{declared const here}}
+
+  _Atomic svint8_t atomic_int8; // expected-error {{_Atomic cannot be applied to incomplete type}}
+  __restrict svint8_t restrict_int8; // expected-error {{requires a pointer or reference}}
+
+  svint8_t array_int8[1]; // expected-error {{array has sizeless element type}}
+
+  bool test_int8 = init_int8; // expected-error {{cannot initialize}}
+
+  int int_int8 = init_int8; // expected-error {{cannot initialize}}
+
+  init_int8 = local_int8;
+  init_int8 = local_int16; // expected-error {{incompatible type}}
+  init_int8 = sel; // expected-error {{incompatible type}}
+
+  sel = local_int8; // expected-error {{incompatible type}}
+
+  local_int8 = (svint8_t)local_int8;
+  local_int8 = (const svint8_t)local_int8;
+  local_int8 = (svint8_t)local_int16; // expected-error {{not allowed}}
+
+  init_int8 = local_int8;
+  init_int8 = const_int8;
+  init_int8 = volatile_int8;
+  init_int8 = const_volatile_int8;
+
+  const_int8 = local_int8; // expected-error {{const-qualified type}}
+
+  volatile_int8 = local_int8;
+  volatile_int8 = const_int8;
+  volatile_int8 = volatile_int8;
+  volatile_int8 = const_volatile_int8;
+
+  const_volatile_int8 = local_int8; // expected-error {{const-qualified type}}
+
+  init_int8 = sel ? init_int8 : local_int8;
+  init_int8 = sel ? init_int8 : const_int8;
+  init_int8 = sel ? volatile_int8 : const_int8;
+  init_int8 = sel ? volatile_int8 : const_volatile_int8;
+
+  pass_int8(local_int8);
+  pass_int8(local_int16); // expected-error {{no matching function}}
+
+  local_int8 = return_int8();
+  local_int16 = return_int8(); // expected-error {{incompatible type}}
+
+  dump(&local_int8);
+  dump(&const_int8);
+  dump(&volatile_int8);
+  dump(&const_volatile_int8);
+
+  dump(&local_int8 + 1); // expected-error {{arithmetic on a pointer to an incomplete type}}
+
+  *&local_int8 = local_int8;
+  *&const_int8 = local_int8; // expected-error {{read-only variable}}
+  *&volatile_int8 = local_int8;
+  *&const_volatile_int8 = local_int8; // expected-error {{read-only variable}}
+
+  (&local_int8)[0] = local_int8; // expected-error {{subscript of pointer to incomplete type}}
+
+  overf(local_int8);
+  overf(local_int16);
+
+  overf8(local_int8);
+  overf8(local_int16); // expected-error {{no matching function}}
+
+  overf16(local_int8); // expected-error {{no matching function}}
+  overf16(local_int16);
+
+  varargs(1, local_int8, local_int16);
+
+  +init_int8; // expected-error {{invalid argument type}}
+  ++init_int8; // expected-error {{cannot increment}}
+  -init_int8; // expected-error {{invalid argument type}}
+  --init_int8; // expected-error {{cannot decrement}}
+  ~init_int8; // expected-error {{invalid argument type}}
+  !init_int8; // expected-error {{invalid argument type}}
+  *init_int8; // expected-error {{requires pointer operand}}
+  __real init_int8; // expected-error {{invalid type}}
+  __imag init_int8; // expected-error {{invalid type}}
+
+  local_int8 + init_int8; // expected-error {{invalid operands}}
+  local_int8 - init_int8; // expected-error {{invalid operands}}
+  local_int8 * init_int8; // expected-error {{invalid operands}}
+  local_int8 / init_int8; // expected-error {{invalid operands}}
+  local_int8 % init_int8; // expected-error {{invalid operands}}
+  local_int8 & init_int8; // expected-error {{invalid operands}}
+  local_int8 | init_int8; // expected-error {{invalid operands}}
+  local_int8 ^ init_int8; // expected-error {{invalid operands}}
+  local_int8 << init_int8; // expected-error {{invalid operands}}
+  local_int8 >> init_int8; // expected-error {{invalid operands}}
+  local_int8 < init_int8; // expected-error {{invalid operands}}
+  local_int8 <= init_int8; // expected-error {{invalid operands}}
+  local_int8 == init_int8; // expected-error {{invalid operands}}
+  local_int8 != init_int8; // expected-error {{invalid operands}}
+  local_int8 >= init_int8; // expected-error {{invalid operands}}
+  local_int8 > init_int8; // expected-error {{invalid operands}}
+  local_int8 && init_int8; // expected-error {{invalid operands}} expected-error {{not contextually convertible}}
+  local_int8 || init_int8; // expected-error {{invalid operands}} expected-error {{not contextually convertible}}
+
+  local_int8 += init_int8; // expected-error {{invalid operands}}
+  local_int8 -= init_int8; // expected-error {{invalid operands}}
+  local_int8 *= init_int8; // expected-error {{invalid operands}}
+  local_int8 /= init_int8; // expected-error {{invalid operands}}
+  local_int8 %= init_int8; // expected-error {{invalid operands}}
+  local_int8 &= init_int8; // expected-error {{invalid operands}}
+  local_int8 |= init_int8; // expected-error {{invalid operands}}
+  local_int8 ^= init_int8; // expected-error {{invalid operands}}
+  local_int8 <<= init_int8; // expected-error {{invalid operands}}
+  local_int8 >>= init_int8; // expected-error {{invalid operands}}
+
+  local_int8 + 0; // expected-error {{invalid operands}}
+  local_int8 - 0; // expected-error {{invalid operands}}
+  local_int8 * 0; // expected-error {{invalid operands}}
+  local_int8 / 0; // expected-error {{invalid operands}}
+  local_int8 % 0; // expected-error {{invalid operands}}
+  local_int8 & 0; // expected-error {{invalid operands}}
+  local_int8 | 0; // expected-error {{invalid operands}}
+  local_int8 ^ 0; // expected-error {{invalid operands}}
+  local_int8 << 0; // expected-error {{invalid operands}}
+  local_int8 >> 0; // expected-error {{invalid operands}}
+  local_int8 < 0; // expected-error {{invalid operands}}
+  local_int8 <= 0; // expected-error {{invalid operands}}
+  local_int8 == 0; // expected-error {{invalid operands}}
+  local_int8 != 0; // expected-error {{invalid operands}}
+  local_int8 >= 0; // expected-error {{invalid operands}}
+  local_int8 > 0; // expected-error {{invalid operands}}
+  local_int8 && 0; // expected-error {{invalid operands}} expected-error {{not contextually convertible}}
+  local_int8 || 0; // expected-error {{invalid operands}} expected-error {{not contextually convertible}}
+
+  if (local_int8) {} // expected-error {{not contextually convertible}}
+  while (local_int8) {} // expected-error {{not contextually convertible}}
+  do {} while (local_int8); // expected-error {{not contextually convertible}}
+  switch (local_int8) { default:; } // expected-error {{integer type}}
+}
+
+int vararg_receiver(int count, svint8_t first, ...) {
+  __builtin_va_list va;
+
+  __builtin_va_start(va, first);
+  __builtin_va_arg(va, svint8_t);
+  __builtin_va_end(va);
+  return count;
+}
+
+struct sized_struct {
+  int f1;
+  svint8_t f2; // expected-error {{field has incomplete type}}
+  svint8_t f3 : 2; // expected-error {{incomplete type}}
+};
+
+union sized_union {
+  int f1;
+  svint8_t f2; // expected-error {{field has incomplete type}}
+  svint8_t f3 : 2; // expected-error {{incomplete type}}
+};
+
+void pass_int8_ref(svint8_t &); // expected-note {{not viable}}
+
+svint8_t &return_int8_ref();
+#if __cplusplus >= 201103L
+svint8_t &&return_int8_rvalue_ref();
+#endif
+
+template<typename T> struct s_template {
+  T y; // expected-error {{incomplete type}}
+};
+
+template<typename T> struct s_ptr_template {
+  s_ptr_template();
+  s_ptr_template(T, svint8_t = svint8_t());
+  s_ptr_template(const s_ptr_template &, svint8_t = svint8_t());
+  T *y;
+};
+
+template<typename T> struct s_array_template {
+  T y[1]; // expected-error {{array has sizeless element type}}
+};
+
+struct widget {
+  widget(s_ptr_template<int>);
+  svint8_t operator[](int);
+};
+
+struct foo_iterator {
+  svint8_t operator++();
+  svint8_t operator*() const;
+  bool operator!=(const foo_iterator &) const;
+};
+
+struct foo {
+  foo();
+  operator svint8_t() const;
+  foo_iterator begin() const;
+  foo_iterator end() const;
+};
+
+struct constructible_from_sizeless {
+  constructible_from_sizeless(svint8_t);
+};
+
+void with_default(svint8_t = svint8_t());
+
+#if __cplusplus < 201703L
+void throwing_func() throw(svint8_t); // expected-error {{incomplete type}}
+void throwing_pointer_func() throw(svint8_t *); // expected-error {{pointer to incomplete type}}
+void throwing_pointer_func() throw(svint8_t &); // expected-error {{reference to incomplete type}}
+#endif
+
+template<typename T> void template_fn_direct(T) {}
+template<typename T> void template_fn_ref(T &) {}
+template<typename T> void template_fn_const_ref(const T &) {}
+#if __cplusplus >= 201103L
+template<typename T> void template_fn_rvalue_ref(T &&) {}
+#endif
+
+void cxx_only() {
+  svint8_t local_int8;
+  svint16_t local_int16;
+
+  pass_int8_ref(local_int8);
+  pass_int8_ref(local_int16); // expected-error {{no matching function}}
+
+  local_int8 = return_int8_ref();
+  local_int16 = return_int8_ref(); // expected-error {{incompatible type}}
+  return_int8_ref() = local_int8;
+  return_int8_ref() = local_int16; // expected-error {{incompatible type}}
+
+#if __cplusplus >= 201103L
+  local_int8 = return_int8_rvalue_ref();
+  local_int16 = return_int8_rvalue_ref(); // expected-error {{incompatible type}}
+
+  return_int8_rvalue_ref() = local_int8; // expected-error {{not assignable}}
+  return_int8_rvalue_ref() = local_int16; // expected-error {{not assignable}}
+#endif
+
+  local_int8 = static_cast<svint8_t>(local_int8);
+  local_int8 = static_cast<svint8_t>(local_int16); // expected-error {{not allowed}}
+  local_int16 = static_cast<svint16_t>(local_int8); // expected-error {{not allowed}}
+
+  throw 1;
+  throw local_int8; // expected-error {{cannot throw object of incomplete type}}
+
+  try {} catch (int) {}
+  try {} catch (svint8_t) {} // expected-error {{cannot catch incomplete type}}
+  try {} catch (svint8_t *) {} // expected-error {{cannot catch pointer to incomplete type}}
+  try {} catch (svint8_t &) {} // expected-error {{cannot catch reference to incomplete type}}
+
+  new svint8_t; // expected-error {{allocation of incomplete type}}
+  new svint8_t(); // expected-error {{allocation of incomplete type}}
+
+  (void)svint8_t();
+
+  local_int8 = svint8_t();
+  local_int8 = svint16_t(); // expected-error {{incompatible type}}
+
+  s_template<int> st_int;
+  s_template<svint8_t> st_svint8; // expected-note {{in instantiation}}
+
+  s_ptr_template<int> st_ptr_int;
+  s_ptr_template<svint8_t> st_ptr_svint8;
+
+  widget w(1);
+  local_int8 = w[1];
+
+  s_array_template<int> st_array_int;
+  s_array_template<svint8_t> st_array_svint8; // expected-note {{in instantiation}}
+
+  local_int8 = static_cast<svint8_t>(foo());
+  local_int16 = static_cast<svint8_t>(foo()); // expected-error {{incompatible type}}
+
+  local_int8 = foo();
+  local_int16 = foo(); // expected-error {{incompatible type}}
+
+  svint8_t &ref_int8 = local_int8;
+  ref_int8 = ref_int8; // expected-warning {{to itself}}
+  ref_int8 = local_int8;
+  local_int8 = ref_int8;
+
+#if __cplusplus >= 201103L
+  svint8_t zero_init_int8 {};
+  svint8_t init_int8 { local_int8 };
+#endif
+
+  template_fn_direct(local_int8);
+  template_fn_ref(local_int8);
+  template_fn_const_ref(local_int8);
+#if __cplusplus >= 201103L
+  template_fn_rvalue_ref(local_int8);
+#endif
+
+  _Static_assert(__is_trivially_destructible(svint8_t), "");
+  _Static_assert(!__is_nothrow_assignable(svint8_t, svint8_t), "");
+  _Static_assert(__is_nothrow_assignable(svint8_t &, svint8_t), "");
+  _Static_assert(!__is_nothrow_assignable(svint8_t &, svint16_t), "");
+  _Static_assert(__is_constructible(svint8_t), "");
+  _Static_assert(__is_constructible(svint8_t, svint8_t), "");
+  _Static_assert(!__is_constructible(svint8_t, svint8_t, svint8_t), "");
+  _Static_assert(!__is_constructible(svint8_t, svint16_t), "");
+  _Static_assert(__is_nothrow_constructible(svint8_t), "");
+  _Static_assert(__is_nothrow_constructible(svint8_t, svint8_t), "");
+  _Static_assert(!__is_nothrow_constructible(svint8_t, svint16_t), "");
+  _Static_assert(!__is_assignable(svint8_t, svint8_t), "");
+  _Static_assert(__is_assignable(svint8_t &, svint8_t), "");
+  _Static_assert(!__is_assignable(svint8_t &, svint16_t), "");
+  _Static_assert(__has_nothrow_assign(svint8_t), "");
+  _Static_assert(__has_nothrow_move_assign(svint8_t), "");
+  _Static_assert(__has_nothrow_copy(svint8_t), "");
+  _Static_assert(__has_nothrow_constructor(svint8_t), "");
+  _Static_assert(__has_trivial_assign(svint8_t), "");
+  _Static_assert(__has_trivial_move_assign(svint8_t), "");
+  _Static_assert(__has_trivial_copy(svint8_t), "");
+  _Static_assert(__has_trivial_constructor(svint8_t), "");
+  _Static_assert(__has_trivial_move_constructor(svint8_t), "");
+  _Static_assert(__has_trivial_destructor(svint8_t), "");
+  _Static_assert(!__has_virtual_destructor(svint8_t), "");
+  _Static_assert(!__is_abstract(svint8_t), "");
+  _Static_assert(!__is_aggregate(svint8_t), "");
+  _Static_assert(!__is_base_of(svint8_t, svint8_t), "");
+  _Static_assert(!__is_class(svint8_t), "");
+  _Static_assert(__is_convertible_to(svint8_t, svint8_t), "");
+  _Static_assert(!__is_convertible_to(svint8_t, svint16_t), "");
+  _Static_assert(!__is_empty(svint8_t), "");
+  _Static_assert(!__is_enum(svint8_t), "");
+  _Static_assert(!__is_final(svint8_t), "");
+  _Static_assert(!__is_literal(svint8_t), "");
+  _Static_assert(__is_pod(svint8_t), "");
+  _Static_assert(!__is_polymorphic(svint8_t), "");
+  _Static_assert(__is_trivial(svint8_t), "");
+  _Static_assert(__is_object(svint8_t), "");
+  _Static_assert(__has_unique_object_representations(svint8_t), "");
+  _Static_assert(!__is_arithmetic(svint8_t), "");
+  _Static_assert(!__is_floating_point(svint8_t), "");
+  _Static_assert(!__is_integral(svint8_t), "");
+  _Static_assert(!__is_complete_type(svint8_t), "");
+  _Static_assert(!__is_void(svint8_t), "");
+  _Static_assert(!__is_array(svint8_t), "");
+  _Static_assert(!__is_function(svint8_t), "");
+  _Static_assert(!__is_reference(svint8_t), "");
+  _Static_assert(__is_reference(svint8_t &), "");
+  _Static_assert(__is_reference(const svint8_t &), "");
+  _Static_assert(!__is_lvalue_reference(svint8_t), "");
+  _Static_assert(__is_lvalue_reference(svint8_t &), "");
+#if __cplusplus >= 201103L
+  _Static_assert(!__is_lvalue_reference(svint8_t &&), "");
+#endif
+  _Static_assert(!__is_rvalue_reference(svint8_t), "");
+  _Static_assert(!__is_rvalue_reference(svint8_t &), "");
+#if __cplusplus >= 201103L
+  _Static_assert(__is_rvalue_reference(svint8_t &&), "");
+#endif
+  _Static_assert(!__is_fundamental(svint8_t), "");
+  _Static_assert(__is_object(svint8_t), "");
+  _Static_assert(!__is_scalar(svint8_t), "");
+  _Static_assert(!__is_compound(svint8_t), "");
+  _Static_assert(!__is_pointer(svint8_t), "");
+  _Static_assert(__is_pointer(svint8_t *), "");
+  _Static_assert(!__is_member_object_pointer(svint8_t), "");
+  _Static_assert(!__is_member_function_pointer(svint8_t), "");
+  _Static_assert(!__is_member_pointer(svint8_t), "");
+  _Static_assert(!__is_const(svint8_t), "");
+  _Static_assert(__is_const(const svint8_t), "");
+  _Static_assert(__is_const(const volatile svint8_t), "");
+  _Static_assert(!__is_volatile(svint8_t), "");
+  _Static_assert(__is_volatile(volatile svint8_t), "");
+  _Static_assert(__is_volatile(const volatile svint8_t), "");
+  _Static_assert(!__is_standard_layout(svint8_t), "");
+  // At present these types are opaque and don't have the properties
+  // implied by their name.
+  _Static_assert(!__is_signed(svint8_t), "");
+  _Static_assert(!__is_unsigned(svint8_t), "");
+
+#if __cplusplus >= 201103L
+  auto auto_int8 = local_int8;
+  auto auto_int16 = local_int16;
+#if __cplusplus >= 201703L
+  auto [auto_int8_a] = local_int8; // expected-error {{cannot decompose}}
+#endif
+#endif
+
+  s_ptr_template<int> y;
+  s_ptr_template<int> &x = y;
+
+  constructible_from_sizeless cfs1(local_int8);
+  constructible_from_sizeless cfs2 = local_int8;
+#if __cplusplus >= 201103L
+  constructible_from_sizeless cfs3 { local_int8 };
+#endif
+
+#if __cplusplus >= 201103L
+  for (auto x : local_int8) {} // expected-error {{incomplete type}}
+
+  for (const svint8_t &x : foo()) { (void)x; } // expected-warning {{always a copy}} expected-note {{use non-reference type}}
+#endif
+}