Unify aggregate operator folding with other constant folding

src/compiler/translator/IntermNode.h

@@ -302,7 +302,7 @@ class TIntermConstantUnion : public TIntermTyped
     TConstantUnion *foldBinary(TOperator op, TIntermConstantUnion *rightNode, TInfoSink &infoSink);
     TConstantUnion *foldUnary(TOperator op, TInfoSink &infoSink);
 
-    static TIntermTyped *FoldAggregateBuiltIn(TOperator op, TIntermAggregate *aggregate, TInfoSink &infoSink);
+    static TConstantUnion *FoldAggregateBuiltIn(TIntermAggregate *aggregate, TInfoSink &infoSink);
 
   protected:
     TConstantUnion *mUnionArrayPointer;
@@ -443,6 +443,7 @@ class TIntermAggregate : public TIntermOperator
     bool insertChildNodes(TIntermSequence::size_type position, TIntermSequence insertions);
     // Conservatively assume function calls and other aggregate operators have side-effects
     virtual bool hasSideEffects() const { return true; }
+    TIntermTyped *fold(TInfoSink &infoSink);
 
     TIntermSequence *getSequence() { return &mSequence; }
 

src/compiler/translator/Intermediate.cpp

@@ -441,9 +441,9 @@ bool TIntermediate::postProcess(TIntermNode *root)
     return true;
 }
 
-TIntermTyped *TIntermediate::foldAggregateBuiltIn(TOperator op, TIntermAggregate *aggregate)
+TIntermTyped *TIntermediate::foldAggregateBuiltIn(TIntermAggregate *aggregate)
 {
-    switch (op)
+    switch (aggregate->getOp())
     {
       case EOpAtan:
       case EOpPow:
@@ -466,7 +466,7 @@ TIntermTyped *TIntermediate::foldAggregateBuiltIn(TOperator op, TIntermAggregate
       case EOpFaceForward:
       case EOpReflect:
       case EOpRefract:
-        return TIntermConstantUnion::FoldAggregateBuiltIn(op, aggregate, mInfoSink);
+        return aggregate->fold(mInfoSink);
       default:
         // Constant folding not supported for the built-in.
         return nullptr;

src/compiler/translator/Intermediate.h

@@ -64,7 +64,7 @@ class TIntermediate
 
     static void outputTree(TIntermNode *, TInfoSinkBase &);
 
-    TIntermTyped *foldAggregateBuiltIn(TOperator op, TIntermAggregate *aggregate);
+    TIntermTyped *foldAggregateBuiltIn(TIntermAggregate *aggregate);
 
   private:
     void operator=(TIntermediate &); // prevent assignments

src/compiler/translator/ParseContext.cpp

@@ -3512,19 +3512,20 @@ TIntermTyped *TParseContext::addFunctionCallOrMethod(TFunction *fnCall, TIntermN
                     TIntermAggregate *aggregate = intermediate.setAggregateOperator(paramNode, op, loc);
                     aggregate->setType(fnCandidate->getReturnType());
                     aggregate->setPrecisionFromChildren();
-                    callNode = aggregate;
 
                     // Some built-in functions have out parameters too.
                     functionCallLValueErrorCheck(fnCandidate, aggregate);
 
                     // See if we can constant fold a built-in.
-                    TIntermTyped *foldedNode = intermediate.foldAggregateBuiltIn(op, aggregate);
+                    TIntermTyped *foldedNode = intermediate.foldAggregateBuiltIn(aggregate);
                     if (foldedNode)
                     {
-                        foldedNode->setType(callNode->getType());
-                        foldedNode->getTypePointer()->setQualifier(EvqConst);
                         callNode = foldedNode;
                     }
+                    else
+                    {
+                        callNode = aggregate;
+                    }
                 }
             }
             else