[Sema][SVE] Flip default RequireCompleteType behavior for sizeless types

[rsandifo-arm]

Summary

Sizeless types are defined to be a form of incomplete type, but with
more relaxed rules in certain cases. Previous patches in the series
took the following approach:

• Add tests for things that are explicitly supposed to be valid for sizeless types and that clang already handled correctly.

• Add diagnostics for things that are explicitly supposed to be invalid for sizeless types, in many cases inheriting the same rules as for incomplete types.

For any other cases, we should conservatively treat sizeless types as
in the same way as incomplete types. This patch therefore flips the
default behavior for RequireCompleteType and co. Callers that want
to accept sizeless types must then explicitly pass AcceptSizeless.

The Sema::BuildObjCEncodeExpression change is needed to keep
clang/test/CodeGenObjC/aarch64-sve-types.m passing. If @encoding a
sizeless type will never be useful, we could enforce that here instead.

For reference, here's a list of every other function that now passes
AcceptSizeless, along with one example line from Sema/sizeless-1.c
or SemaCXX/sizeless-1.cpp that would regress without the change.

• CastOperation::CheckCStyleCast
  
  local_int8 = (svint8_t)0; // expected-error {{...arithmetic or pointer type is required...}}

• Sema::CheckParmsForFunctionDef
  
  int vararg_receiver(int count, svint8_t first, ...) {

• Sema::AddInitializerToDecl
  
  svint8_t init_int8 = local_int8;

• Sema::ActOnInitializerError
  
  svint8_t bad_init_int8 = for; // expected-error {{expected expression}}

• Sema::ActOnUninitializedDecl
  
  svint8_t local_int8;

• Sema::ActOnStartOfFunctionDef
  
  svint8_t ret_bad_conv() { return explicit_conv(); }

• Sema::SetParamDefaultArgument
  
  void with_default(svint8_t = svint8_t());

• Sema::BuildExceptionDeclaration
  
  } catch (svint8_t) { // expected-error {{...sizeless type...}}

• Sema::CheckSpecifiedExceptionType
  
  void throwing_func() throw(svint8_t); // expected-error {{...sizeless...}}

• Sema::DefaultVariadicArgumentPromotion
  
  varargs(1, local_int8, local_int16);

• Sema::GatherArgumentsForCall
  
  pass_int8(local_int8);

• Sema::BuildResolvedCallExpr
  
  noproto(local_int8);

• CheckCommaOperands
  
  0, local_int8;

• Sema::BuildVAArgExpr
  
  __builtin_va_arg(va, svint8_t);

• Sema::CheckCXXThrowOperand
  
  throw local_int8; // expected-error {{...sizeless type...}}

• Sema::BuildCXXTypeConstructExpr
  
  void with_default(svint8_t = svint8_t());

• CheckUnaryTypeTraitTypeCompleteness
  
  _Static_assert(__is_trivially_destructible(svint8_t), "");

• evaluateTypeTrait
  
  _Static_assert(__is_constructible(svint8_t), "");

• EvaluateBinaryTypeTrait
  
  _Static_assert(is_convertible_to(svint8_t, svint8_t), ""); _Static_assert(!is_assignable(svint8_t, svint8_t), "");

• Sema::IgnoredValueConversions
  
  (void)local_int8;

• CopyObject
  
  widget w(1);

• InitializationSequence::Diagnose
  
  svint8_t ret_bad_conv() { return explicit_conv(); }

• Sema::buildLambdaScope
  
  local_int8 = ([]() { return svint8_t(); })();

• TryListConversion
  
  template_fn_direct<svint8_t>({wrapper<svint8_t>()});

• Sema::AddConversionCandidate
  
  local_int8 = wrapper<svint8_t>();

• Sema::BuildCXXForRangeStmt
  
  for (auto x : local_int8) {

• Sema::BuildAtomicType
  
  _Atomic svint8_t atomic_int8; // expected-error {{...sizeless...}}

clang/include/clang/Sema/Sema.h

public:
 
   enum class CompleteTypeKind {
     /// Apply the normal rules for complete types.  In particular,
     /// treat all sizeless types as incomplete.
     Normal,
 
     /// Relax the normal rules for complete types so that they include
     /// sizeless built-in types.
-    AcceptSizeless,
-
-    // FIXME: Eventually we should flip the default to Normal and opt in
-    // to AcceptSizeless rather than opt out of it.
-    Default = AcceptSizeless
+    AcceptSizeless
   };
 
 private:
   /// Methods for marking which expressions involve dereferencing a pointer
   /// marked with the 'noderef' attribute. Expressions are checked bottom up as
   /// they are parsed, meaning that a noderef pointer may not be accessed. For
   /// example, in `&*p` where `p` is a noderef pointer, we will first parse the
   /// `*p`, but need to check that `address of` is called on it. This requires
bool isEquivalentInternalLinkageDeclaration(const NamedDecl *A,
                                               const NamedDecl *B);
   void diagnoseEquivalentInternalLinkageDeclarations(
       SourceLocation Loc, const NamedDecl *D,
       ArrayRef<const NamedDecl *> Equiv);
 
   bool isUsualDeallocationFunction(const CXXMethodDecl *FD);
 
   bool isCompleteType(SourceLocation Loc, QualType T,
-                      CompleteTypeKind Kind = CompleteTypeKind::Default) {
+                      CompleteTypeKind Kind = CompleteTypeKind::Normal) {
     return !RequireCompleteTypeImpl(Loc, T, Kind, nullptr);
   }
   bool RequireCompleteType(SourceLocation Loc, QualType T,
                            CompleteTypeKind Kind, TypeDiagnoser &Diagnoser);
   bool RequireCompleteType(SourceLocation Loc, QualType T,
                            CompleteTypeKind Kind, unsigned DiagID);
 
   bool RequireCompleteType(SourceLocation Loc, QualType T,
                            TypeDiagnoser &Diagnoser) {
-    return RequireCompleteType(Loc, T, CompleteTypeKind::Default, Diagnoser);
+    return RequireCompleteType(Loc, T, CompleteTypeKind::Normal, Diagnoser);
   }
   bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned DiagID) {
-    return RequireCompleteType(Loc, T, CompleteTypeKind::Default, DiagID);
+    return RequireCompleteType(Loc, T, CompleteTypeKind::Normal, 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);
   }
+  template <typename... Ts>
+  bool RequireCompleteType(SourceLocation Loc, QualType T,
+                           CompleteTypeKind Kind, unsigned DiagID,
+                           const Ts &... Args) {
+    BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
+    return RequireCompleteType(Loc, T, Kind, Diagnoser);
+  }
 
   template <typename... Ts>
   bool RequireCompleteSizedType(SourceLocation Loc, QualType T, unsigned DiagID,
                                 const Ts &... Args) {
     SizelessTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
     return RequireCompleteType(Loc, T, CompleteTypeKind::Normal, Diagnoser);
   }
 
   void completeExprArrayBound(Expr *E);
   bool RequireCompleteExprType(Expr *E, CompleteTypeKind Kind,
                                TypeDiagnoser &Diagnoser);
   bool RequireCompleteExprType(Expr *E, unsigned DiagID);
 
   template <typename... Ts>
+  bool RequireCompleteExprType(Expr *E, CompleteTypeKind Kind, unsigned DiagID,
+                               const Ts &... Args) {
+    BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
+    return RequireCompleteExprType(E, Kind, Diagnoser);
+  }
+  template <typename... Ts>
   bool RequireCompleteExprType(Expr *E, unsigned DiagID, const Ts &...Args) {
     BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
-    return RequireCompleteExprType(E, CompleteTypeKind::Default, Diagnoser);
+    return RequireCompleteExprType(E, CompleteTypeKind::Normal, Diagnoser);
   }
 
   template <typename... Ts>
   bool RequireCompleteSizedExprType(Expr *E, unsigned DiagID,
                                     const Ts &... Args) {
     SizelessTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
     return RequireCompleteExprType(E, CompleteTypeKind::Normal, Diagnoser);
   }

clang/lib/Sema/SemaCast.cpp

void CastOperation::CheckCStyleCast() {
   QualType SrcType = SrcExpr.get()->getType();
 
   assert(!SrcType->isPlaceholderType());
 
   checkAddressSpaceCast(SrcType, DestType);
   if (SrcExpr.isInvalid())
     return;
 
+  // Being sizeless doesn't in itself prevent casting, so diagnose invalid
+  // cases below instead.
   if (Self.RequireCompleteType(OpRange.getBegin(), DestType,
+                               Sema::CompleteTypeKind::AcceptSizeless,
                                diag::err_typecheck_cast_to_incomplete)) {
     SrcExpr = ExprError();
     return;
   }
 
   if (!DestType->isScalarType() && !DestType->isVectorType()) {
     const RecordType *DestRecordTy = DestType->getAs<RecordType>();
 

clang/lib/Sema/SemaChecking.cpp

bool Sema::CheckParmsForFunctionDef(ArrayRef<ParmVarDecl *> Parameters,
   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.
     //
     // This is also C++ [dcl.fct]p6.
     if (!Param->isInvalidDecl() &&
         RequireCompleteType(Param->getLocation(), Param->getType(),
+                            // Function parameters can have sizeless type.
+                            CompleteTypeKind::AcceptSizeless,
                             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 &&

clang/lib/Sema/SemaDecl.cpp

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,
+                            // Local variables can have sizeless type.
+                            // We diagnose invalid sizeless decls later.
+                            CompleteTypeKind::AcceptSizeless,
                             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,
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),
+  if (RequireCompleteType(VD->getLocation(), Context.getBaseElementType(Ty),
+                          // Sizeless variables can be initialized,
+                          // so sizelessness itself isn't the problem.
+                          CompleteTypeKind::AcceptSizeless,
                           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,
if (Type->isDependentType())
       return;
 
     if (Var->isInvalidDecl())
       return;
 
     if (!Var->hasAttr<AliasAttr>()) {
       if (RequireCompleteType(Var->getLocation(),
                               Context.getBaseElementType(Type),
+                              // Local variables can have sizeless type.
+                              // We diagnose invalid sizeless decls later.
+                              CompleteTypeKind::AcceptSizeless,
                               diag::err_typecheck_decl_incomplete_type)) {
         Var->setInvalidDecl();
         return;
       }
     } else {
       return;
     }
 
Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D,
   }
 
   // The return type of a function definition must be complete
   // (C99 6.9.1p3, C++ [dcl.fct]p6).
   QualType ResultType = FD->getReturnType();
   if (!ResultType->isDependentType() && !ResultType->isVoidType() &&
       !FD->isInvalidDecl() &&
       RequireCompleteType(FD->getLocation(), ResultType,
+                          // Functions can return sizeless types by value.
+                          CompleteTypeKind::AcceptSizeless,
                           diag::err_func_def_incomplete_result))
     FD->setInvalidDecl();
 
   if (FnBodyScope)
     PushDeclContext(FnBodyScope, FD);
 
   // Check the validity of our function parameters
   CheckParmsForFunctionDef(FD->parameters(),

clang/lib/Sema/SemaDeclCXX.cpp

void Sema::ImplicitExceptionSpecification::CalledStmt(Stmt *S) {
   if (Self->canThrow(S))
     ComputedEST = EST_None;
 }
 
 bool
 Sema::SetParamDefaultArgument(ParmVarDecl *Param, Expr *Arg,
                               SourceLocation EqualLoc) {
   if (RequireCompleteType(Param->getLocation(), Param->getType(),
+                          // Parameters can have sizeless type.
+                          CompleteTypeKind::AcceptSizeless,
                           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
if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
     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;
   }
   if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
-      !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK))
+      !BaseType->isDependentType() &&
+      // See below for the handling of sizeless types.
+      RequireCompleteType(Loc, BaseType, CompleteTypeKind::AcceptSizeless, DK))
     Invalid = true;
 
   if (!Invalid && Mode != 1 && BaseType->isSizelessType()) {
     Diag(Loc, diag::err_catch_sizeless) << (Mode == 2 ? 1 : 0) << BaseType;
     Invalid = true;
   }
 
   if (!Invalid && !ExDeclType->isDependentType() &&

clang/lib/Sema/SemaExceptionSpec.cpp

bool Sema::CheckSpecifiedExceptionType(QualType &T, SourceRange Range) {
   unsigned DiagID = diag::err_incomplete_in_exception_spec;
   bool ReturnValueOnError = true;
   if (getLangOpts().MSVCCompat) {
     DiagID = diag::ext_incomplete_in_exception_spec;
     ReturnValueOnError = false;
   }
   if (!(PointeeT->isRecordType() &&
         PointeeT->castAs<RecordType>()->isBeingDefined()) &&
-      RequireCompleteType(Range.getBegin(), PointeeT, DiagID, Kind, Range))
+      RequireCompleteType(Range.getBegin(), PointeeT,
+                          // See below for the handling of sizeless types.
+                          CompleteTypeKind::AcceptSizeless, DiagID, Kind,
+                          Range))
     return ReturnValueOnError;
 
   // The MSVC compatibility mode doesn't extend to sizeless types,
   // so diagnose them separately.
   if (PointeeT->isSizelessType() && Kind != 1) {
     Diag(Range.getBegin(), diag::err_sizeless_in_exception_spec)
         << (Kind == 2 ? 1 : 0) << PointeeT << Range;
     return true;

clang/lib/Sema/SemaExpr.cpp

ExprResult Comma =
         ActOnBinOp(TUScope, E->getBeginLoc(), tok::comma, Call.get(), E);
     if (Comma.isInvalid())
       return ExprError();
     return Comma.get();
   }
 
   if (!getLangOpts().CPlusPlus &&
       RequireCompleteType(E->getExprLoc(), E->getType(),
+                          // Function arguments can have sizeless type.
+                          CompleteTypeKind::AcceptSizeless,
                           diag::err_call_incomplete_argument))
     return ExprError();
 
   return E;
 }
 
 /// Converts an integer to complex float type.  Helper function of
 /// UsualArithmeticConversions()
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->getBeginLoc(), ProtoArgType,
+                              // Function arguments can have sizeless type.
+                              CompleteTypeKind::AcceptSizeless,
                               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++) {
 
         if (ArgE.isInvalid())
           return true;
 
         Arg = ArgE.getAs<Expr>();
       }
 
       if (RequireCompleteType(Arg->getBeginLoc(), Arg->getType(),
+                              // Function arguments can have sizeless type.
+                              CompleteTypeKind::AcceptSizeless,
                               diag::err_call_incomplete_argument, Arg))
         return ExprError();
 
       TheCall->setArg(i, Arg);
     }
   }
 
   if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
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(),
+                            // Expressions of sizeless type are allowed
+                            // on either side of ",".
+                            Sema::CompleteTypeKind::AcceptSizeless,
                             diag::err_incomplete_type);
   }
 
   if (!S.getDiagnostics().isIgnored(diag::warn_comma_operator, Loc))
     S.DiagnoseCommaOperator(LHS.get(), Loc);
 
   return RHS.get()->getType();
 }
if (!IsMS && !E->isTypeDependent() &&
       !Context.hasSameType(VaListType, E->getType()))
     return ExprError(
         Diag(E->getBeginLoc(),
              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(),
+                            // Function arguments can have sizeless type and
+                            // sizelessness doesn't prevent them from being
+                            // passed through "...".
+                            CompleteTypeKind::AcceptSizeless,
                             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()))

clang/lib/Sema/SemaExprCXX.cpp

bool Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc,
   //   to an incomplete type other than (cv) void the program is ill-formed.
   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,
+    // See below for the handling of sizeless types.
+    if (RequireCompleteType(ThrowLoc, Ty, CompleteTypeKind::AcceptSizeless,
                             isPointer ? diag::err_throw_incomplete_ptr
                                       : diag::err_throw_incomplete,
                             E->getSourceRange()))
       return true;
 
     if (!isPointer && Ty->isSizelessType()) {
       Diag(ThrowLoc, diag::err_throw_sizeless) << Ty << E->getSourceRange();
       return true;
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.
   if (!Ty->isVoidType() &&
       RequireCompleteType(TyBeginLoc, ElemTy,
+                          // Local sizeless objects can be initialized in the
+                          // normal way.
+                          CompleteTypeKind::AcceptSizeless,
                           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_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);
+        Loc, ArgTy, Sema::CompleteTypeKind::AcceptSizeless,
+        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 clang::TT_IsTriviallyConstructible: {
     // Precondition: T and all types in the parameter pack Args shall be
     // complete types, (possibly cv-qualified) void, or arrays of
     // unknown bound.
     for (const auto *TSI : Args) {
       QualType ArgTy = TSI->getType();
       if (ArgTy->isVoidType() || ArgTy->isIncompleteArrayType())
         continue;
 
-      if (S.RequireCompleteType(KWLoc, ArgTy,
+      if (S.RequireCompleteType(
+              KWLoc, ArgTy, Sema::CompleteTypeKind::AcceptSizeless,
               diag::err_incomplete_type_used_in_type_trait_expr))
         return false;
     }
 
     // Make sure the first argument is not incomplete nor a function type.
     QualType T = Args[0]->getType();
     if (T->isIncompleteType() || T->isFunctionType())
       return false;
 
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))
+    if (!Self.isCompleteType(KeyLoc, RhsT,
+                             Sema::CompleteTypeKind::AcceptSizeless) ||
+        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 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.
     if (!LhsT->isVoidType() && !LhsT->isIncompleteArrayType() &&
-        Self.RequireCompleteType(KeyLoc, LhsT,
+        Self.RequireCompleteType(
+            KeyLoc, LhsT, Sema::CompleteTypeKind::AcceptSizeless,
             diag::err_incomplete_type_used_in_type_trait_expr))
       return false;
     if (!RhsT->isVoidType() && !RhsT->isIncompleteArrayType() &&
-        Self.RequireCompleteType(KeyLoc, RhsT,
+        Self.RequireCompleteType(
+            KeyLoc, RhsT, Sema::CompleteTypeKind::AcceptSizeless,
             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
     // declval<U>().
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(),
+                        // Ignored results can have sizeless type.
+                        CompleteTypeKind::AcceptSizeless,
                         diag::err_incomplete_type);
   return E;
 }
 
 ExprResult Sema::CheckUnevaluatedOperand(Expr *E) {
   // Per C++2a [expr.ass]p5, a volatile assignment is not deprecated if
   // it occurs as an unevaluated operand.
   CheckUnusedVolatileAssignment(E);

clang/lib/Sema/SemaExprObjC.cpp

ExprResult Sema::BuildObjCEncodeExpression(SourceLocation AtLoc,
                                       SourceLocation RParenLoc) {
   QualType EncodedType = EncodedTypeInfo->getType();
   QualType StrTy;
   if (EncodedType->isDependentType())
     StrTy = Context.DependentTy;
   else {
     if (!EncodedType->getAsArrayTypeUnsafe() && //// Incomplete array is handled.
         !EncodedType->isVoidType()) // void is handled too.
+      // Leave later messages to complain about sizeless types that
+      // can't be @encoded.  Sizelessness itself doesn't really prevent
+      // the use of @encode.
       if (RequireCompleteType(AtLoc, EncodedType,
+                              CompleteTypeKind::AcceptSizeless,
                               diag::err_incomplete_type_objc_at_encode,
                               EncodedTypeInfo->getTypeLoc()))
         return ExprError();
 
     std::string Str;
     QualType NotEncodedT;
     Context.getObjCEncodingForType(EncodedType, Str, nullptr, &NotEncodedT);
     if (!NotEncodedT.isNull())

clang/lib/Sema/SemaInit.cpp

if (IsExtraneousCopy) {
     // 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(),
+                                // Function arguments can have sizeless type.
+                                Sema::CompleteTypeKind::AcceptSizeless,
                                 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);
     }
case OR_Ambiguous:
                   : (S.PDiag(diag::err_ref_init_ambiguous)
                      << DestType << OnlyArg->getType()
                      << Args[0]->getSourceRange())),
           S, OCD_AmbiguousCandidates, Args);
       break;
 
     case OR_No_Viable_Function: {
       auto Cands = FailedCandidateSet.CompleteCandidates(S, OCD_AllCandidates, Args);
-      if (!S.RequireCompleteType(Kind.getLocation(),
-                                 DestType.getNonReferenceType(),
-                          diag::err_typecheck_nonviable_condition_incomplete,
-                               OnlyArg->getType(), Args[0]->getSourceRange()))
+      // Sizeless objects can be initialized, so sizelessness itself
+      // isn't the problem.  Prefer the more detailed diagnostic below.
+      if (!S.RequireCompleteType(
+              Kind.getLocation(), DestType.getNonReferenceType(),
+              Sema::CompleteTypeKind::AcceptSizeless,
         S.Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition)
           << (Entity.getKind() == InitializedEntity::EK_Result)
           << OnlyArg->getType() << Args[0]->getSourceRange()
           << DestType.getNonReferenceType();
 
       FailedCandidateSet.NoteCandidates(S, Args, Cands);
       break;
     }

clang/lib/Sema/SemaLambda.cpp

void Sema::buildLambdaScope(LambdaScopeInfo *LSI,
   LSI->Mutable = Mutable;
 
   if (ExplicitResultType) {
     LSI->ReturnType = CallOperator->getReturnType();
 
     if (!LSI->ReturnType->isDependentType() &&
         !LSI->ReturnType->isVoidType()) {
       if (RequireCompleteType(CallOperator->getBeginLoc(), LSI->ReturnType,
+                              // Lambdas can return sizeless types.
+                              CompleteTypeKind::AcceptSizeless,
                               diag::err_lambda_incomplete_result)) {
         // Do nothing.
       }
     }
   } else {
     LSI->HasImplicitReturnType = true;
   }
 }

clang/lib/Sema/SemaOverload.cpp

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
-  // initialized from init lists.
-  if (!S.isCompleteType(From->getBeginLoc(), ToType))
+  // We need a completely-defined (but possibly sizeless) type for what
+  // follows. Incompletely-defined types can never be initialized from
+  // init lists.
+  if (!S.isCompleteType(From->getBeginLoc(), ToType,
+                        Sema::CompleteTypeKind::AcceptSizeless))
     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.
   //
void Sema::AddConversionCandidate(
   DeclRefExpr ConversionRef(Context, Conversion, false, Conversion->getType(),
                             VK_LValue, From->getBeginLoc());
   ImplicitCastExpr ConversionFn(ImplicitCastExpr::OnStack,
                                 Context.getPointerType(Conversion->getType()),
                                 CK_FunctionToPointerDecay,
                                 &ConversionRef, VK_RValue);
 
   QualType ConversionType = Conversion->getConversionType();
-  if (!isCompleteType(From->getBeginLoc(), ConversionType)) {
+  if (!isCompleteType(From->getBeginLoc(), ConversionType,
+                      CompleteTypeKind::AcceptSizeless)) {
     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

clang/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();
 
+    // For sizeless types it's better to report the same "no viable
+    // 'begin' function" diagnostic as we would for scalars.
     if (RequireCompleteType(RangeLoc, RangeType,
+                            CompleteTypeKind::AcceptSizeless,
                             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,
                                              std::string("__begin") + DepthStr);

clang/lib/Sema/SemaType.cpp

bool Sema::RequireCompleteExprType(Expr *E, CompleteTypeKind Kind,
   // FIXME: Are there other cases which require instantiating something other
   // than the type to complete the type of an expression?
 
   return RequireCompleteType(E->getExprLoc(), T, Kind, Diagnoser);
 }
 
 bool Sema::RequireCompleteExprType(Expr *E, unsigned DiagID) {
   BoundTypeDiagnoser<> Diagnoser(DiagID);
-  return RequireCompleteExprType(E, CompleteTypeKind::Default, Diagnoser);
+  return RequireCompleteExprType(E, CompleteTypeKind::Normal, Diagnoser);
 }
 
 /// Ensure that the type T is a complete 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
QualType Sema::BuildUnaryTransformType(QualType BaseType,
   }
   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
     // are allowed or not; for simplicity, ban them for the moment.
-    if (RequireCompleteType(Loc, T, diag::err_atomic_specifier_bad_type, 0))
+    //
+    // Fall through to the code below for sizeless types.
+    if (RequireCompleteType(Loc, T, CompleteTypeKind::AcceptSizeless,
+                            diag::err_atomic_specifier_bad_type, 0))
       return QualType();
 
     int DisallowedKind = -1;
     if (T->isArrayType())
       DisallowedKind = 1;
     else if (T->isFunctionType())
       DisallowedKind = 2;
     else if (T->isReferenceType())