Move pointer/reference rejection to Sema (#8436)

This is a refactoring to move the rejection of pointer and reference
types into Sema rather than rejecting it during parsing. This has a few
consequences and benefits.

The consequence as seen in the changes to the cpp-errors tests are that
we don't see pointer use errors in cases where a parser error prevents
sema code from executing (as seen in operator cases).

The benefit is that this also intercepts pointer and reference types
that are deduced (via templates, auto or decltype).

Author: llvm-beanz

tools/clang/include/clang/Basic/DiagnosticParseKinds.td

@@ -994,8 +994,6 @@ def err_hlsl_unsupported_member_default : Error<
   "struct/class members cannot have default values">;
 def err_hlsl_unsupported_packoffset_component : Error<
   "packoffset component should indicate offset with one of x, y, z, w, r, g, b, or a">;
-def err_hlsl_unsupported_pointer : Error<
-  "pointers are unsupported in HLSL">;
 def err_hlsl_unsupported_register_number : Error<
   "register number should be an integral numeric string">;
 def err_hlsl_unsupported_register_noninteger : Error<

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

@@ -8061,6 +8061,9 @@ def err_hlsl_linalg_attributed_matrix_required
 def err_hlsl_linalg_unsupported_stage : Error<
    "builtin unavailable in shader stage '%0' (requires 'compute', 'mesh' or 'amplification')">;
 
+def err_hlsl_pointers_unsupported : Error<
+  "%select{pointers|references}0 are unsupported in HLSL">;
+
 // HLSL Change Ends
 
 // SPIRV Change Starts

tools/clang/lib/Parse/ParseDecl.cpp

@@ -5887,15 +5887,6 @@ void Parser::ParseDeclaratorInternal(Declarator &D,
         return;
       }
 
-      // HLSL Change Starts - No pointer support in HLSL.
-      if (getLangOpts().HLSL) {
-        Diag(Tok, diag::err_hlsl_unsupported_pointer);
-        D.SetIdentifier(0, Tok.getLocation());
-        D.setInvalidType();
-        return;
-      }
-      // HLSL Change Ends
-
       SourceLocation Loc = ConsumeToken();
       D.SetRangeEnd(Loc);
       DeclSpec DS(AttrFactory);
@@ -5917,12 +5908,6 @@ void Parser::ParseDeclaratorInternal(Declarator &D,
 
   tok::TokenKind Kind = Tok.getKind();
 
-  // HLSL Change Starts - HLSL doesn't support pointers, references or blocks
-  if (getLangOpts().HLSL && isPtrOperatorToken(Kind, getLangOpts(), D.getContext())) {
-    Diag(Tok, diag::err_hlsl_unsupported_pointer);
-  }
-  // HLSL Change Ends
-
   // Not a pointer, C++ reference, or block.
   if (!isPtrOperatorToken(Kind, getLangOpts(), D.getContext())) {
     if (DirectDeclParser)

tools/clang/lib/Sema/SemaHLSL.cpp

@@ -15474,6 +15474,24 @@ bool Sema::DiagnoseHLSLDecl(Declarator &D, DeclContext *DC, Expr *BitWidth,
   if (!isFunction)
     hlslSource->WarnMinPrecision(qt, D.getLocStart());
 
+  // HLSL Change Starts - disallow pointers through __decltype.
+  if (!D.isInvalidType() && pType && !qt->isDependentType()) {
+    if (const auto *DTT = dyn_cast<DecltypeType>(pType)) {
+      QualType Underlying = DTT->getUnderlyingType();
+      if (Underlying->isPointerType()) {
+        Diag(D.getLocStart(), diag::err_hlsl_pointers_unsupported) << 0;
+        D.setInvalidType();
+        return false;
+      }
+      if (Underlying->isReferenceType()) {
+        Diag(D.getLocStart(), diag::err_hlsl_pointers_unsupported) << 1;
+        D.setInvalidType();
+        return false;
+      }
+    }
+  }
+  // HLSL Change Ends
+
   // Early checks - these are not simple attribution errors, but constructs that
   // are fundamentally unsupported,
   // and so we avoid errors that might indicate they can be repaired.

tools/clang/lib/Sema/SemaTemplate.cpp

@@ -421,8 +421,14 @@ Sema::ActOnDependentIdExpression(const CXXScopeSpec &SS,
     NamedDecl *FirstQualifierInScope = nullptr;
 
     // HLSL Change begin - This is a reference.
+    // In HLSL, 'this' is an lvalue reference (not a pointer), so implicit
+    // member accesses use '.' (IsArrow=false). The base type must be the
+    // class type T, not the pointer type T*.
+    QualType MemberBaseType =
+        getLangOpts().HLSL ? ThisType->getPointeeType() : ThisType;
     return CXXDependentScopeMemberExpr::Create(
-        Context, /*This*/ nullptr, ThisType, /*IsArrow*/ !getLangOpts().HLSL,
+        Context, /*This*/ nullptr, MemberBaseType,
+        /*IsArrow*/ !getLangOpts().HLSL,
         /*Op*/ SourceLocation(), SS.getWithLocInContext(Context), TemplateKWLoc,
         FirstQualifierInScope, NameInfo, TemplateArgs);
     // HLSL Change end - This is a reference.

tools/clang/lib/Sema/SemaType.cpp

@@ -1849,6 +1849,13 @@ QualType Sema::BuildPointerType(QualType T,
     return QualType();
   }
 
+  // HLSL Change Begin - Disallow pointers.
+  if (getLangOpts().HLSL && Loc.isValid()) {
+    Diag(Loc, diag::err_hlsl_pointers_unsupported) << 0;
+    return QualType();
+  }
+  // HLSL Change End.
+
   if (checkQualifiedFunction(*this, T, Loc, QFK_Pointer))
     return QualType();
 
@@ -1911,6 +1918,13 @@ QualType Sema::BuildReferenceType(QualType T, bool SpelledAsLValue,
     return QualType();
   }
 
+  // HLSL Change Begin - Disallow references.
+  if (getLangOpts().HLSL && Loc.isValid()) {
+    Diag(Loc, diag::err_hlsl_pointers_unsupported) << 1;
+    return QualType();
+  }
+  // HLSL Change End.
+
   if (checkQualifiedFunction(*this, T, Loc, QFK_Reference))
     return QualType();
 
@@ -2313,6 +2327,13 @@ QualType Sema::BuildMemberPointerType(QualType T, QualType Class,
     return QualType();
   }
 
+  // HLSL Change Begin - Disallow pointers.
+  if (getLangOpts().HLSL && Loc.isValid()) {
+    Diag(Loc, diag::err_hlsl_pointers_unsupported) << 0;
+    return QualType();
+  }
+  // HLSL Change End.
+
   // Adjust the default free function calling convention to the default method
   // calling convention.
   if (T->isFunctionType())

tools/clang/lib/Sema/TreeTransform.h

@@ -9852,7 +9852,12 @@ TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr(
   } else {
     OldBase = nullptr;
     BaseType = getDerived().TransformType(E->getBaseType());
-    ObjectType = BaseType->getPointeeType();
+    // HLSL Change - Begin
+    // In HLSL, 'this' is an lvalue reference so implicit member accesses use
+    // '.' (IsArrow=false) and the stored base type IS the object type, not a
+    // pointer to it.
+    ObjectType = E->isArrow() ? BaseType->getPointeeType() : BaseType;
+    // HLSL Change - End
   }
 
   // Transform the first part of the nested-name-specifier that qualifies

tools/clang/test/HLSL/cpp-errors-hv2015.hlsl

@@ -94,10 +94,10 @@ typename typedef float4 TFloat4; // expected-error {{'typename' is a reserved ke
 class C {
   int fn_eq_default() = default; // expected-error {{function deletion and defaulting is unsupported in HLSL}}
 
-  // Errors are a bit misleading here, but ultimate we don't support these.
-  void* operator new(); // expected-error {{'operator' is a reserved keyword in HLSL}} expected-error {{pointers are unsupported in HLSL}}
-  void* operator new(int); // expected-error {{'operator' is a reserved keyword in HLSL}} expected-error {{pointers are unsupported in HLSL}}
-  void* operator new(size_t); // expected-error {{'operator' is a reserved keyword in HLSL}} expected-error {{pointers are unsupported in HLSL}}
+  // Pointer return type is no longer caught at parse time; operator keyword error is still reported.
+  void* operator new(); // expected-error {{'operator' is a reserved keyword in HLSL}}
+  void* operator new(int); // expected-error {{'operator' is a reserved keyword in HLSL}}
+  void* operator new(size_t); // expected-error {{'operator' is a reserved keyword in HLSL}}
 
   C() = delete; // expected-error {{HLSL requires a type specifier for all declarations}} expected-error {{constructor cannot have a return type}}
 };

tools/clang/test/HLSL/cpp-errors.hlsl

@@ -91,10 +91,10 @@ typename typedef float4 TFloat4; // expected-error {{'typename' is a reserved ke
 class C {
   int fn_eq_default() = default; // expected-error {{function deletion and defaulting is unsupported in HLSL}}
 
-  // Errors are a bit misleading here, but ultimate we don't support these.
-  void* operator new(); // expected-error {{'operator' is a reserved keyword in HLSL}} expected-error {{pointers are unsupported in HLSL}}
-  void* operator new(int); // expected-error {{'operator' is a reserved keyword in HLSL}} expected-error {{pointers are unsupported in HLSL}}
-  void* operator new(size_t); // expected-error {{'operator' is a reserved keyword in HLSL}} expected-error {{pointers are unsupported in HLSL}}
+  // Pointer return type is no longer caught at parse time; operator keyword error is still reported.
+  void* operator new(); // expected-error {{'operator' is a reserved keyword in HLSL}}
+  void* operator new(int); // expected-error {{'operator' is a reserved keyword in HLSL}}
+  void* operator new(size_t); // expected-error {{'operator' is a reserved keyword in HLSL}}
 
   C() = delete; // expected-error {{HLSL requires a type specifier for all declarations}} expected-error {{constructor cannot have a return type}}
 };

tools/clang/test/SemaHLSL/decltype-ptr-ref-instance-vars.hlsl

@@ -0,0 +1,67 @@
+// RUN: %dxc -Tlib_6_3 -Wno-unused-value -verify %s
+// RUN: %dxc -Tcs_6_0 -Wno-unused-value -verify %s
+
+// Verify that pointer and reference types produced by __decltype cannot be
+// used as struct instance variable types or local variable types in HLSL.
+// Also verifies that template instantiation with pointer/reference type
+// arguments is rejected, and that valid __decltype uses are not affected.
+
+// __decltype is the GCC way of saying 'decltype', but doesn't require C++11.
+
+// groupshared variables are mutable (unlike plain global variables in HLSL),
+// which allows their lvalue expressions to produce reference types via
+// __decltype.
+groupshared int g;
+
+// --- Struct field: reference type from __decltype ---
+struct RefField {
+  __decltype(++g) ref_field; // expected-error {{references are unsupported in HLSL}}
+};
+
+// --- Struct field: pointer type via explicit cast in __decltype ---
+struct PtrField {
+  __decltype((int *)0) ptr_field; // expected-error {{pointers are unsupported in HLSL}}
+};
+
+// --- Struct field: plain (non-reference) type from __decltype is valid ---
+struct PlainField {
+  __decltype(0 + 1) plain_field; // no error: int rvalue, not a reference
+};
+
+// --- Local variable: reference type from __decltype ---
+void test_local_ref() {
+  int x = 0;
+  __decltype(++x) local_ref; // expected-error {{references are unsupported in HLSL}}
+}
+
+// --- Local variable: pointer type via __decltype ---
+void test_local_ptr() {
+  __decltype((int *)0) local_ptr; // expected-error {{pointers are unsupported in HLSL}}
+}
+
+// --- Template: field with explicit reference type is rejected at definition ---
+template <typename T>
+struct RefContainer {
+  T &ref_field; // expected-error {{references are unsupported in HLSL}}
+};
+
+// --- Template instantiation: type argument is an explicit pointer type ---
+// This verifies that pointer instance variables cannot be created through
+// template instantiation with pointer type arguments.
+template <typename T>
+struct Container {
+  T field;
+};
+
+void test_template_ptr_explicit() {
+  Container<int *> c; // expected-error {{pointers are unsupported in HLSL}}
+}
+
+// --- Regression: __decltype in is_same template argument still works ---
+// HLSL has a non-standard is_same extension that treats T and T& as the same
+// type. This is used in scalar-operators tests and must not be broken.
+void test_is_same_regression() {
+  int x = 0;
+  _Static_assert(std::is_same<int, __decltype(x += 1)>::value,
+                 "regression: is_same with lvalue __decltype must still work");
+}