Disallow built-in internal types to be inferred by auto

tools/clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -8070,6 +8070,9 @@ def err_hlsl_auto_descriptor_heap : Error<
   "'auto' cannot deduce the type of '%select{ResourceDescriptorHeap|SamplerDescriptorHeap}0'; "
   "use a specific resource or sampler type instead">;
 
+def err_hlsl_auto_undeducible_type : Error<
+  "'auto' cannot deduce type %0">;
+
 // HLSL Change Ends
 
 // SPIRV Change Starts

tools/clang/include/clang/Sema/SemaHLSL.h

@@ -93,6 +93,10 @@ bool DiagnoseTypeElements(clang::Sema &S, clang::SourceLocation Loc,
                           TypeDiagContext LongVecDiagContext,
                           const clang::FieldDecl *FD = nullptr);
 
+// Returns true if 'auto' is allowed to deduce the given type. Container types
+// are deducible only when the type they wrap is deducible.
+bool IsTypeDeducibleWithAuto(clang::Sema &S, clang::QualType Ty);
+
 void DiagnoseControlFlowConditionForHLSL(clang::Sema *self,
                                          clang::Expr *condExpr,
                                          llvm::StringRef StmtName);

tools/clang/lib/Sema/SemaDecl.cpp

@@ -9051,6 +9051,16 @@ void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init,
         VDecl->setInvalidDecl();
         return;
       }
+
+      // A dependent deduced type cannot be classified yet; defer the check to
+      // instantiation, when 'auto' is re-deduced to a concrete type.
+      if (!DeducedType->isDependentType() &&
+          !hlsl::IsTypeDeducibleWithAuto(*this, DeducedType)) {
+        Diag(VDecl->getLocation(), diag::err_hlsl_auto_undeducible_type)
+            << DeducedType;
+        VDecl->setInvalidDecl();
+        return;
+      }
     }
 
     VDecl->setType(DeducedType);

tools/clang/lib/Sema/SemaHLSL.cpp

@@ -4773,6 +4773,45 @@ class HLSLExternalSource : public ExternalSemaSource {
     return type;
   }
 
+  bool IsTypeDeducibleWithAuto(QualType type) {
+    if (type.isNull())
+      return false;
+
+    switch (GetTypeObjectKind(type)) {
+    // Types with no concrete, nameable form for 'auto' to bind to.
+    case AR_TOBJ_INVALID:
+    case AR_TOBJ_VOID:
+    case AR_TOBJ_INNER_OBJ:
+    case AR_TOBJ_DEPENDENT:
+      return false;
+
+    // Fully-formed types that 'auto' can deduce directly.
+    case AR_TOBJ_OBJECT:
+    case AR_TOBJ_BASIC:
+    case AR_TOBJ_COMPOUND:
+    case AR_TOBJ_INTERFACE:
+    case AR_TOBJ_STRING:
+    case AR_TOBJ_LINALG_MATRIX:
+      return true;
+
+    // Container types: deducible iff their wrapped type is deducible.
+    case AR_TOBJ_MATRIX:
+    case AR_TOBJ_VECTOR:
+      return IsTypeDeducibleWithAuto(GetMatrixOrVectorElementType(type));
+    case AR_TOBJ_ARRAY: {
+      const ArrayType *arrayType =
+          GetStructuralForm(type)->getAsArrayTypeUnsafe();
+      return IsTypeDeducibleWithAuto(arrayType->getElementType());
+    }
+    case AR_TOBJ_POINTER:
+      return IsTypeDeducibleWithAuto(GetStructuralForm(type)->getPointeeType());
+    case AR_TOBJ_QUALIFIER:
+      return IsTypeDeducibleWithAuto(
+          GetStructuralForm(type).getUnqualifiedType());
+    }
+    return false;
+  }
+
   /// <summary>Given a Clang type, return the ArBasicKind classification for its
   /// contents.</summary>
   ArBasicKind GetTypeElementKind(QualType type) {
@@ -12787,6 +12826,10 @@ bool hlsl::DiagnoseTypeElements(Sema &S, SourceLocation Loc, QualType Ty,
                               LongVecDiagContext, CheckedDecls, FD);
 }
 
+bool hlsl::IsTypeDeducibleWithAuto(Sema &S, QualType Ty) {
+  return HLSLExternalSource::FromSema(&S)->IsTypeDeducibleWithAuto(Ty);
+}
+
 bool hlsl::DiagnoseNodeStructArgument(Sema *self, TemplateArgumentLoc ArgLoc,
                                       QualType ArgTy, bool &Empty,
                                       const FieldDecl *FD) {

tools/clang/test/HLSLFileCheckLit/hlsl/auto/auto-deducible-types.hlsl

@@ -0,0 +1,37 @@
+// RUN: %dxc -T cs_6_0 -HV 202x -verify %s
+// expected-no-diagnostics
+
+struct MyStruct {
+    float a;
+    int b;
+};
+
+Texture2D<float4> tex : register(t0);
+SamplerState samp : register(s0);
+RWBuffer<float> output : register(u0);
+
+[numthreads(1,1,1)]
+void main() {
+    // AR_TOBJ_BASIC
+    auto i = 5;
+    auto f = 1.5f;
+    auto b = true;
+
+    // AR_TOBJ_VECTOR -> element AR_TOBJ_BASIC
+    auto v = float4(1, 2, 3, 4);
+
+    // AR_TOBJ_MATRIX -> element AR_TOBJ_BASIC
+    float2x2 matInit = { 1, 2, 3, 4 };
+    auto m = matInit;
+
+    // AR_TOBJ_COMPOUND
+    MyStruct s = { 1.0f, 2 };
+    auto sCopy = s;
+
+    // AR_TOBJ_OBJECT: resource handles are copyable, so binding one is allowed.
+    auto t = tex;
+
+    // Use every value to prevent dead-code elimination.
+    output[0] = (float)i + f + (float)b + v.x + m._11 + sCopy.a +
+                (float)sCopy.b + t.SampleLevel(samp, float2(0, 0), 0).x;
+}

tools/clang/test/HLSLFileCheckLit/hlsl/auto/auto-undeducible-types.hlsl

@@ -0,0 +1,29 @@
+// RUN: %dxc -T cs_6_0 -HV 202x -verify %s
+
+
+void voidFunc() {}
+
+Texture2D<float4> tex : register(t0);
+Texture2DMS<float4> texMS : register(t1);
+
+[numthreads(1,1,1)]
+void main() {
+    int y = 1;
+
+    // AR_TOBJ_VOID: a void-returning call has no value type.
+    // expected-error@+1 {{'auto' cannot deduce type 'void'}}
+    auto x = voidFunc();
+
+    // AR_TOBJ_VOID: an explicit cast to void is equally non-deducible.
+    // expected-error@+1 {{'auto' cannot deduce type 'void'}}
+    auto v = (void)y;
+
+    // AR_TOBJ_INNER_OBJ: .mips is an inner indexer object (Texture2D::mips_type).
+    // expected-error@+1 {{'auto' cannot deduce type}}
+    auto m = tex.mips;
+
+    // AR_TOBJ_INNER_OBJ: .sample is an inner indexer object
+    // (Texture2DMS::sample_type).
+    // expected-error@+1 {{'auto' cannot deduce type}}
+    auto s = texMS.sample;
+}