Refine swizzle/indexing constant folding code

src/compiler/translator/ParseContext.h

@@ -253,18 +253,7 @@ class TParseContext : angle::NonCopyable
                                  TOperator op,
                                  TFunction *fnCall,
                                  const TSourceLoc &line);
-    TIntermTyped *addConstVectorNode(TVectorFields &fields,
-                                     TIntermConstantUnion *node,
-                                     const TSourceLoc &line,
-                                     bool outOfRangeIndexIsError);
-    TIntermTyped *addConstMatrixNode(int index,
-                                     TIntermConstantUnion *node,
-                                     const TSourceLoc &line,
-                                     bool outOfRangeIndexIsError);
-    TIntermTyped *addConstArrayNode(int index,
-                                    TIntermConstantUnion *node,
-                                    const TSourceLoc &line,
-                                    bool outOfRangeIndexIsError);
+
     TIntermTyped *addConstStruct(
         const TString &identifier, TIntermTyped *node, const TSourceLoc& line);
     TIntermTyped *addIndexExpression(TIntermTyped *baseExpression,
@@ -342,6 +331,26 @@ class TParseContext : angle::NonCopyable
     TSymbolTable &symbolTable;   // symbol table that goes with the language currently being parsed
 
   private:
+    // Returns a clamped index.
+    int checkIndexOutOfRange(bool outOfRangeIndexIsError,
+                             const TSourceLoc &location,
+                             int index,
+                             int arraySize,
+                             const char *reason,
+                             const char *token);
+
+    // Constant folding for element access. Note that the returned node does not have the correct
+    // type - it is expected to be fixed later.
+    TIntermConstantUnion *foldVectorSwizzle(TVectorFields &fields,
+                                            TIntermConstantUnion *baseNode,
+                                            const TSourceLoc &location);
+    TIntermConstantUnion *foldMatrixSubscript(int index,
+                                              TIntermConstantUnion *baseNode,
+                                              const TSourceLoc &location);
+    TIntermConstantUnion *foldArraySubscript(int index,
+                                             TIntermConstantUnion *baseNode,
+                                             const TSourceLoc &location);
+
     bool declareVariable(const TSourceLoc &line, const TString &identifier, const TType &type, TVariable **variable);
 
     bool nonInitErrorCheck(const TSourceLoc &line, const TString &identifier, TPublicType *type);

src/tests/compiler_tests/ConstantFolding_test.cpp

@@ -744,3 +744,20 @@ TEST_F(ConstantFoldingTest, FoldNestedIdenticalStructEqualityComparison)
     compile(shaderString);
     ASSERT_TRUE(constantFoundInAST(1.0f));
 }
+
+// Test that right elements are chosen from non-square matrix
+TEST_F(ConstantFoldingTest, FoldNonSquareMatrixIndexing)
+{
+    const std::string &shaderString =
+        "#version 300 es\n"
+        "precision mediump float;\n"
+        "out vec4 my_FragColor;\n"
+        "void main()\n"
+        "{\n"
+        "    my_FragColor = mat3x4(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)[1];\n"
+        "}\n";
+    compile(shaderString);
+    float outputElements[] = {4.0f, 5.0f, 6.0f, 7.0f};
+    std::vector<float> result(outputElements, outputElements + 4);
+    ASSERT_TRUE(constantVectorFoundInAST(result));
+}

src/tests/compiler_tests/MalformedShader_test.cpp

@@ -1611,12 +1611,12 @@ TEST_F(MalformedShaderTest, CompoundMultiplyMatrixValidNonSquareDimensions)
     }
 }
 
-// Covers a bug where we would set the incorrect result size on an out-of-bounds vector sizzle.
+// Covers a bug where we would set the incorrect result size on an out-of-bounds vector swizzle.
 TEST_F(MalformedShaderTest, OutOfBoundsVectorSwizzle)
 {
     const std::string &shaderString =
         "void main() {\n"
-        "   vec2(0).qq * a(b);\n"
+        "   vec2(0).qq;\n"
         "}\n";
     if (compile(shaderString))
     {