Fix structure comparison constant folding

src/compiler/translator/IntermNode.cpp

@@ -66,73 +66,6 @@ bool ValidateMultiplication(TOperator op, const TType &left, const TType &right)
     }
 }
 
-bool CompareStructure(const TType& leftNodeType,
-                      const TConstantUnion *rightUnionArray,
-                      const TConstantUnion *leftUnionArray);
-
-bool CompareStruct(const TType &leftNodeType,
-                   const TConstantUnion *rightUnionArray,
-                   const TConstantUnion *leftUnionArray)
-{
-    const TFieldList &fields = leftNodeType.getStruct()->fields();
-
-    size_t structSize = fields.size();
-    size_t index = 0;
-
-    for (size_t j = 0; j < structSize; j++)
-    {
-        size_t size = fields[j]->type()->getObjectSize();
-        for (size_t i = 0; i < size; i++)
-        {
-            if (fields[j]->type()->getBasicType() == EbtStruct)
-            {
-                if (!CompareStructure(*fields[j]->type(),
-                                      &rightUnionArray[index],
-                                      &leftUnionArray[index]))
-                {
-                    return false;
-                }
-            }
-            else
-            {
-                if (leftUnionArray[index] != rightUnionArray[index])
-                    return false;
-                index++;
-            }
-        }
-    }
-    return true;
-}
-
-bool CompareStructure(const TType &leftNodeType,
-                      const TConstantUnion *rightUnionArray,
-                      const TConstantUnion *leftUnionArray)
-{
-    if (leftNodeType.isArray())
-    {
-        TType typeWithoutArrayness = leftNodeType;
-        typeWithoutArrayness.clearArrayness();
-
-        size_t arraySize = leftNodeType.getArraySize();
-
-        for (size_t i = 0; i < arraySize; ++i)
-        {
-            size_t offset = typeWithoutArrayness.getObjectSize() * i;
-            if (!CompareStruct(typeWithoutArrayness,
-                               &rightUnionArray[offset],
-                               &leftUnionArray[offset]))
-            {
-                return false;
-            }
-        }
-    }
-    else
-    {
-        return CompareStruct(leftNodeType, rightUnionArray, leftUnionArray);
-    }
-    return true;
-}
-
 TConstantUnion *Vectorize(const TConstantUnion &constant, size_t size)
 {
     TConstantUnion *constUnion = new TConstantUnion[size];
@@ -1269,19 +1202,12 @@ TConstantUnion *TIntermConstantUnion::foldBinary(TOperator op, TIntermConstantUn
         {
             resultArray = new TConstantUnion[1];
             bool equal = true;
-            if (getType().getBasicType() == EbtStruct)
-            {
-                equal = CompareStructure(getType(), rightArray, leftArray);
-            }
-            else
+            for (size_t i = 0; i < objectSize; i++)
             {
-                for (size_t i = 0; i < objectSize; i++)
+                if (leftArray[i] != rightArray[i])
                 {
-                    if (leftArray[i] != rightArray[i])
-                    {
-                        equal = false;
-                        break;  // break out of for loop
-                    }
+                    equal = false;
+                    break;  // break out of for loop
                 }
             }
             if (op == EOpEqual)

src/tests/compiler_tests/ConstantFolding_test.cpp

@@ -697,3 +697,50 @@ TEST_F(ConstantFoldingTest, FoldMat2ConstructorTakingVec4)
     std::vector<float> result(outputElements, outputElements + 4);
     ASSERT_TRUE(constantVectorFoundInAST(result));
 }
+
+// Test that equality comparison of two different structs with a nested struct inside returns false.
+TEST_F(ConstantFoldingTest, FoldNestedDifferentStructEqualityComparison)
+{
+    const std::string &shaderString =
+        "precision mediump float;\n"
+        "struct nested {\n"
+        "    float f\n;"
+        "};\n"
+        "struct S {\n"
+        "    nested a;\n"
+        "    float f;\n"
+        "};\n"
+        "uniform vec4 mult;\n"
+        "void main()\n"
+        "{\n"
+        "    const S s1 = S(nested(0.0), 2.0);\n"
+        "    const S s2 = S(nested(0.0), 3.0);\n"
+        "    gl_FragColor = (s1 == s2 ? 1.0 : 0.5) * mult;\n"
+        "}\n";
+    compile(shaderString);
+    ASSERT_TRUE(constantFoundInAST(0.5f));
+}
+
+// Test that equality comparison of two identical structs with a nested struct inside returns true.
+TEST_F(ConstantFoldingTest, FoldNestedIdenticalStructEqualityComparison)
+{
+    const std::string &shaderString =
+        "precision mediump float;\n"
+        "struct nested {\n"
+        "    float f\n;"
+        "};\n"
+        "struct S {\n"
+        "    nested a;\n"
+        "    float f;\n"
+        "    int i;\n"
+        "};\n"
+        "uniform vec4 mult;\n"
+        "void main()\n"
+        "{\n"
+        "    const S s1 = S(nested(0.0), 2.0, 3);\n"
+        "    const S s2 = S(nested(0.0), 2.0, 3);\n"
+        "    gl_FragColor = (s1 == s2 ? 1.0 : 0.5) * mult;\n"
+        "}\n";
+    compile(shaderString);
+    ASSERT_TRUE(constantFoundInAST(1.0f));
+}