[HLSL] support unbounded global resource array.

[python3kgae]

Summary

unbounded resource array is allowed in HLSL.
Here is an example.

RWBuffer<float> B[];
float main(uint ID : BufID) : SV_Target {

  return B[ID][0];
}

Type::isHLSLResourceType is added to check HLSLResource.
HLSLResourceAttr is added on the forward decl so it is ready when check incomplete array type.

clang/include/clang/AST/Type.h

public:
   /// Whether the type is Objective-C 'Class' or a __kindof type of an
   /// Class type, e.g., __kindof Class <NSCopying>.
   ///
   /// Unlike \c isObjCIdOrObjectKindOfType, there is no relevant bound
   /// here because Objective-C's type system cannot express "a class
   /// object for a subclass of NSFoo".
   bool isObjCClassOrClassKindOfType() const;
 
+  ///  Whether the type is HLSL SRV/UAV/ConstantBuffer/Sampler type.
+  bool isHLSLResourceType() const;
+
   bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const;
   bool isObjCSelType() const;                 // Class
   bool isObjCBuiltinType() const;               // 'id' or 'Class'
   bool isObjCARCBridgableType() const;
   bool isCARCBridgableType() const;
   bool isTemplateTypeParmType() const;          // C++ template type parameter
   bool isNullPtrType() const;                   // C++11 std::nullptr_t or
                                                 // C2x nullptr_t

clang/lib/AST/Type.cpp

 }
 
 bool Type::isObjCBoxableRecordType() const {
   if (const auto *RT = getAs<RecordType>())
     return RT->getDecl()->hasAttr<ObjCBoxableAttr>();
   return false;
 }
 
+bool Type::isHLSLResourceType() const {
+  if (const auto *RT = getAs<RecordType>()) {
+    if (const auto *D =
+            llvm::dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl())) {
+      if (D->isCompleteDefinition())
+        return D->hasAttr<HLSLResourceAttr>();
+      ClassTemplateDecl *CTD = D->getSpecializedTemplate();
+      return CTD->getTemplatedDecl()->hasAttr<HLSLResourceAttr>();
+    }
+  }
+  return false;
+}
+
 bool Type::isInterfaceType() const {
   if (const auto *RT = getAs<RecordType>())
     return RT->getDecl()->isInterface();
   return false;
 }
 
 bool Type::isStructureOrClassType() const {
   if (const auto *RT = getAs<RecordType>()) {

clang/lib/Sema/HLSLExternalSemaSource.cpp

 }
 
 void HLSLExternalSemaSource::forwardDeclareHLSLTypes() {
   CXXRecordDecl *Decl;
   Decl = BuiltinTypeDeclBuilder(*SemaPtr, HLSLNamespace, "RWBuffer")
              .addTemplateArgumentList()
              .addTypeParameter("element_type", SemaPtr->getASTContext().FloatTy)
              .finalizeTemplateArgs()
+             .annotateResourceClass(HLSLResourceAttr::UAV,
+                                    HLSLResourceAttr::TypedBuffer)
              .Record;
   if (!Decl->isCompleteDefinition())
     Completions.insert(
         std::make_pair(Decl->getCanonicalDecl(),
                        std::bind(&HLSLExternalSemaSource::completeBufferType,
                                  this, std::placeholders::_1)));
 }
 
void HLSLExternalSemaSource::CompleteType(TagDecl *Tag) {
   It->second(Record);
 }
 
 void HLSLExternalSemaSource::completeBufferType(CXXRecordDecl *Record) {
   BuiltinTypeDeclBuilder(Record)
       .addHandleMember()
       .addDefaultHandleConstructor(*SemaPtr, ResourceClass::UAV)
       .addArraySubscriptOperators()
-      .annotateResourceClass(HLSLResourceAttr::UAV,
-                             HLSLResourceAttr::TypedBuffer)
       .completeDefinition();
 }

clang/lib/Sema/SemaDecl.cpp

case VarDecl::TentativeDefinition:
       // Record the tentative definition; we're done.
       if (!Var->isInvalidDecl())
         TentativeDefinitions.push_back(Var);
       return;
     }
 
     // Provide a specific diagnostic for uninitialized variable
     // definitions with incomplete array type.
-    if (Type->isIncompleteArrayType()) {
+    if (Type->isIncompleteArrayType() &&
+        !(getLangOpts().HLSL && Var->hasExternalFormalLinkage() &&
+          Type->getArrayElementTypeNoTypeQual()->isHLSLResourceType())) {
       if (Var->isConstexpr())
         Diag(Var->getLocation(), diag::err_constexpr_var_requires_const_init)
             << Var;
       else
         Diag(Var->getLocation(),
              diag::err_typecheck_incomplete_array_needs_initializer);
       Var->setInvalidDecl();
       return;
if (getLangOpts().CPlusPlus && Var->hasLocalStorage()) {
           setFunctionHasBranchProtectedScope();
       }
     }
     // In OpenCL, we can't initialize objects in the __local address space,
     // even implicitly, so don't synthesize an implicit initializer.
     if (getLangOpts().OpenCL &&
         Var->getType().getAddressSpace() == LangAS::opencl_local)
       return;
+
+    // In HLSL, global resource array is allowed to be incomplete.
+    // Skip initializing incomplate array here.
+    if (getLangOpts().HLSL && Var->getType()->isIncompleteArrayType())
+      return;
+
     // C++03 [dcl.init]p9:
     //   If no initializer is specified for an object, and the
     //   object is of (possibly cv-qualified) non-POD class type (or
     //   array thereof), the object shall be default-initialized; if
     //   the object is of const-qualified type, the underlying class
     //   type shall have a user-declared default
     //   constructor. Otherwise, if no initializer is specified for
     //   a non- static object, the object and its subobjects, if

clang/test/AST/HLSL/unbounded_global_resource_array.hlsl

+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.0-library -x hlsl -fsyntax-only -ast-dump %s | FileCheck %s
+
+
+// CHECK:VarDecl 0x{{[0-9a-f]+}} <{{.*}}:7:1, col:19> col:17 B 'RWBuffer<float>[]'
+// Make sure no CXXConstructExpr created for unbounded resource array.
+// CHECK-NOT:CXXConstructExpr
+RWBuffer<float> B[];

clang/test/SemaHLSL/unbounded_global_resource_array.hlsl

+// RUN: %clang_cc1 -finclude-default-header -x hlsl -triple dxil--shadermodel6.7-library  %s  -verify
+
+// expected-error@+1 {{definition of variable with array type needs an explicit size or an initializer}}
+static RWBuffer<float> A[];
+// expected-error@+1 {{definition of variable with array type needs an explicit size or an initializer}}
+float F[];
+
+// Make sure extern global resource unbounded array compiles.
+RWBuffer<float> B[];