[PATCH 3/3] [RFC only][NFC] More comments about completeness

[rsandifo-arm]

Summary

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

RFC on cfe-dev. ]

This patch follows on from the main sizeless type patch and adds
comments explaining why some code didn't change. It avoids adding
comments for Objective C/C++ and OpenMP since the sizeless type feature
is at the moment restricted to core C and C++. It also avoids adding
comments for code specific to the Microsoft ABI, which at present
doesn't support sizeless types.

[rsandifo-arm]

Abandoning in favour of:

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

lib/AST/ASTContext.cpp

if (const auto *RT = T->getAs<ReferenceType>()) {
       if (ForAlignof)
         T = RT->getPointeeType();
       else
         T = getPointerType(RT->getPointeeType());
     }
     QualType BaseT = getBaseElementType(T);
     if (T->isFunctionType())
       Align = getTypeInfoImpl(T.getTypePtr()).Align;
+    // "Incomplete" rather than "indefinite" since sizeless types do not have
+    // a meaningful alignment.  Sema should reject attempts to specify one.
     else if (!BaseT->isIncompleteType()) {
       // Adjust alignments of declarations with array type by the
       // large-array alignment on the target.
       if (const ArrayType *arrayType = getAsArrayType(T)) {
         unsigned MinWidth = Target->getLargeArrayMinWidth();
         if (!ForAlignof && MinWidth) {
           if (isa<VariableArrayType>(arrayType))
             Align = std::max(Align, Target->getLargeArrayAlign());

 unsigned ASTContext::getTypeAlignIfKnown(QualType T) const {
   // An alignment on a typedef overrides anything else.
   if (const auto *TT = T->getAs<TypedefType>())
     if (unsigned Align = TT->getDecl()->getMaxAlignment())
       return Align;
 
   // If we have an (array of) complete type, we're done.
   T = getBaseElementType(T);
+  // "Incomplete" rather than "indefinite" since sizeless types do not have
+  // a meaningful alignment.  Sema should reject attempts to specify one.
   if (!T->isIncompleteType())
     return getTypeAlign(T);
 
   // If we had an array type, its element type might be a typedef
   // type with an alignment attribute.
   if (const auto *TT = T->getAs<TypedefType>())
     if (unsigned Align = TT->getDecl()->getMaxAlignment())
       return Align;

 }
 
 /// getConstantArrayType - Return the unique reference to the type for an
 /// array of the specified element type.
 QualType ASTContext::getConstantArrayType(QualType EltTy,
                                           const llvm::APInt &ArySizeIn,
                                           ArrayType::ArraySizeModifier ASM,
                                           unsigned IndexTypeQuals) const {
+  // "Incomplete" rather than "indefinite" since arrays of sizeless type
+  // are not allowed.
   assert((EltTy->isDependentType() ||
           EltTy->isIncompleteType() || EltTy->isConstantSizeType()) &&
          "Constant array of VLAs is illegal!");
 
   // Convert the array size into a canonical width matching the pointer size for
   // the target.
   llvm::APInt ArySize(ArySizeIn);
   ArySize = ArySize.zextOrTrunc(Target->getMaxPointerWidth());

lib/AST/ExprConstant.cpp

static bool IsWeakLValue(const LValue &Value) {
   return Decl && Decl->isWeak();
 }
 
 static bool isZeroSized(const LValue &Value) {
   const ValueDecl *Decl = GetLValueBaseDecl(Value);
   if (Decl && isa<VarDecl>(Decl)) {
     QualType Ty = Decl->getType();
     if (Ty->isArrayType())
+      // "Complete" and "definite" are the same here, since arrays of sizeless
+      // type are not allowed.
       return Ty->isIncompleteType() ||
              Decl->getASTContext().getTypeSize(Ty) == 0;
   }
   return false;
 }
 
 static bool EvalPointerValueAsBool(const APValue &Value, bool &Result) {
   // A null base expression indicates a null pointer.  These are always

 ///
 /// If this returns false, the value of Result is undefined.
 static bool determineEndOffset(EvalInfo &Info, SourceLocation ExprLoc,
                                unsigned Type, const LValue &LVal,
                                CharUnits &EndOffset) {
   bool DetermineForCompleteObject = refersToCompleteObject(LVal);
 
   auto CheckedHandleSizeof = [&](QualType Ty, CharUnits &Result) {
+    // "Incomplete" rather than "indefinite" since sizeof cannot be applied
+    // to sizeless types.
     if (Ty.isNull() || Ty->isIncompleteType() || Ty->isFunctionType())
       return false;
     return HandleSizeof(Info, ExprLoc, Ty, Result);
   };
 
   // We want to evaluate the size of the entire object. This is a valid fallback
   // for when Type=1 and the designator is invalid, because we're asked for an
   // upper-bound.
if (Size.isPowerOfTwo()) {
             E->getArg(1)->isNullPointerConstant(Info.Ctx,
                                                 Expr::NPC_NeverValueDependent))
           // OK, we will inline appropriately-aligned operations of this size,
           // and _Atomic(T) is appropriately-aligned.
           return Success(1, E);
 
         QualType PointeeType = E->getArg(1)->IgnoreImpCasts()->getType()->
           castAs<PointerType>()->getPointeeType();
+        // "Incomplete" rather than "indefinite" since sizeless types do
+        // not have a meaningful alignment, and so cannot guarantee atomicity
+        // for even a fixed-size prefix.
         if (!PointeeType->isIncompleteType() &&
             Info.Ctx.getTypeAlignInChars(PointeeType) >= Size) {
           // OK, we will inline operations on this object.
           return Success(1, E);
         }
       }
     }
 

lib/AST/Type.cpp

bool Type::isLiteralType(const ASTContext &Ctx) const {
   if (BaseTy->isIncompleteType())
     return false;
 
   // C++11 [basic.types]p10:
   //   A type is a literal type if it is:
   //    -- a scalar type; or
   // As an extension, Clang treats vector types and complex types as
   // literal types.
+  //
+  // Sizeless types are not treated as literal types since sizeless objects
+  // cannot usefully be created at compile time.
   if (BaseTy->isScalarType() || BaseTy->isVectorType() ||
       BaseTy->isAnyComplexType())
     return true;
   //    -- a reference type; or
   if (BaseTy->isReferenceType())
     return true;
   //    -- a class type that has all of the following properties:
   if (const auto *RT = BaseTy->getAs<RecordType>()) {
bool Type::isStandardLayoutType() const {
   //   Scalar types, standard-layout class types, arrays of such types, and
   //   cv-qualified versions of these types are collectively called
   //   standard-layout types.
   const Type *BaseTy = getBaseElementTypeUnsafe();
   assert(BaseTy && "NULL element type");
 
   // Return false for incomplete types after skipping any incomplete array
   // types which are expressly allowed by the standard and thus our API.
+  //
+  // We do not treat sizeless types as standard layout, since the lack of
+  // a computable size makes them somewhat special.  There's no strong reason
+  // either way though.
   if (BaseTy->isIncompleteType())
     return false;
 
   // As an extension, Clang treats vector types as Scalar types.
   if (BaseTy->isScalarType() || BaseTy->isVectorType()) return true;
   if (const auto *RT = BaseTy->getAs<RecordType>()) {
     if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl()))
       if (!ClassDecl->isStandardLayout())

lib/Sema/Sema.cpp

for (TentativeDefinitionsType::iterator
     if (const IncompleteArrayType *ArrayT
         = Context.getAsIncompleteArrayType(VD->getType())) {
       // Set the length of the array to 1 (C99 6.9.2p5).
       Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
       llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
       QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
                                                 One, ArrayType::Normal, 0);
       VD->setType(T);
+    // "Complete" rather than "definite" because tentative definitions
+    // make no sense for sizeless types.  Variables of sizeless type
+    // can never be global anyway.
     } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
                                    diag::err_tentative_def_incomplete_type))
       VD->setInvalidDecl();
 
     // No initialization is performed for a tentative definition.
     CheckCompleteVariableDeclaration(VD);
 
     // Notify the consumer that we've completed a tentative definition.

lib/Sema/SemaCXXScopeSpec.cpp

bool Sema::RequireCompleteDeclContext(CXXScopeSpec &SS,
   const TagType *tagType = type->getAs<TagType>();
   if (tagType && tagType->isBeingDefined())
     return false;
 
   SourceLocation loc = SS.getLastQualifierNameLoc();
   if (loc.isInvalid()) loc = SS.getRange().getBegin();
 
   // The type must be complete.
+  //
+  // "Complete" and "definite" are the same here, since we don't yet
+  // support sizeless structures, and sizeless enums make no sense.
   if (RequireCompleteType(loc, type, diag::err_incomplete_nested_name_spec,
                           SS.getRange())) {
     SS.SetInvalid(SS.getRange());
     return true;
   }
 
   // Fixed enum types are complete, but they aren't valid as scopes
   // until we see a definition, so awkwardly pull out this special

lib/Sema/SemaCast.cpp

if (DestPointer) {
     SrcExpr = ExprError();
     return;
   }
 
   const RecordType *DestRecord = DestPointee->getAs<RecordType>();
   if (DestPointee->isVoidType()) {
     assert(DestPointer && "Reference to void is not possible");
   } else if (DestRecord) {
+    // "Complete" and "definite" are the same here, since we don't yet support
+    // sizeless structures.
     if (Self.RequireCompleteType(OpRange.getBegin(), DestPointee,
                                  diag::err_bad_dynamic_cast_incomplete,
                                  DestRange)) {
       SrcExpr = ExprError();
       return;
     }
   } else {
     Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_class)
if (DestPointer) {
     if (SrcExpr.get()->isRValue())
       SrcExpr = Self.CreateMaterializeTemporaryExpr(
           SrcType, SrcExpr.get(), /*IsLValueReference*/ false);
     SrcPointee = SrcType;
   }
 
   const RecordType *SrcRecord = SrcPointee->getAs<RecordType>();
   if (SrcRecord) {
+    // "Complete" and "definite" are the same here, since we don't yet support
+    // sizeless structures.
     if (Self.RequireCompleteType(OpRange.getBegin(), SrcPointee,
                                  diag::err_bad_dynamic_cast_incomplete,
                                  SrcExpr.get())) {
       SrcExpr = ExprError();
       return;
     }
   } else {
     Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_class)

 /// TryStaticPointerDowncast. Tests whether a static downcast from SrcType to
 /// DestType is possible and allowed.
 TryCastResult
 TryStaticDowncast(Sema &Self, CanQualType SrcType, CanQualType DestType,
                   bool CStyle, SourceRange OpRange, QualType OrigSrcType,
                   QualType OrigDestType, unsigned &msg, 
                   CastKind &Kind, CXXCastPath &BasePath) {
   // We can only work with complete types. But don't complain if it doesn't work
+  //
+  // "Complete" and "definite" are the same here, since we don't yet support
+  // sizeless structures.
   if (!Self.isCompleteType(OpRange.getBegin(), SrcType) ||
       !Self.isCompleteType(OpRange.getBegin(), DestType))
     return TC_NotApplicable;
 
   // Downcast can only happen in class hierarchies, so we need classes.
   if (!DestType->getAs<RecordType>() || !SrcType->getAs<RecordType>()) {
     return TC_NotApplicable;
   }

 ///   An expression e can be explicitly converted to a type T using a
 ///   @c static_cast if the declaration "T t(e);" is well-formed [...].
 TryCastResult
 TryStaticImplicitCast(Sema &Self, ExprResult &SrcExpr, QualType DestType,
                       Sema::CheckedConversionKind CCK, 
                       SourceRange OpRange, unsigned &msg,
                       CastKind &Kind, bool ListInitialization) {
   if (DestType->isRecordType()) {
+    // "Complete" and "definite" are the same here, since we don't yet support
+    // sizeless structures.
     if (Self.RequireCompleteType(OpRange.getBegin(), DestType,
                                  diag::err_bad_dynamic_cast_incomplete) ||
         Self.RequireNonAbstractType(OpRange.getBegin(), DestType,
                                     diag::err_allocation_of_abstract_type)) {
       msg = 0;
       return TC_Failed;
     }
   }
if (!DestPtr->isAddressSpaceOverlapping(*SrcType->getAs<PointerType>())) {
                 diag::err_typecheck_incompatible_address_space)
           << SrcType << DestType << Sema::AA_Casting
           << SrcExpr.get()->getSourceRange();
       SrcExpr = ExprError();
       return;
     }
   }
 
+  // "Complete" rather than "definite" because there's no point casting
+  // sizeless types.
   if (Self.RequireCompleteType(OpRange.getBegin(), DestType,
                                diag::err_typecheck_cast_to_incomplete)) {
     SrcExpr = ExprError();
     return;
   }
 
   if (!DestType->isScalarType() && !DestType->isVectorType()) {
     const RecordType *DestRecordTy = DestType->getAs<RecordType>();

lib/Sema/SemaChecking.cpp

if (IsAddSub && !ValType->isIntegerType() && !ValType->isPointerType()) {
         << IsC11 << Ptr->getType() << Ptr->getSourceRange();
       return ExprError();
     }
     if (!IsAddSub && !ValType->isIntegerType()) {
       Diag(DRE->getLocStart(), diag::err_atomic_op_bitwise_needs_atomic_int)
         << IsC11 << Ptr->getType() << Ptr->getSourceRange();
       return ExprError();
     }
+    // "Complete" rather than "definite" because pointer arithmetic on
+    // sizeless types is not well-formed.
     if (IsC11 && ValType->isPointerType() &&
         RequireCompleteType(Ptr->getLocStart(), ValType->getPointeeType(),
                             diag::err_incomplete_type)) {
       return ExprError();
     }
   } else if (IsN && !ValType->isIntegerType() && !ValType->isPointerType()) {
     // For __atomic_*_n operations, the value type must be a scalar integral or
     // pointer type which is 1, 2, 4, 8 or 16 bytes in length.
if (const PointerType *DestPtrTy = DestTy->getAs<PointerType>()) {
           // TODO: For strncpy() and friends, this could suggest sizeof(dst)
           //       over sizeof(src) as well.
           unsigned ActionIdx = 0; // Default is to suggest dereferencing.
           StringRef ReadableName = FnName->getName();
 
           if (const UnaryOperator *UnaryOp = dyn_cast<UnaryOperator>(Dest))
             if (UnaryOp->getOpcode() == UO_AddrOf)
               ActionIdx = 1; // If its an address-of operator, just remove it.
+          // "Incomplete" rather than "indefinite" since we can't compute
+          // the size of sizeless types.
           if (!PointeeTy->isIncompleteType() &&
               (Context.getTypeSize(PointeeTy) == Context.getCharWidth()))
             ActionIdx = 2; // If the pointee's size is sizeof(char),
                            // suggest an explicit length.
 
           // If the function is defined as a builtin macro, do not show macro
           // expansion.
           SourceLocation SL = SizeOfArg->getExprLoc();
if (T->isDependentType() || Op->getType()->isDependentType())
     return;
 
   // Require that the destination be a pointer type.
   const PointerType *DestPtr = T->getAs<PointerType>();
   if (!DestPtr) return;
 
   // If the destination has alignment 1, we're done.
   QualType DestPointee = DestPtr->getPointeeType();
+  // "Incomplete" rather than "indefinite" since sizeless types do not have
+  // a meaningful alignment, and we should reject attempts to specify one.
   if (DestPointee->isIncompleteType()) return;
   CharUnits DestAlign = Context.getTypeAlignInChars(DestPointee);
   if (DestAlign.isOne()) return;
 
   // Require that the source be a pointer type.
   const PointerType *SrcPtr = Op->getType()->getAs<PointerType>();
   if (!SrcPtr) return;
   QualType SrcPointee = SrcPtr->getPointeeType();
void Sema::DiscardMisalignedMemberAddress(const Type *T, Expr *E) {
   if (!T->isPointerType() && !T->isIntegerType())
     return;
   if (isa<UnaryOperator>(E) &&
       cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf) {
     auto *Op = cast<UnaryOperator>(E)->getSubExpr()->IgnoreParens();
     if (isa<MemberExpr>(Op)) {
       auto MA = std::find(MisalignedMembers.begin(), MisalignedMembers.end(),
                           MisalignedMember(Op));
+      // "Incomplete" rather than "indefinite" since sizeless types do not have
+      // a meaningful alignment, and we should reject attempts to specify one.
       if (MA != MisalignedMembers.end() &&
           (T->isIntegerType() ||
            (T->isPointerType() && (T->getPointeeType()->isIncompleteType() ||
                                    Context.getTypeAlignInChars(
                                        T->getPointeeType()) <= MA->Alignment))))
         MisalignedMembers.erase(MA);
     }
   }

lib/Sema/SemaCodeComplete.cpp

if (FD) { // We check whether it's a resolved function declaration.
                              Args, CandidateSet,
                              /*SuppressUsedConversions=*/false,
                              /*PartialOverloading=*/true);
 
     } else if (auto DC = NakedFn->getType()->getAsCXXRecordDecl()) {
       // If expression's type is CXXRecordDecl, it may overload the function
       // call operator, so we check if it does and add them as candidates.
       // A complete type is needed to lookup for member function call operators.
+      //
+      // "Complete" and "definite" are the same here, since we don't yet
+      // support sizeless structures.
       if (isCompleteType(Loc, NakedFn->getType())) {
         DeclarationName OpName = Context.DeclarationNames
                                  .getCXXOperatorName(OO_Call);
         LookupResult R(*this, OpName, Loc, LookupOrdinaryName);
         LookupQualifiedName(R, DC);
         R.suppressDiagnostics();
         SmallVector<Expr *, 12> ArgExprs(1, NakedFn);
         ArgExprs.append(Args.begin(), Args.end());

lib/Sema/SemaCoroutine.cpp

static QualType lookupPromiseType(Sema &S, const FunctionDecl *FD,
   for (QualType T : FnType->getParamTypes())
     AddArg(T);
 
   // Build the template-id.
   QualType CoroTrait =
       S.CheckTemplateIdType(TemplateName(CoroTraits), KwLoc, Args);
   if (CoroTrait.isNull())
     return QualType();
+  // "Complete" and "definite" are the same here, since std::coroutine_traits
+  // is never sizeless.
   if (S.RequireCompleteType(KwLoc, CoroTrait,
                             diag::err_coroutine_type_missing_specialization))
     return QualType();
 
   auto *RD = CoroTrait->getAsCXXRecordDecl();
   assert(RD && "specialization of class template is not a class?");
 
   // Look up the ::promise_type member.
static QualType lookupPromiseType(Sema &S, const FunctionDecl *FD,
   };
 
   if (!PromiseType->getAsCXXRecordDecl()) {
     S.Diag(FuncLoc,
            diag::err_implied_std_coroutine_traits_promise_type_not_class)
         << buildElaboratedType();
     return QualType();
   }
+  // "Complete" and "definite" are the same here, since we don't yet
+  // support sizeless structures.
   if (S.RequireCompleteType(FuncLoc, buildElaboratedType(),
                             diag::err_coroutine_promise_type_incomplete))
     return QualType();
 
   return PromiseType;
 }
 
 /// Look up the std::experimental::coroutine_handle<PromiseType>.
Args.addArgument(TemplateArgumentLoc(
       TemplateArgument(PromiseType),
       S.Context.getTrivialTypeSourceInfo(PromiseType, Loc)));
 
   // Build the template-id.
   QualType CoroHandleType =
       S.CheckTemplateIdType(TemplateName(CoroHandle), Loc, Args);
   if (CoroHandleType.isNull())
     return QualType();
+  // "Complete" and "definite" are the same here, since we don't yet
+  // support sizeless structures.
   if (S.RequireCompleteType(Loc, CoroHandleType,
                             diag::err_coroutine_type_missing_specialization))
     return QualType();
 
   return CoroHandleType;
 }
 
 static bool isValidCoroutineContext(Sema &S, SourceLocation Loc,
static FunctionDecl *findDeleteForPromise(Sema &S, SourceLocation Loc,
   auto *PointeeRD = PromiseType->getAsCXXRecordDecl();
   assert(PointeeRD && "PromiseType must be a CxxRecordDecl type");
 
   if (S.FindDeallocationFunction(Loc, PointeeRD, DeleteName, OperatorDelete))
     return nullptr;
 
   if (!OperatorDelete) {
     // Look for a global declaration.
+    //
+    // "Complete" and "definite" are the same here, since we don't yet
+    // support sizeless structures.
     const bool CanProvideSize = S.isCompleteType(Loc, PromiseType);
     const bool Overaligned = false;
     OperatorDelete = S.FindUsualDeallocationFunction(Loc, CanProvideSize,
                                                      Overaligned, DeleteName);
   }
   S.MarkFunctionReferenced(Loc, OperatorDelete);
   return OperatorDelete;
 }

 }
 
 bool CoroutineStmtBuilder::makeNewAndDeleteExpr() {
   // Form and check allocation and deallocation calls.
   assert(!IsPromiseDependentType &&
          "cannot make statement while the promise type is dependent");
   QualType PromiseType = Fn.CoroutinePromise->getType();
 
+  // "Complete" rather than "definite" because we do not (yet?) want to
+  // support sizeless promise types.
   if (S.RequireCompleteType(Loc, PromiseType, diag::err_incomplete_type))
     return false;
 
   const bool RequiresNoThrowAlloc = ReturnStmtOnAllocFailure != nullptr;
 
   // [dcl.fct.def.coroutine]/7
   // Lookup allocation functions using a parameter list composed of the
   // requested size of the coroutine state being allocated, followed by

lib/Sema/SemaDecl.cpp

Decl *Sema::BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS,
 
   // Inject the members of the anonymous struct into the current
   // context and into the identifier resolver chain for name lookup
   // purposes.
   SmallVector<NamedDecl*, 2> Chain;
   Chain.push_back(Anon);
 
   RecordDecl *RecordDef = Record->getDefinition();
+  // "Complete" and "definite" are the same here, since we don't yet
+  // support sizeless structures.
   if (RequireCompleteType(Anon->getLocation(), RecTy,
                           diag::err_field_incomplete) ||
       InjectAnonymousStructOrUnionMembers(*this, S, CurContext, RecordDef,
                                           AS_none, Chain)) {
     Anon->setInvalidDecl();
     ParentDecl->setInvalidDecl();
   }
 
case VarDecl::TentativeDefinition:
       // File scope. C99 6.9.2p2: A declaration of an identifier for an
       // object that has file scope without an initializer, and without a
       // storage-class specifier or with the storage-class specifier "static",
       // constitutes a tentative definition. Note: A tentative definition with
       // external linkage is valid (C99 6.2.2p5).
       if (!Var->isInvalidDecl()) {
         if (const IncompleteArrayType *ArrayT
                                     = Context.getAsIncompleteArrayType(Type)) {
+          // "Complete" and "definite" are the same here, since arrays
+          // of sizeless type are not allowed.
           if (RequireCompleteType(Var->getLocation(),
                                   ArrayT->getElementType(),
                                   diag::err_illegal_decl_array_incomplete_type))
             Var->setInvalidDecl();
         } else if (Var->getStorageClass() == SC_Static) {
           // C99 6.9.2p3: If the declaration of an identifier for an object is
           // a tentative definition and has internal linkage (C99 6.2.2p3), the
           // declared type shall not be an incomplete type.
           // NOTE: code such as the following
           //     static struct s;
           //     struct s { int a; };
           // is accepted by gcc. Hence here we issue a warning instead of
           // an error and we do not invalidate the static declaration.
           // NOTE: to avoid multiple warnings, only check the first declaration.
           if (Var->isFirstDecl())
+            // "Complete" rather than "definite" because tentative definitions
+            // make no sense for sizeless types.  Variables of sizeless type
+            // can never be global anyway.
             RequireCompleteType(Var->getLocation(), Type,
                                 diag::ext_typecheck_decl_incomplete_type);
         }
       }
 
       // Record the tentative definition; we're done.
       if (!Var->isInvalidDecl())
         TentativeDefinitions.push_back(Var);
ExprResult Sema::VerifyBitField(SourceLocation FieldLoc,
   // Default to true; that shouldn't confuse checks for emptiness
   if (ZeroWidth)
     *ZeroWidth = true;
 
   // C99 6.7.2.1p4 - verify the field type.
   // C++ 9.6p3: A bit-field shall have integral or enumeration type.
   if (!FieldTy->isDependentType() && !FieldTy->isIntegralOrEnumerationType()) {
     // Handle incomplete types with specific error.
+    //
+    // "Complete" and "definite" are the same here, since we don't yet
+    // support sizeless structures (and thus sizeless fields).
     if (RequireCompleteType(FieldLoc, FieldTy, diag::err_field_incomplete))
       return ExprError();
     if (FieldName)
       return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
         << FieldName << FieldTy << BitWidth->getSourceRange();
     return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
       << FieldTy << BitWidth->getSourceRange();
   } else if (DiagnoseUnexpandedParameterPack(const_cast<Expr *>(BitWidth),
FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T,
   // marking this declaration as invalid.
   if (T.isNull()) {
     InvalidDecl = true;
     T = Context.IntTy;
   }
 
   QualType EltTy = Context.getBaseElementType(T);
   if (!EltTy->isDependentType()) {
+    // "Complete" rather than "definite" because fields cannot
+    // have sizeless types.
     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->isIndefiniteType(&Def);
       if (Def && Def->isInvalidDecl()) {
if (FDTy->isFunctionType()) {
         // Okay, we have a legal flexible array member at the end of the struct.
         Record->setHasFlexibleArrayMember(true);
       } else {
         // In ObjCContainerDecl ivars with incomplete array type are accepted,
         // unless they are followed by another ivar. That check is done
         // elsewhere, after synthesized ivars are known.
       }
     } else if (!FDTy->isDependentType() &&
+               // "Complete" rather than "definite" because fields cannot
+               // have sizeless types.
                RequireCompleteType(FD->getLocation(), FD->getType(),
                                    diag::err_field_incomplete)) {
       // Incomplete type
       FD->setInvalidDecl();
       EnclosingDecl->setInvalidDecl();
       continue;
     } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) {
       if (Record && FDTTy->getDecl()->hasFlexibleArrayMember()) {
if (CheckForZeroSize) {
            (NonBitFields == 0 || ZeroSize) && I != E; ++I) {
         IsEmpty = false;
         if (I->isUnnamedBitfield()) {
           if (!I->isZeroLengthBitField(Context))
             ZeroSize = false;
         } else {
           ++NonBitFields;
           QualType FieldType = I->getType();
+          // "Complete" and "definite" are the same here, since we don't yet
+          // support sizeless structures (and thus sizeless fields).
           if (FieldType->isIncompleteType() ||
               !Context.getTypeSizeInChars(FieldType).isZero())
             ZeroSize = false;
         }
       }
 
       // Empty structs are an extension in C (C99 6.7.2.1p7). They are
       // allowed in C++, but warn if its declaration is inside

lib/Sema/SemaDeclAttr.cpp

static bool threadSafetyCheckIsPointer(Sema &S, const Decl *D,
   QualType QT = VD->getType();
   if (QT->isAnyPointerType())
     return true;
 
   if (const auto *RT = QT->getAs<RecordType>()) {
     // If it's an incomplete type, it could be a smart pointer; skip it.
     // (We don't want to force template instantiation if we can avoid it,
     // since that would alter the order in which templates are instantiated.)
+    //
+    // "Complete" and "definite" are the same here, since we don't yet
+    // support sizeless structures.
     if (RT->isIncompleteType())
       return true;
 
     if (threadSafetyCheckIsSmartPointer(S, RT))
       return true;
   }
 
   S.Diag(AL.getLoc(), diag::warn_thread_attribute_decl_not_pointer)

 
 static bool checkRecordTypeForCapability(Sema &S, QualType Ty) {
   const RecordType *RT = getRecordType(Ty);
 
   if (!RT)
     return false;
 
   // Don't check for the capability if the class hasn't been defined yet.
+  //
+  // "Complete" and "definite" are the same here, since we don't yet
+  // support sizeless structures.
   if (RT->isIncompleteType())
     return true;
 
   // Allow smart pointers to be used as capability objects.
   // FIXME -- Check the type that the smart pointer points to.
   if (threadSafetyCheckIsSmartPointer(S, RT))
     return true;
 
static void handleExtVectorTypeAttr(Sema &S, Decl *D, const AttributeList &AL) {
   S.ExtVectorDecls.push_back(cast<TypedefNameDecl>(D));
 }
 
 static void handlePackedAttr(Sema &S, Decl *D, const AttributeList &AL) {
   if (auto *TD = dyn_cast<TagDecl>(D))
     TD->addAttr(::new (S.Context) PackedAttr(AL.getRange(), S.Context,
                                         AL.getAttributeSpellingListIndex()));
   else if (auto *FD = dyn_cast<FieldDecl>(D)) {
+    // "Complete" and "definite" are the same here, since we don't yet
+    // support sizeless structures (and thus sizeless fields).
     bool BitfieldByteAligned = (!FD->getType()->isDependentType() &&
                                 !FD->getType()->isIncompleteType() &&
                                 FD->isBitField() &&
                                 S.Context.getTypeAlign(FD->getType()) <= 8);
 
     if (S.getASTContext().getTargetInfo().getTriple().isPS4()) {
       if (BitfieldByteAligned)
         // The PS4 target needs to maintain ABI backwards compatibility.
static void handleTransparentUnionAttr(Sema &S, Decl *D,
   QualType FirstType = FirstField->getType();
   if (FirstType->hasFloatingRepresentation() || FirstType->isVectorType()) {
     S.Diag(FirstField->getLocation(),
            diag::warn_transparent_union_attribute_floating)
       << FirstType->isVectorType() << FirstType;
     return;
   }
 
+  // "Complete" and "definite" are the same here, since we don't yet support
+  // sizeless unions (and thus sizeless fields).
   if (FirstType->isIncompleteType())
     return;
   uint64_t FirstSize = S.Context.getTypeSize(FirstType);
   uint64_t FirstAlign = S.Context.getTypeAlign(FirstType);
   for (; Field != FieldEnd; ++Field) {
     QualType FieldType = Field->getType();
+    // "Complete" and "definite" are the same here, since we don't yet support
+    // sizeless unions (and thus sizeless fields).
     if (FieldType->isIncompleteType())
       return;
     // FIXME: this isn't fully correct; we also need to test whether the
     // members of the union would all have the same calling convention as the
     // first member of the union. Checking just the size and alignment isn't
     // sufficient (consider structs passed on the stack instead of in registers
     // as an example).
     if (S.Context.getTypeSize(FieldType) != FirstSize ||

lib/Sema/SemaDeclCXX.cpp

if (!TraitTD) {
     S.Diag(Found->getLocation(), diag::note_declared_at);
     return true;
   }
 
   // Build the template-id.
   QualType TraitTy = S.CheckTemplateIdType(TemplateName(TraitTD), Loc, Args);
   if (TraitTy.isNull())
     return true;
+  // "Complete" and "definite" are the same here, since trait classes are never
+  // sizeless.
   if (!S.isCompleteType(Loc, TraitTy)) {
     if (DiagID)
       S.RequireCompleteType(
           Loc, TraitTy, DiagID,
           printTemplateArgs(S.Context.getPrintingPolicy(), Args));
     return true;
   }
 
static bool checkTupleLikeDecomposition(Sema &S,
 
   DeclarationName GetDN = S.PP.getIdentifierInfo("get");
 
   // [dcl.decomp]p3:
   //   The unqualified-id get is looked up in the scope of E by class member
   //   access lookup
   LookupResult MemberGet(S, GetDN, Src->getLocation(), Sema::LookupMemberName);
   bool UseMemberGet = false;
+  // "Complete" and "definite" are the same here, since we don't yet
+  // support sizeless structures (and there can therefore be no "get"
+  // member for sizeless types).
   if (S.isCompleteType(Src->getLocation(), DecompType)) {
     if (auto *RD = DecompType->getAsCXXRecordDecl())
       S.LookupQualifiedName(MemberGet, RD);
     if (MemberGet.isAmbiguous())
       return true;
     UseMemberGet = !MemberGet.empty();
     S.FilterAcceptableTemplateNames(MemberGet);
   }
if (Attr *ClassAttr = getDLLAttr(Class)) {
                                             BaseLoc);
       }
     }
   }
 
   // C++ [class.derived]p2:
   //   The class-name in a base-specifier shall not be an incompletely
   //   defined class.
+  //
+  // "Complete" and "definite" are the same here, since we don't yet
+  // support sizeless structures.
   if (RequireCompleteType(BaseLoc, BaseType,
                           diag::err_incomplete_base_class, SpecifierRange)) {
     Class->setInvalidDecl();
     return nullptr;
   }
 
   // If the base class is polymorphic or isn't empty, the new one is/isn't, too.
   RecordDecl *BaseDecl = BaseType->getAs<RecordType>()->getDecl();
bool Sema::IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base) {
 
   // If either the base or the derived type is invalid, don't try to
   // check whether one is derived from the other.
   if (BaseRD->isInvalidDecl() || DerivedRD->isInvalidDecl())
     return false;
 
   // FIXME: In a modules build, do we need the entire path to be visible for us
   // to be able to use the inheritance relationship?
+  //
+  // "Complete" and "definite" are the same here, since we don't yet
+  // support sizeless structures.
   if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined())
     return false;
 
   return DerivedRD->isDerivedFrom(BaseRD);
 }
 
 /// \brief Determine whether the type \p Derived is a C++ class that is
 /// derived from the type \p Base.
 bool Sema::IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base,
                          CXXBasePaths &Paths) {
   if (!getLangOpts().CPlusPlus)
     return false;
 
   CXXRecordDecl *DerivedRD = Derived->getAsCXXRecordDecl();
   if (!DerivedRD)
     return false;
 
   CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl();
   if (!BaseRD)
     return false;
 
+  // "Complete" and "definite" are the same here, since we don't yet
+  // support sizeless structures.
   if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined())
     return false;
 
   return DerivedRD->isDerivedFrom(BaseRD, Paths);
 }
 
 static void BuildBasePathArray(const CXXBasePath &Path,
                                CXXCastPath &BasePathArray) {
if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
     Mode = 1;
     DK = diag::err_catch_incomplete_ptr;
   } else if (const ReferenceType *Ref = BaseType->getAs<ReferenceType>()) {
     // For the purpose of error recovery, we treat rvalue refs like lvalue refs.
     BaseType = Ref->getPointeeType();
     Mode = 2;
     DK = diag::err_catch_incomplete_ref;
   }
+  // "Complete" rather than "definite" because sizeless types cannot be thrown.
   if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
       !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK))
     Invalid = true;
 
   if (!Invalid && !ExDeclType->isDependentType() &&
       RequireNonAbstractType(Loc, ExDeclType,
                              diag::err_abstract_type_in_decl,
                              AbstractVariableType))
bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
   if (!Context.hasSameUnqualifiedType(NewClassTy, OldClassTy)) {
     // C++14 [class.virtual]p8:
     //   If the class type in the covariant return type of D::f differs from
     //   that of B::f, the class type in the return type of D::f shall be
     //   complete at the point of declaration of D::f or shall be the class
     //   type D.
     if (const RecordType *RT = NewClassTy->getAs<RecordType>()) {
       if (!RT->isBeingDefined() &&
+          // "Complete" and "definite" are the same here, since we don't yet
+          // support sizeless structures.
           RequireCompleteType(New->getLocation(), NewClassTy,
                               diag::err_covariant_return_incomplete,
                               New->getDeclName()))
         return true;
     }
 
     // Check if the new class derives from the old class.
     if (!IsDerivedFrom(New->getLocation(), NewClassTy, OldClassTy)) {

lib/Sema/SemaExceptionSpec.cpp

bool Sema::CheckSpecifiedExceptionType(QualType &T, SourceRange Range) {
 
   // C++11 [except.spec]p2:
   //   A type denoted in an exception-specification shall not denote an
   //   incomplete type other than a class currently being defined [...].
   //   A type denoted in an exception-specification shall not denote a
   //   pointer or reference to an incomplete type, other than (cv) void* or a
   //   pointer or reference to a class currently being defined.
   // In Microsoft mode, downgrade this to a warning.
+  //
+  // This remains true with the sizeless type extension.  It would be
+  // possible to support throwing pointers to sizeless types, but it
+  // doesn't seem worthwhile.
   unsigned DiagID = diag::err_incomplete_in_exception_spec;
   bool ReturnValueOnError = true;
   if (getLangOpts().MicrosoftExt) {
     DiagID = diag::ext_incomplete_in_exception_spec;
     ReturnValueOnError = false;
   }
   if (!(PointeeT->isRecordType() &&
         PointeeT->getAs<RecordType>()->isBeingDefined()) &&

lib/Sema/SemaExpr.cpp

if (!CheckExtensionTraitOperandType(*this, ExprTy, E->getExprLoc(),
                                       E->getSourceRange(), ExprKind))
     return false;
 
   // 'alignof' applied to an expression only requires the base element type of
   // the expression to be complete. 'sizeof' requires the expression's type to
   // be complete (and will attempt to complete it if it's an array of unknown
   // bound).
   if (ExprKind == UETT_AlignOf) {
+    // "Complete" rather than "definite" because alignof cannot be
+    // applied to sizeless types.
     if (RequireCompleteType(E->getExprLoc(),
                             Context.getBaseElementType(E->getType()),
                             diag::err_sizeof_alignof_incomplete_type, ExprKind,
                             E->getSourceRange()))
       return true;
   } else {
     if (RequireCompleteExprType(E, diag::err_sizeof_alignof_incomplete_type,
                                 ExprKind, E->getSourceRange()))
bool Sema::CheckUnaryExprOrTypeTraitOperand(QualType ExprType,
   if (ExprKind == UETT_VecStep)
     return CheckVecStepTraitOperandType(*this, ExprType, OpLoc, ExprRange);
 
   // Whitelist some types as extensions
   if (!CheckExtensionTraitOperandType(*this, ExprType, OpLoc, ExprRange,
                                       ExprKind))
     return false;
 
+  // "Complete" rather than "definite" because alignof & co. cannot be applied
+  // to sizeless types.
   if (RequireCompleteType(OpLoc, ExprType,
                           diag::err_sizeof_alignof_incomplete_type,
                           ExprKind, ExprRange))
     return true;
 
   if (ExprType->isFunctionType()) {
     Diag(OpLoc, diag::err_sizeof_alignof_function_type)
       << ExprKind << ExprRange;
if (ResultType->isVoidType() && !getLangOpts().CPlusPlus) {
     // GNU extension: subscripting on pointer to void
     Diag(LLoc, diag::ext_gnu_subscript_void_type)
       << BaseExpr->getSourceRange();
 
     // C forbids expressions of unqualified void type from being l-values.
     // See IsCForbiddenLValueType.
     if (!ResultType.hasQualifiers()) VK = VK_RValue;
   } else if (!ResultType->isDependentType() &&
+      // "Complete" rather than "definite" because arrays of sizeless type
+      // and arithmetic on pointers to sizeless types are both invalid.
       RequireCompleteType(LLoc, ResultType,
                           diag::err_subscript_incomplete_type, BaseExpr))
     return ExprError();
 
   assert(VK == VK_RValue || LangOpts.CPlusPlus ||
          !ResultType.isCForbiddenLValueType());
 
   return new (Context)

 }
 
 ExprResult
 Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo,
                                SourceLocation RParenLoc, Expr *LiteralExpr) {
   QualType literalType = TInfo->getType();
 
   if (literalType->isArrayType()) {
+    // "Complete" rather than "definite" because arrays of sizeless types
+    // are not allowed.
     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()));

 static bool checkArithmeticIncompletePointerType(Sema &S, SourceLocation Loc,
                                                  Expr *Operand) {
   QualType ResType = Operand->getType();
   if (const AtomicType *ResAtomicType = ResType->getAs<AtomicType>())
     ResType = ResAtomicType->getValueType();
 
   assert(ResType->isAnyPointerType() && !ResType->isDependentType());
   QualType PointeeTy = ResType->getPointeeType();
+  // "Complete" rather than "definite" because arithmetic on pointers to
+  // sizeless types is not allowed.
   return S.RequireCompleteType(Loc, PointeeTy,
                                diag::err_typecheck_arithmetic_incomplete_type,
                                PointeeTy, Operand->getSourceRange());
 }
 
 /// \brief Check the validity of an arithmetic pointer operand.
 ///
 /// If the operand has pointer type, this code will check for pointer types
ExprResult Sema::BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
   // one is known to be a field designator.  Verify that the ArgTy represents
   // a struct/union/class.
   if (!Dependent && !ArgTy->isRecordType())
     return ExprError(Diag(BuiltinLoc, diag::err_offsetof_record_type) 
                        << ArgTy << TypeRange);
   
   // Type must be complete per C99 7.17p3 because a declaring a variable
   // with an incomplete type would be ill-formed.
+  //
+  // The condition remains completeness rather than definiteness with
+  // the sizeless type extension because offsetof cannot be applied to
+  // sizeless types.
   if (!Dependent 
       && RequireCompleteType(BuiltinLoc, ArgTy,
                              diag::err_offsetof_incomplete_type, TypeRange))
     return ExprError();
 
   bool DidWarnAboutNonPOD = false;
   QualType CurrentType = ArgTy;
   SmallVector<OffsetOfNode, 4> Comps;
if (CurrentType->isDependentType()) {
       // We have the offset of a field, but we can't look into the dependent
       // type. Just record the identifier of the field.
       Comps.push_back(OffsetOfNode(OC.LocStart, OC.U.IdentInfo, OC.LocEnd));
       CurrentType = Context.DependentTy;
       continue;
     }
     
     // We need to have a complete type to look into.
+    //
+    // The condition remains completeness rather than definiteness with
+    // the sizeless type extension because offsetof cannot be applied to
+    // sizeless types.
     if (RequireCompleteType(OC.LocStart, CurrentType,
                             diag::err_offsetof_incomplete_type))
       return ExprError();
     
     // Look for the designated field.
     const RecordType *RC = CurrentType->getAs<RecordType>();
     if (!RC) 
       return ExprError(Diag(OC.LocEnd, diag::err_offsetof_record_type)
if (CaptureType.getObjCLifetime() == Qualifiers::OCL_Autoreleasing) {
         S.Diag(Loc, diag::err_arc_autoreleasing_capture) << /*lambda*/ 1;
         S.Diag(Var->getLocation(), diag::note_previous_decl)
           << Var->getDeclName();
       }
       return false;
     }
 
     // Make sure that by-copy captures are of a complete and non-abstract type.
+    //
+    // The condition remains completeness rather than definiteness with
+    // the sizeless type extension because by-value capture of sizeless
+    // types would give a sizeless closure type.  (Capturing references
+    // to sizeless types is OK.)
     if (BuildAndDiagnose) {
       if (!CaptureType->isDependentType() &&
           S.RequireCompleteType(Loc, CaptureType,
                                 diag::err_capture_of_incomplete_type,
                                 Var->getDeclName()))
         return false;
 
       if (S.RequireNonAbstractType(Loc, CaptureType,

 }
 
 /// Check a cast of an unknown-any type.  We intentionally only
 /// trigger this for C-style casts.
 ExprResult Sema::checkUnknownAnyCast(SourceRange TypeRange, QualType CastType,
                                      Expr *CastExpr, CastKind &CastKind,
                                      ExprValueKind &VK, CXXCastPath &Path) {
   // The type we're casting to must be either void or complete.
+  //
+  // "Complete" rather than "definite" because there doesn't seem much
+  // point extending this to sizeless definite types.
   if (!CastType->isVoidType() &&
       RequireCompleteType(TypeRange.getBegin(), CastType,
                           diag::err_typecheck_cast_to_incomplete))
     return ExprError();
 
   // Rewrite the casted expression from scratch.
   ExprResult result = RebuildUnknownAnyExpr(*this, CastType).Visit(CastExpr);
   if (!result.isUsable()) return ExprError();

lib/Sema/SemaExprCXX.cpp

if (SS.isSet()) {
     //   If the unqualified-id is ~type-name, the type-name is looked up
     //   in the context of the entire postfix-expression. If the type T
     //   of the object expression is of a class type C, the type-name is
     //   also looked up in the scope of class C. At least one of the
     //   lookups shall find a name that refers to (possibly
     //   cv-qualified) T.
     LookupCtx = computeDeclContext(SearchType);
     isDependent = SearchType->isDependentType();
+    // "Complete" and "definite" are the same here, since we don't yet support
+    // sizeless structures.
     assert((isDependent || !SearchType->isIncompleteType()) &&
            "Caller should have completed object type");
 
     LookInScope = true;
   } else {
     // Perform lookup into the current scope (only).
     LookInScope = true;
   }
ExprResult Sema::BuildCXXTypeId(QualType TypeInfoType,
   //   that is the operand of typeid are always ignored.
   //   If the type of the type-id is a class type or a reference to a class
   //   type, the class shall be completely-defined.
   Qualifiers Quals;
   QualType T
     = Context.getUnqualifiedArrayType(Operand->getType().getNonReferenceType(),
                                       Quals);
   if (T->getAs<RecordType>() &&
+      // "Complete" and "definite" are the same here, since we don't yet
+      // support sizeless structures.
       RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
     return ExprError();
 
   if (T->isVariablyModifiedType())
     return ExprError(Diag(TypeidLoc, diag::err_variably_modified_typeid) << T);
 
   return new (Context) CXXTypeidExpr(TypeInfoType.withConst(), Operand,
                                      SourceRange(TypeidLoc, RParenLoc));
if (E && !E->isTypeDependent()) {
     }
 
     QualType T = E->getType();
     if (const RecordType *RecordT = T->getAs<RecordType>()) {
       CXXRecordDecl *RecordD = cast<CXXRecordDecl>(RecordT->getDecl());
       // C++ [expr.typeid]p3:
       //   [...] If the type of the expression is a class type, the class
       //   shall be completely-defined.
+      //
+      // "Complete" and "definite" are the same here, since we don't yet
+      // support sizeless structures.
       if (RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
         return ExprError();
 
       // C++ [expr.typeid]p3:
       //   When typeid is applied to an expression other than an glvalue of a
       //   polymorphic class type [...] [the] expression is an unevaluated
       //   operand. [...]
       if (RecordD->isPolymorphic() && E->isGLValue()) {
static void getUnambiguousPublicSubobjects(
   }
 }
 
 /// CheckCXXThrowOperand - Validate the operand of a throw.
 bool Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc,
                                 QualType ExceptionObjectTy, Expr *E) {
   //   If the type of the exception would be an incomplete type or a pointer
   //   to an incomplete type other than (cv) void the program is ill-formed.
+  //
+  // This remains true with the sizeless type extension.  It would be
+  // possible to support throwing pointers to sizeless types, but it
+  // doesn't seem worthwhile.
   QualType Ty = ExceptionObjectTy;
   bool isPointer = false;
   if (const PointerType* Ptr = Ty->getAs<PointerType>()) {
     Ty = Ptr->getPointeeType();
     isPointer = true;
   }
   if (!isPointer || !Ty->isVoidType()) {
     if (RequireCompleteType(ThrowLoc, Ty,

 }
 
 /// \brief Checks that a type is suitable as the allocated type
 /// in a new-expression.
 bool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc,
                               SourceRange R) {
   // C++ 5.3.4p1: "[The] type shall be a complete object type, but not an
   //   abstract class type or array thereof.
+  //
+  // The condition remains completeness rather than definiteness with
+  // the sizeless type extension; it isn't possible to use "new" with
+  // sizeless definite types.
   if (AllocType->isFunctionType())
     return Diag(Loc, diag::err_bad_new_type)
       << AllocType << 0 << R;
   else if (AllocType->isReferenceType())
     return Diag(Loc, diag::err_bad_new_type)
       << AllocType << 1 << R;
   else if (!AllocType->isDependentType() &&
            RequireCompleteType(Loc, AllocType, diag::err_new_incomplete_type,R))
if (Pointee->isVoidType() && !isSFINAEContext()) {
       // effectively bans deletion of "void*". However, most compilers support
       // this, so we treat it as a warning unless we're in a SFINAE context.
       Diag(StartLoc, diag::ext_delete_void_ptr_operand)
         << Type << Ex.get()->getSourceRange();
     } else if (Pointee->isFunctionType() || Pointee->isVoidType()) {
       return ExprError(Diag(StartLoc, diag::err_delete_operand)
         << Type << Ex.get()->getSourceRange());
     } else if (!Pointee->isDependentType()) {
+      // "Complete" rather than "definite" because it isn't possible to
+      // use "new" or "delete" with sizeless definite types.
+      //
       // FIXME: This can result in errors if the definition was imported from a
       // module but is hidden.
       if (!RequireCompleteType(StartLoc, Pointee,
                                diag::warn_delete_incomplete, Ex.get())) {
         if (const RecordType *RT = PointeeElem->getAs<RecordType>())
           PointeeRD = cast<CXXRecordDecl>(RT->getDecl());
       }
     }
if (PointeeRD) {
 
       CheckVirtualDtorCall(PointeeRD->getDestructor(), StartLoc,
                            /*IsDelete=*/true, /*CallCanBeVirtual=*/true,
                            /*WarnOnNonAbstractTypes=*/!ArrayForm,
                            SourceLocation());
     }
 
     if (!OperatorDelete) {
+      // "Complete" rather than "definite" because it isn't possible to
+      // use "new" or "delete" with sizeless definite types.  It also
+      // wouldn't make sense to use size forms for sizeless types.
       bool IsComplete = isCompleteType(StartLoc, Pointee);
       bool CanProvideSize =
           IsComplete && (!ArrayForm || UsualArrayDeleteWantsSize ||
                          Pointee.isDestructedType());
       bool Overaligned = hasNewExtendedAlignment(*this, Pointee);
 
       // Look for a global declaration.
       OperatorDelete = FindUsualDeallocationFunction(StartLoc, CanProvideSize,
static bool CheckUnaryTypeTraitTypeCompleteness(Sema &S, TypeTrait UTT,
 
   // C++14 [meta.unary.prop]:
   //   If T is a non-union class type, T shall be a complete type.
   case UTT_IsEmpty:
   case UTT_IsPolymorphic:
   case UTT_IsAbstract:
     if (const auto *RD = ArgTy->getAsCXXRecordDecl())
       if (!RD->isUnion())
+        // "Complete" and "definite" are the same here, since we don't yet
+        // support sizeless structures.
         return !S.RequireCompleteType(
             Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
     return true;
 
   // C++14 [meta.unary.prop]:
   //   If T is a class type, T shall be a complete type.
   case UTT_IsFinal:
   case UTT_IsSealed:
     if (ArgTy->getAsCXXRecordDecl())
+      // "Complete" and "definite" are the same here, since we don't yet
+      // support sizeless structures.
       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",
case BTT_IsBaseOf: {
 
     if (lhsRecord == rhsRecord)
       return !lhsRecord->getDecl()->isUnion();
 
     // C++0x [meta.rel]p2:
     //   If Base and Derived are class types and are different types
     //   (ignoring possible cv-qualifiers) then Derived shall be a
     //   complete type.
+    //
+    // "Complete" and "definite" are the same here, since we don't yet
+    // support sizeless structures.
     if (Self.RequireCompleteType(KeyLoc, RhsT,
                           diag::err_incomplete_type_used_in_type_trait_expr))
       return false;
 
     return cast<CXXRecordDecl>(rhsRecord->getDecl())
       ->isDerivedFrom(cast<CXXRecordDecl>(lhsRecord->getDecl()));
   }
   case BTT_IsSame:
else {
         << OpSpelling << 1 << LHSType
         << FixItHint::CreateReplacement(SourceRange(Loc), ".*");
       return QualType();
     }
   }
 
   if (!Context.hasSameUnqualifiedType(Class, LHSType)) {
     // If we want to check the hierarchy, we need a complete type.
+    //
+    // "Complete" and "definite" are the same here, since we don't yet
+    // support sizeless structures.
     if (RequireCompleteType(Loc, LHSType, diag::err_bad_memptr_lhs,
                             OpSpelling, (int)isIndirect)) {
       return QualType();
     }
 
     if (!IsDerivedFrom(Loc, LHSType, Class)) {
       Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling
         << (int)isIndirect << LHS.get()->getType();
ExprResult Sema::ActOnStartCXXMemberReference(Scope *S, Expr *Base,
 
   // The object type must be complete (or dependent), or
   // C++11 [expr.prim.general]p3:
   //   Unlike the object expression in other contexts, *this is not required to
   //   be of complete type for purposes of class member access (5.2.5) outside
   //   the member function body.
   if (!BaseType->isDependentType() &&
       !isThisOutsideMemberFunctionBody(BaseType) &&
+      // "Complete" and "definite" are the same here, since we don't yet
+      // support sizeless structures.
       RequireCompleteType(OpLoc, BaseType, diag::err_incomplete_member_access))
     return ExprError();
 
   // C++ [basic.lookup.classref]p2:
   //   If the id-expression in a class member access (5.2.5) is an
   //   unqualified-id, and the type of the object expression is of a class
   //   type C (or of pointer to a class type C), the unqualified-id is looked
   //   up in the scope of class C. [...]

lib/Sema/SemaExprMember.cpp

static bool LookupMemberExprInRecord(Sema &SemaRef, LookupResult &R,
                                      Expr *BaseExpr,
                                      const RecordType *RTy,
                                      SourceLocation OpLoc, bool IsArrow,
                                      CXXScopeSpec &SS, bool HasTemplateArgs,
                                      TypoExpr *&TE) {
   SourceRange BaseRange = BaseExpr ? BaseExpr->getSourceRange() : SourceRange();
   RecordDecl *RDecl = RTy->getDecl();
   if (!SemaRef.isThisOutsideMemberFunctionBody(QualType(RTy, 0)) &&
+      // "Complete" and "definite" are the same here, since we don't yet
+      // support sizeless structures.
       SemaRef.RequireCompleteType(OpLoc, QualType(RTy, 0),
                                   diag::err_typecheck_incomplete_tag,
                                   BaseRange))
     return true;
 
   if (HasTemplateArgs) {
     // LookupTemplateName doesn't expect these both to exist simultaneously.
     QualType ObjectType = SS.isSet() ? QualType() : QualType(RTy, 0);

lib/Sema/SemaInit.cpp

ResolveConstructorOverload(Sema &S, SourceLocation DeclLoc,
   // direct-initialization.
   //
   // Note: SecondStepOfCopyInit is only ever true in this case when
   // evaluating whether to produce a C++98 compatibility warning.
   if (S.getLangOpts().CPlusPlus17 && Args.size() == 1 &&
       !SecondStepOfCopyInit) {
     Expr *Initializer = Args[0];
     auto *SourceRD = Initializer->getType()->getAsCXXRecordDecl();
+    // "Complete" and "definite" are the same here, since we don't yet
+    // support sizeless structures.
     if (SourceRD && S.isCompleteType(DeclLoc, Initializer->getType())) {
       const auto &Conversions = SourceRD->getVisibleConversionFunctions();
       for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
         NamedDecl *D = *I;
         CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
         D = D->getUnderlyingDecl();
 
         FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
static OverloadingResult TryRefInitWithConversionFunction(
 
   // Determine whether we are allowed to call explicit constructors or
   // explicit conversion operators.
   bool AllowExplicit = Kind.AllowExplicit();
   bool AllowExplicitConvs = Kind.allowExplicitConversionFunctionsInRefBinding();
 
   const RecordType *T1RecordType = nullptr;
   if (AllowRValues && (T1RecordType = T1->getAs<RecordType>()) &&
+      // "Complete" and "definite" are the same here, since we don't yet
+      // support sizeless structures.
       S.isCompleteType(Kind.getLocation(), T1)) {
     // The type we're converting to is a class type. Enumerate its constructors
     // to see if there is a suitable conversion.
     CXXRecordDecl *T1RecordDecl = cast<CXXRecordDecl>(T1RecordType->getDecl());
 
     for (NamedDecl *D : S.LookupConstructors(T1RecordDecl)) {
       auto Info = getConstructorInfo(D);
       if (!Info.Constructor)
static void TryUserDefinedConversion(Sema &S,
 
   if (const RecordType *DestRecordType = DestType->getAs<RecordType>()) {
     // The type we're converting to is a class type. Enumerate its constructors
     // to see if there is a suitable conversion.
     CXXRecordDecl *DestRecordDecl
       = cast<CXXRecordDecl>(DestRecordType->getDecl());
 
     // Try to complete the type we're converting to.
+    //
+    // "Complete" and "definite" are the same here, since we don't yet support
+    // sizeless structures.
     if (S.isCompleteType(Kind.getLocation(), DestType)) {
       for (NamedDecl *D : S.LookupConstructors(DestRecordDecl)) {
         auto Info = getConstructorInfo(D);
         if (!Info.Constructor)
           continue;
 
         if (!Info.Constructor->isInvalidDecl() &&
             Info.Constructor->isConvertingConstructor(AllowExplicit)) {
static void TryUserDefinedConversion(Sema &S,
   SourceLocation DeclLoc = Initializer->getLocStart();
 
   if (const RecordType *SourceRecordType = SourceType->getAs<RecordType>()) {
     // The type we're converting from is a class type, enumerate its conversion
     // functions.
 
     // We can only enumerate the conversion functions for a complete type; if
     // the type isn't complete, simply skip this step.
+    //
+    // "Complete" and "definite" are the same here, since we don't yet support
+    // sizeless structures.
     if (S.isCompleteType(DeclLoc, SourceType)) {
       CXXRecordDecl *SourceRecordDecl
         = cast<CXXRecordDecl>(SourceRecordType->getDecl());
 
       const auto &Conversions =
           SourceRecordDecl->getVisibleConversionFunctions();
       for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
         NamedDecl *D = *I;
static ExprResult CopyObject(Sema &S,
   if (const RecordType *Record = T->getAs<RecordType>())
     Class = cast<CXXRecordDecl>(Record->getDecl());
   if (!Class)
     return CurInit;
 
   SourceLocation Loc = getInitializationLoc(Entity, CurInit.get());
 
   // Make sure that the type we are copying is complete.
+  //
+  // "Complete" and "definite" are the same here, since we don't yet support
+  // sizeless structures.
   if (S.RequireCompleteType(Loc, T, diag::err_temp_copy_incomplete))
     return CurInit;
 
   // Perform overload resolution using the class's constructors. Per
   // C++11 [dcl.init]p16, second bullet for class types, this initialization
   // is direct-initialization.
   OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
   DeclContext::lookup_result Ctors = S.LookupConstructors(Class);
case OR_Ambiguous:
     // list why they were not viable when given the initializer list itself as
     // an argument.
     Candidates.NoteCandidates(*this, OCD_ViableCandidates, Inits);
     return QualType();
 
   case OR_No_Viable_Function: {
     CXXRecordDecl *Primary =
         cast<ClassTemplateDecl>(Template)->getTemplatedDecl();
+    // "Complete" and "definite" are the same here, since we don't yet support
+    // sizeless structures.
     bool Complete =
         isCompleteType(Kind.getLocation(), Context.getTypeDeclType(Primary));
     Diag(Kind.getLocation(),
          Complete ? diag::err_deduced_class_template_ctor_no_viable
                   : diag::err_deduced_class_template_incomplete)
       << TemplateName << !Guides.empty();
     Candidates.NoteCandidates(*this, OCD_AllCandidates, Inits);
     return QualType();

lib/Sema/SemaLookup.cpp

for (unsigned I = DMin, N = DTD->getTemplateParameters()->size();
         return true;
     }
   }
 
   // VarDecl can have incomplete array types, prefer the one with more complete
   // array type.
   if (VarDecl *DVD = dyn_cast<VarDecl>(DUnderlying)) {
     VarDecl *EVD = cast<VarDecl>(EUnderlying);
+    // "Complete" and "definite" are the same here, since the code is only
+    // intended to handle arrays, which are never sizeless.
     if (EVD->getType()->isIncompleteType() &&
         !DVD->getType()->isIncompleteType()) {
       // Prefer the decl with a more complete type if visible.
       return S.isVisible(DVD);
     }
     return false; // Avoid picking up a newer decl, just because it was newer.
   }
 
if (ClassTemplateSpecializationDecl *Spec
     CollectEnclosingNamespace(Result.Namespaces, Ctx);
 
     const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
     for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
       addAssociatedClassesAndNamespaces(Result, TemplateArgs[I]);
   }
 
   // Only recurse into base classes for complete types.
+  //
+  // "Complete" and "definite" are the same here, since we don't yet
+  // support sizeless structures.
   if (!Result.S.isCompleteType(Result.InstantiationLoc,
                                Result.S.Context.getRecordType(Class)))
     return;
 
   // Add direct and indirect base classes along with their associated
   // namespaces.
   SmallVector<CXXRecordDecl *, 32> Bases;
   Bases.push_back(Class);

lib/Sema/SemaOverload.cpp

if (const EnumType *FromEnumType = FromType->getAs<EnumType>()) {
     // the bitfield-ness of the actual source expression.
     if (FromEnumType->getDecl()->isFixed()) {
       QualType Underlying = FromEnumType->getDecl()->getIntegerType();
       return Context.hasSameUnqualifiedType(Underlying, ToType) ||
              IsIntegralPromotion(nullptr, Underlying, ToType);
     }
 
     // We have already pre-calculated the promotion type, so this is trivial.
+    //
+    // "Complete" and "definite" are the same here, since there's no concept
+    // of a sizeless enum.
     if (ToType->isIntegerType() &&
         isCompleteType(From->getLocStart(), FromType))
       return Context.hasSameUnqualifiedType(
           ToType, FromEnumType->getDecl()->getPromotionType());
   }
 
   // C++0x [conv.prom]p2:
   //   A prvalue of type char16_t, char32_t, or wchar_t (3.9.1) can be converted
if (const RecordType *ToRecordType = ToType->getAs<RecordType>()) {
     //   functions are all the converting constructors (12.3.1) of
     //   that class. The argument list is the expression-list within
     //   the parentheses of the initializer.
     if (S.Context.hasSameUnqualifiedType(ToType, From->getType()) ||
         (From->getType()->getAs<RecordType>() &&
          S.IsDerivedFrom(From->getLocStart(), From->getType(), ToType)))
       ConstructorsOnly = true;
 
+    // "Complete" and "definite" are the same here, since we don't yet support
+    // sizeless structures.
     if (!S.isCompleteType(From->getExprLoc(), ToType)) {
       // We're not going to find any constructors.
     } else if (CXXRecordDecl *ToRecordDecl
                  = dyn_cast<CXXRecordDecl>(ToRecordType->getDecl())) {
 
       Expr **Args = &From;
       unsigned NumArgs = 1;
       bool ListInitializing = false;
if (!S.isCompleteType(From->getExprLoc(), ToType)) {
                                    CandidateSet, SuppressUserConversions);
         }
       }
     }
   }
 
   // Enumerate conversion functions, if we're allowed to.
   if (ConstructorsOnly || isa<InitListExpr>(From)) {
+  // "Complete" and "definite" are the same here, since we don't yet support
+  // sizeless structures.
   } else if (!S.isCompleteType(From->getLocStart(), From->getType())) {
     // No conversion functions from incomplete types.
   } else if (const RecordType *FromRecordType
                                    = From->getType()->getAs<RecordType>()) {
     if (CXXRecordDecl *FromRecordDecl
          = dyn_cast<CXXRecordDecl>(FromRecordType->getDecl())) {
       // Add all of the conversion functions as candidates.
       const auto &Conversions = FromRecordDecl->getVisibleConversionFunctions();
Sema::CompareReferenceRelationship(SourceLocation Loc,
   //   reference-related to "cv2 T2" if T1 is the same type as T2, or
   //   T1 is a base class of T2.
   DerivedToBase = false;
   ObjCConversion = false;
   ObjCLifetimeConversion = false;
   QualType ConvertedT2;
   if (UnqualT1 == UnqualT2) {
     // Nothing to do.
+  // "Complete" and "definite" are the same here, since there is no derivation
+  // based on sizeless types.
   } else if (isCompleteType(Loc, OrigT2) &&
              isTypeValid(UnqualT1) && isTypeValid(UnqualT2) &&
              IsDerivedFrom(Loc, UnqualT2, UnqualT1))
     DerivedToBase = true;
   else if (UnqualT1->isObjCObjectOrInterfaceType() &&
            UnqualT2->isObjCObjectOrInterfaceType() &&
            Context.canBindObjCObjectType(UnqualT1, UnqualT2))
     ObjCConversion = true;
if (!isRValRef) {
 
     //       -- has a class type (i.e., T2 is a class type), where T1 is
     //          not reference-related to T2, and can be implicitly
     //          converted to an lvalue of type "cv3 T3," where "cv1 T1"
     //          is reference-compatible with "cv3 T3" 92) (this
     //          conversion is selected by enumerating the applicable
     //          conversion functions (13.3.1.6) and choosing the best
     //          one through overload resolution (13.3)),
+    //
+    // "Complete" and "definite" are the same here, since we don't yet support
+    // sizeless structures.
     if (!SuppressUserConversions && T2->isRecordType() &&
         S.isCompleteType(DeclLoc, T2) &&
         RefRelationship == Sema::Ref_Incompatible) {
       if (FindConversionForRefInit(S, ICS, DeclType, DeclLoc,
                                    Init, T2, /*AllowRvalues=*/false,
                                    AllowExplicit))
         return ICS;
     }
TryReferenceInit(Sema &S, Expr *Init, QualType DeclType,
   //               an xvalue, class prvalue, or function lvalue of type
   //               "cv3 T3", where "cv1 T1" is reference-compatible with
   //               "cv3 T3",
   //
   //          then the reference is bound to the value of the initializer
   //          expression in the first case and to the result of the conversion
   //          in the second case (or, in either case, to an appropriate base
   //          class subobject).
+  //
+  // "Complete" and "definite" are the same here, since we don't yet support
+  // sizeless structures.
   if (!SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible &&
       T2->isRecordType() && S.isCompleteType(DeclLoc, T2) &&
       FindConversionForRefInit(S, ICS, DeclType, DeclLoc,
                                Init, T2, /*AllowRvalues=*/true,
                                AllowExplicit)) {
     // In the second case, if the reference is an rvalue reference
     // and the second standard conversion sequence of the
     // user-defined conversion sequence includes an lvalue-to-rvalue
struct TypeDiagnoserPartialDiag : TypeDiagnoser {
     TypeDiagnoserPartialDiag(ContextualImplicitConverter &Converter, Expr *From)
         : Converter(Converter), From(From) {}
 
     void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
       Converter.diagnoseIncomplete(S, Loc, T) << From->getSourceRange();
     }
   } IncompleteDiagnoser(Converter, From);
 
+  // "Complete" and "definite" are the same here, since we don't yet support
+  // sizeless structures.
   if (Converter.Suppress ? !isCompleteType(Loc, T)
                          : RequireCompleteType(Loc, T, IncompleteDiagnoser))
     return From;
 
   // Look for a conversion to an integral or enumeration type.
   UnresolvedSet<4>
       ViableConversions; // These are *potentially* viable in C++1y.
   UnresolvedSet<4> ExplicitConversions;
void Sema::AddMemberOperatorCandidates(OverloadedOperatorKind Op,
   QualType T1 = Args[0]->getType();
 
   //     -- If T1 is a complete class type or a class currently being
   //        defined, the set of member candidates is the result of the
   //        qualified lookup of T1::operator@ (13.3.1.1.1); otherwise,
   //        the set of member candidates is empty.
   if (const RecordType *T1Rec = T1->getAs<RecordType>()) {
     // Complete the type if it can be completed.
+    //
+    // "Complete" and "definite" are the same here, since we don't yet
+    // support sizeless structures.
     if (!isCompleteType(OpLoc, T1) && !T1Rec->isBeingDefined())
       return;
     // If the type is neither complete nor being defined, bail out now.
     if (!T1Rec->getDecl()->getDefinition())
       return;
 
     LookupResult Operators(*this, OpName, OpLoc, LookupOrdinaryName);
     LookupQualifiedName(Operators, T1Rec->getDecl());
else if (Ty->getAs<PointerType>() || Ty->getAs<ObjCObjectPointerType>()) {
     // We treat vector types as arithmetic types in many contexts as an
     // extension.
     HasArithmeticOrEnumeralTypes = true;
     VectorTypes.insert(Ty);
   } else if (Ty->isNullPtrType()) {
     HasNullPtrType = true;
   } else if (AllowUserConversions && TyRec) {
     // No conversion functions in incomplete types.
+    //
+    // "Complete" and "definite" are the same here, since we don't yet support
+    // sizeless structures.
     if (!SemaRef.isCompleteType(Loc, Ty))
       return;
 
     CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl());
     for (NamedDecl *D : ClassDecl->getVisibleConversionFunctions()) {
       if (isa<UsingShadowDecl>(D))
         D = cast<UsingShadowDecl>(D)->getTargetDecl();
 
static void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand,
   }
 
   // Diagnose base -> derived pointer conversions.
   unsigned BaseToDerivedConversion = 0;
   if (const PointerType *FromPtrTy = FromTy->getAs<PointerType>()) {
     if (const PointerType *ToPtrTy = ToTy->getAs<PointerType>()) {
       if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
                                                FromPtrTy->getPointeeType()) &&
+          // "Complete" and "definite" are the same here, since there is
+          // no derivation based on sizeless types.
           !FromPtrTy->getPointeeType()->isIncompleteType() &&
           !ToPtrTy->getPointeeType()->isIncompleteType() &&
           S.IsDerivedFrom(SourceLocation(), ToPtrTy->getPointeeType(),
                           FromPtrTy->getPointeeType()))
         BaseToDerivedConversion = 1;
     }
   } else if (const ObjCObjectPointerType *FromPtrTy
                                     = FromTy->getAs<ObjCObjectPointerType>()) {
     if (const ObjCObjectPointerType *ToPtrTy
                                         = ToTy->getAs<ObjCObjectPointerType>())
       if (const ObjCInterfaceDecl *FromIface = FromPtrTy->getInterfaceDecl())
         if (const ObjCInterfaceDecl *ToIface = ToPtrTy->getInterfaceDecl())
           if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
                                                 FromPtrTy->getPointeeType()) &&
               FromIface->isSuperClassOf(ToIface))
             BaseToDerivedConversion = 2;
   } else if (const ReferenceType *ToRefTy = ToTy->getAs<ReferenceType>()) {
     if (ToRefTy->getPointeeType().isAtLeastAsQualifiedAs(FromTy) &&
+        // "Complete" and "definite" are the same here, since there is
+        // no derivation based on sizeless types.
         !FromTy->isIncompleteType() &&
         !ToRefTy->getPointeeType()->isIncompleteType() &&
         S.IsDerivedFrom(SourceLocation(), ToRefTy->getPointeeType(), FromTy)) {
       BaseToDerivedConversion = 3;
     } else if (ToTy->isLValueReferenceType() && !FromExpr->isLValue() &&
                ToTy.getNonReferenceType().getCanonicalType() ==
                FromTy.getNonReferenceType().getCanonicalType()) {
       S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_lvalue)
case OR_No_Viable_Function: {
       // operator do not fall through to handling in built-in, but report that
       // no overloaded assignment operator found
       ExprResult Result = ExprError();
       if (Args[0]->getType()->isRecordType() &&
           Opc >= BO_Assign && Opc <= BO_OrAssign) {
         Diag(OpLoc,  diag::err_ovl_no_viable_oper)
              << BinaryOperator::getOpcodeStr(Opc)
              << Args[0]->getSourceRange() << Args[1]->getSourceRange();
+        // "Complete" and "definite" are the same here, since we don't
+        // yet support sizeless structures.
         if (Args[0]->getType()->isIncompleteType()) {
           Diag(OpLoc, diag::note_assign_lhs_incomplete)
             << Args[0]->getType()
             << Args[0]->getSourceRange() << Args[1]->getSourceRange();
         }
       } else {
         // This is an erroneous use of an operator which can be overloaded by
         // a non-member function. Check for non-member operators which were
Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj,
   //  candidate functions includes at least the function call
   //  operators of T. The function call operators of T are obtained by
   //  ordinary lookup of the name operator() in the context of
   //  (E).operator().
   OverloadCandidateSet CandidateSet(LParenLoc,
                                     OverloadCandidateSet::CSK_Operator);
   DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(OO_Call);
 
+  // "Complete" and "definite" are the same here, since we don't yet support
+  // sizeless structures.
   if (RequireCompleteType(LParenLoc, Object.get()->getType(),
                           diag::err_incomplete_object_call, Object.get()))
     return true;
 
   LookupResult R(*this, OpName, LParenLoc, LookupOrdinaryName);
   LookupQualifiedName(R, Record->getDecl());
   R.suppressDiagnostics();
 
Sema::BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc,
   //   for a class object x of type T if T::operator->() exists and if
   //   the operator is selected as the best match function by the
   //   overload resolution mechanism (13.3).
   DeclarationName OpName =
     Context.DeclarationNames.getCXXOperatorName(OO_Arrow);
   OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Operator);
   const RecordType *BaseRecord = Base->getType()->getAs<RecordType>();
 
+  // "Complete" and "definite" are the same here, since we don't yet support
+  // sizeless structures.
   if (RequireCompleteType(Loc, Base->getType(),
                           diag::err_typecheck_incomplete_tag, Base))
     return ExprError();
 
   LookupResult R(*this, OpName, OpLoc, LookupOrdinaryName);
   LookupQualifiedName(R, BaseRecord->getDecl());
   R.suppressDiagnostics();
 

lib/Sema/SemaPseudoObject.cpp

Sema::ObjCSubscriptKind
   // If we don't have a class type in C++, there's no way we can get an
   // expression of integral or enumeration type.
   const RecordType *RecordTy = T->getAs<RecordType>();
   if (!RecordTy &&
       (T->isObjCObjectPointerType() || T->isVoidPointerType()))
     // All other scalar cases are assumed to be dictionary indexing which
     // caller handles, with diagnostics if needed.
     return OS_Dictionary;
+  // "Complete" and "definite" are the same here, since we don't yet
+  // support sizeless structures.
   if (!getLangOpts().CPlusPlus || 
       !RecordTy || RecordTy->isIncompleteType()) {
     // No indexing can be done. Issue diagnostics and quit.
     const Expr *IndexExpr = FromE->IgnoreParenImpCasts();
     if (isa<StringLiteral>(IndexExpr))
       Diag(FromE->getExprLoc(), diag::err_objc_subscript_pointer)
         << T << FixItHint::CreateInsertion(FromE->getExprLoc(), "@");
     else
       Diag(FromE->getExprLoc(), diag::err_objc_subscript_type_conversion)
         << T;
     return OS_Error;
   }
   
   // We must have a complete class type.
+  //
+  // "Complete" and "definite" are the same here, since we don't yet
+  // support sizeless structures.
   if (RequireCompleteType(FromE->getExprLoc(), T, 
                           diag::err_objc_index_incomplete_class_type, FromE))
     return OS_Error;
   
   // Look for a conversion to an integral, enumeration type, or
   // objective-C pointer type.
   int NoIntegrals=0, NoObjCIdPointers=0;
   SmallVector<CXXConversionDecl *, 4> ConversionDecls;

lib/Sema/SemaStmt.cpp

if (EndRangeRef.isInvalid())
       return StmtError();
 
     QualType AutoType = Context.getAutoDeductType();
     Expr *Range = RangeVar->getInit();
     if (!Range)
       return StmtError();
     QualType RangeType = Range->getType();
 
+    // "Complete" is the same as "definite" since we don't yet support
+    // sizeless structures, and since sizeless built-in types cannot
+    // be used in ranges.
     if (RequireCompleteType(RangeLoc, RangeType,
                             diag::err_for_range_incomplete_type))
       return StmtError();
 
     // Build auto __begin = begin-expr, __end = end-expr.
     // Divide by 2, since the variables are in the inner scope (loop body).
     const auto DepthStr = std::to_string(S->getDepth() / 2);
     VarDecl *BeginVar = BuildForRangeVarDecl(*this, ColonLoc, AutoType,

lib/Sema/SemaStmtAsm.cpp

else if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(FoundDecl)) {
       RT = QT->getAs<RecordType>();
     } else if (TypeDecl *TD = dyn_cast<TypeDecl>(FoundDecl))
       RT = TD->getTypeForDecl()->getAs<RecordType>();
     else if (FieldDecl *TD = dyn_cast<FieldDecl>(FoundDecl))
       RT = TD->getType()->getAs<RecordType>();
     if (!RT)
       return true;
 
+    // "Complete" and "definite" are the same here, since we don't yet
+    // support sizeless structures.
     if (RequireCompleteType(AsmLoc, QualType(RT, 0),
                             diag::err_asm_incomplete_type))
       return true;
 
     LookupResult FieldResult(*this, &Context.Idents.get(NextMember),
                              SourceLocation(), LookupMemberName);
 
     if (!LookupQualifiedName(FieldResult, RT->getDecl()))

lib/Sema/SemaTemplate.cpp

void Sema::LookupTemplateName(LookupResult &Found,
   DeclContext *LookupCtx = nullptr;
   bool isDependent = false;
   if (!ObjectType.isNull()) {
     // This nested-name-specifier occurs in a member access expression, e.g.,
     // x->B::f, and we are looking into the type of the object.
     assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist");
     LookupCtx = computeDeclContext(ObjectType);
     isDependent = ObjectType->isDependentType();
+    // "Complete" and "definite" are the same here, since we don't support
+    // sizeless structures.
     assert((isDependent || !ObjectType->isIncompleteType() ||
             ObjectType->castAs<TagType>()->isBeingDefined()) &&
            "Caller should have completed object type");
 
     // Template names cannot appear inside an Objective-C class or object type.
     if (ObjectType->isObjCObjectOrInterfaceType()) {
       Found.clear();
       return;

 void Sema::DeclareImplicitDeductionGuides(TemplateDecl *Template,
                                           SourceLocation Loc) {
   DeclContext *DC = Template->getDeclContext();
   if (DC->isDependentContext())
     return;
 
   ConvertConstructorToDeductionGuideTransform Transform(
       *this, cast<ClassTemplateDecl>(Template));
+  // "Complete" and "definite" are the same here, since DeducedType is a
+  // class template and we don't support sizeless structures.
   if (!isCompleteType(Loc, Transform.DeducedType))
     return;
 
   // Check whether we've already declared deduction guides for this template.
   // FIXME: Consider storing a flag on the template to indicate this.
   auto Existing = DC->lookup(Transform.DeductionGuideName);
   for (auto *D : Existing)
     if (D->isImplicit())
isNullPointerValueTemplateArgument(Sema &S, NonTypeTemplateParmDecl *Param,
   if (Arg->isValueDependent() || Arg->isTypeDependent())
     return NPV_NotNullPointer;
 
   // dllimport'd entities aren't constant but are available inside of template
   // arguments.
   if (Entity && Entity->hasAttr<DLLImportAttr>())
     return NPV_NotNullPointer;
 
+  // No need to handle sizeless types here; the type is already known to be
+  // some form of pointer.
   if (!S.isCompleteType(Arg->getExprLoc(), ParamType))
     llvm_unreachable(
         "Incomplete parameter type in isNullPointerValueTemplateArgument!");
 
   if (!S.getLangOpts().CPlusPlus11)
     return NPV_NotNullPointer;
 
   // Determine whether we have a constant expression.
static bool isEnableIf(NestedNameSpecifierLoc NNS, const IdentifierInfo &II,
   TypeLoc EnableIfTy = NNS.getTypeLoc();
   TemplateSpecializationTypeLoc EnableIfTSTLoc =
       EnableIfTy.getAs<TemplateSpecializationTypeLoc>();
   if (!EnableIfTSTLoc || EnableIfTSTLoc.getNumArgs() == 0)
     return false;
   const TemplateSpecializationType *EnableIfTST = EnableIfTSTLoc.getTypePtr();
 
   // ... which names a complete class template declaration...
+  //
+  // "Complete" and "definite" are the same here, since std::enable_if
+  // is always sized rather than sizeless.
   const TemplateDecl *EnableIfDecl =
     EnableIfTST->getTemplateName().getAsTemplateDecl();
   if (!EnableIfDecl || EnableIfTST->isIncompleteType())
     return false;
 
   // ... called "enable_if".
   const IdentifierInfo *EnableIfII =
     EnableIfDecl->getDeclName().getAsIdentifierInfo();

lib/Sema/SemaTemplateDeduction.cpp

case Type::TemplateSpecialization: {
           S, TemplateParams, SpecParam, Arg, Info, Deduced);
 
       if (Result == Sema::TDK_Success)
         return Result;
 
       // We cannot inspect base classes as part of deduction when the type
       // is incomplete, so either instantiate any templates necessary to
       // complete the type, or skip over it if it cannot be completed.
+      //
+      // "Complete" and "definite" are the same here, since no sizeless
+      // types have base classes.
       if (!S.isCompleteType(Info.getLocation(), Arg))
         return Result;
 
       // C++14 [temp.deduct.call] p4b3:
       //   If P is a class and P has the form simple-template-id, then the
       //   transformed A can be a derived class of the deduced A. Likewise if
       //   P is a pointer to a class of the form simple-template-id, the
       //   transformed A can be a pointer to a derived class pointed to by the

lib/Sema/SemaTemplateInstantiateDecl.cpp

if (ParentDC != D->getDeclContext()) {
     if (CXXRecordDecl *Spec = dyn_cast<CXXRecordDecl>(ParentDC)) {
       if (!Spec->isDependentContext()) {
         QualType T = Context.getTypeDeclType(Spec);
         const RecordType *Tag = T->getAs<RecordType>();
         assert(Tag && "type of non-dependent record is not a RecordType");
         if (Tag->isBeingDefined())
           IsBeingInstantiated = true;
         if (!Tag->isBeingDefined() &&
+            // "Complete" and "definite" are the same here, since we
+            // don't yet support sizeless structures.
             RequireCompleteType(Loc, T, diag::err_incomplete_type))
           return nullptr;
 
         ParentDC = Tag->getDecl();
       }
     }
 
     NamedDecl *Result = nullptr;

lib/Sema/SemaType.cpp

if (getLangOpts().CPlusPlus) {
     if (Context.getTargetInfo().getCXXABI().isMicrosoft())
       if (const MemberPointerType *MPTy = T->getAs<MemberPointerType>())
         if (!MPTy->getClass()->isDependentType())
           (void)isCompleteType(Loc, T);
 
   } else {
     // C99 6.7.5.2p1: If the element type is an incomplete or function type,
     // reject it (e.g. void ary[7], struct foo ary[7], void ary[7]())
+    //
+    // This remains true with the sizeless type extension; arrays of
+    // sizeless types are not allowed.
     if (RequireCompleteType(Loc, T,
                             diag::err_illegal_decl_array_incomplete_type))
       return QualType();
   }
 
   if (T->isFunctionType()) {
     Diag(Loc, diag::err_illegal_decl_array_of_functions)
       << getPrintableNameForEntity(Entity) << T;
QualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
   llvm::APSInt ConstVal(Context.getTypeSize(Context.getSizeType()));
   if (!ArraySize) {
     if (ASM == ArrayType::Star)
       T = Context.getVariableArrayType(T, nullptr, ASM, Quals, Brackets);
     else
       T = Context.getIncompleteArrayType(T, ASM, Quals);
   } else if (ArraySize->isTypeDependent() || ArraySize->isValueDependent()) {
     T = Context.getDependentSizedArrayType(T, ArraySize, ASM, Quals, Brackets);
+  // "Complete" and "definite" are equivalent at this point, since we
+  // rejected sizeless T above.
   } else if ((!T->isDependentType() && !T->isIncompleteType() &&
               !T->isConstantSizeType()) ||
              isArraySizeVLA(*this, ArraySize, ConstVal)) {
     // Even in C++11, don't allow contextual conversions in the array bound
     // of a VLA.
     if (getLangOpts().CPlusPlus11 &&
         !ArraySize->getType()->isIntegralOrUnscopedEnumerationType()) {
       Diag(ArraySize->getLocStart(), diag::err_array_size_non_int)
if (ConstVal == 0) {
         << ArraySize->getSourceRange();
 
       if (ASM == ArrayType::Static) {
         Diag(ArraySize->getLocStart(),
              diag::warn_typecheck_zero_static_array_size)
           << ArraySize->getSourceRange();
         ASM = ArrayType::Normal;
       }
+    // "Complete" and "definite" are equivalent at this point, since we
+    // rejected sizeless T above.
     } else if (!T->isDependentType() && !T->isVariablyModifiedType() &&
                !T->isIncompleteType() && !T->isUndeducedType()) {
       // Is the array too large?
       unsigned ActiveSizeBits
         = ConstantArrayType::getNumAddressingBits(Context, T, ConstVal);
       if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) {
         Diag(ArraySize->getLocStart(), diag::err_array_too_large)
           << ConstVal.toString(10)

 ///
 /// @returns @c true if @p T is not a literal type and a diagnostic was emitted,
 /// @c false otherwise.
 bool Sema::RequireLiteralType(SourceLocation Loc, QualType T,
                               TypeDiagnoser &Diagnoser) {
   assert(!T->isDependentType() && "type should not be dependent");
 
   QualType ElemType = Context.getBaseElementType(T);
+  // "Complete" is equivalent to "definite" here, since sizeless types are
+  // not (at present) treated as literal types.
   if ((isCompleteType(Loc, ElemType) || ElemType->isVoidType()) &&
       T->isLiteralType(Context))
     return false;
 
   Diagnoser.diagnose(*this, Loc, T);
 
   if (T->isVariableArrayType())
     return true;
 
   const RecordType *RT = ElemType->getAs<RecordType>();
   if (!RT)
     return true;
 
   const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
 
   // A partially-defined class type can't be a literal type, because a literal
   // class type must have a trivial destructor (which can't be checked until
   // the class definition is complete).
+  //
+  // As above, the condition is completeness rather than definiteness since
+  // sizeless types are not treated as literal types.
   if (RequireCompleteType(Loc, ElemType, diag::note_non_literal_incomplete, T))
     return true;
 
   // If the class has virtual base classes, then it's not an aggregate, and
   // cannot have any constexpr constructors or a trivial default constructor,
   // so is non-literal. This is better to diagnose than the resulting absence
   // of constexpr constructors.
   if (RD->getNumVBases()) {
if (!BaseType->isDependentType() && !BaseType->isEnumeralType()) {
                                         UnaryTransformType::EnumUnderlyingType);
     }
   }
   llvm_unreachable("unknown unary transform type");
 }
 
 QualType Sema::BuildAtomicType(QualType T, SourceLocation Loc) {
   if (!T->isDependentType()) {
-    // FIXME: It isn't entirely clear whether incomplete atomic types
+    // "Complete" rather than "definite" because atomic sizeless types
+    // are not allowed.
+    //
+    // FIXME: It isn't entirely clear whether other incomplete atomic types
     // are allowed or not; for simplicity, ban them for the moment.
     if (RequireCompleteType(Loc, T, diag::err_atomic_specifier_bad_type, 0))
       return QualType();
 
     int DisallowedKind = -1;
     if (T->isArrayType())
       DisallowedKind = 1;
     else if (T->isFunctionType())