[HLSL2021] Disable operators that rely on references (#4133) (#4135)

* Disable operators that rely on references

After lots of discussion, we think it is best to disable operators that
should rely on reference parameters or return types for HLSL 2021. The
main driver of this is that we believe that references will get added to
HLSL in the near future, and we'd like to make it easier to maintain
compatability between HLSL 2021 and future versions of HLSL where
references are supported.

* Removing assignment operator test case

(cherry picked from commit ade5e47)

Author: llvm-beanz

tools/clang/lib/Sema/SemaDeclCXX.cpp

@@ -11,6 +11,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang/Basic/OperatorKinds.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
@@ -11638,7 +11639,10 @@ bool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {
   // HLSL Change Starts
   if (LangOpts.HLSL) {
     if (Op == OO_Delete || Op == OO_Array_Delete || Op == OO_New ||
-        Op == OO_Array_New) {
+        Op == OO_Array_New || Op == OO_Equal ||
+        (Op >= OO_PlusEqual && Op <= OO_GreaterGreaterEqual) ||
+        Op == OO_PlusPlus || Op == OO_MinusMinus || Op == OO_ArrowStar ||
+        Op == OO_Arrow) {
       return Diag(FnDecl->getLocation(),
                   diag::err_hlsl_overloading_new_delete_operator)
              << FnDecl->getDeclName();

tools/clang/test/CodeGenSPIRV/operator.overloading.assign.hlsl

@@ -0,0 +1,30 @@
+// RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -ffreestanding -verify -enable-operator-overloading %s
+// RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -ffreestanding -verify -HV 2021 %s
+
+// This test checks that dxcompiler generates errors when overloading operators
+// that are not supported for overloading in HLSL 2021
+
+struct S
+{
+    float foo;
+    void operator=(S s) {} // expected-error {{overloading 'operator=' is not allowed}}
+    void operator+=(S s) {} // expected-error {{overloading 'operator+=' is not allowed}}
+    void operator-=(S s) {} // expected-error {{overloading 'operator-=' is not allowed}}
+    void operator*=(S s) {} // expected-error {{overloading 'operator*=' is not allowed}}
+    void operator/=(S s) {} // expected-error {{overloading 'operator/=' is not allowed}}
+    void operator%=(S s) {} // expected-error {{overloading 'operator%=' is not allowed}}
+    void operator^=(S s) {} // expected-error {{overloading 'operator^=' is not allowed}}
+    void operator&=(S s) {} // expected-error {{overloading 'operator&=' is not allowed}}
+    void operator|=(S s) {} // expected-error {{overloading 'operator|=' is not allowed}}
+    void operator<<(S s) {} // expected-error {{overloading 'operator<<' is not allowed}}
+    void operator>>(S s) {} // expected-error {{overloading 'operator>>' is not allowed}}
+    void operator<<=(S s) {} // expected-error {{overloading 'operator<<=' is not allowed}}
+    void operator>>=(S s) {} // expected-error {{overloading 'operator>>=' is not allowed}}
+    void operator->*(S s) {} // expected-error {{overloading 'operator->*' is not allowed}}
+    void operator->(S s) {} // expected-error {{overloading 'operator->' is not allowed}}
+    void operator++(S s) {} // expected-error {{overloading 'operator++' is not allowed}}
+    void operator--(S s) {} // expected-error {{overloading 'operator--' is not allowed}}
+};
+
+[numthreads(1,1,1)]
+void main() {}

tools/clang/test/HLSL/overloading-unsupported-operators.hlsl

@@ -5,8 +5,8 @@
 struct S {
     float a;
 
-    void operator=(float x) {
-        a = x;
+    float operator-(float x) {
+        return a - x;
     }
 
     float operator+(float x) {
@@ -17,20 +17,18 @@ struct S {
 struct Number {
     int n;
 
-    void operator=(float x) {
-        n = x;
+    int operator+(float x) {
+        return n + x;
     }
 };
 
 int main(float4 pos: SV_Position) : SV_Target {
-    S s1;
-    S s2;
-    s1 = s2;
-    s1 = 0.2;
-    s1 = s1 + 0.1;
+    S s1 = {0.2};
+    S s2 = {0.2};
+    float f = s1 + 0.1;
 
     Number a = {pos.x};
     Number b = {pos.y};
-    a = pos.x;
-    return a.n;
+    a.n = b + pos.x;
+    return b + pos.y;
 }

tools/clang/test/HLSLFileCheck/hlsl/operator_overloading/operator.overloading.assign.hlsl

@@ -228,9 +228,6 @@ TEST_F(FileTest, VarVFACEInterface) {
   runFileTest("var.vface.interface.hlsl", Expect::Warning);
 }
 
-TEST_F(FileTest, OperatorOverloadingAssign) {
-  runFileTest("operator.overloading.assign.hlsl");
-}
 TEST_F(FileTest, OperatorOverloadingCall) {
   runFileTest("operator.overloading.call.hlsl");
 }