Refactor unary operation constant folding code

src/compiler/translator/IntermNode.cpp

@@ -810,7 +810,28 @@ TIntermTyped *TIntermUnary::fold(TInfoSink &infoSink)
     {
         return nullptr;
     }
-    TConstantUnion *constArray = operandConstant->foldUnary(mOp, infoSink);
+
+    TConstantUnion *constArray = nullptr;
+    switch (mOp)
+    {
+      case EOpAny:
+      case EOpAll:
+      case EOpLength:
+      case EOpTranspose:
+      case EOpDeterminant:
+      case EOpInverse:
+      case EOpPackSnorm2x16:
+      case EOpUnpackSnorm2x16:
+      case EOpPackUnorm2x16:
+      case EOpUnpackUnorm2x16:
+      case EOpPackHalf2x16:
+      case EOpUnpackHalf2x16:
+        constArray = operandConstant->foldUnaryWithDifferentReturnType(mOp, infoSink);
+        break;
+      default:
+        constArray = operandConstant->foldUnaryWithSameReturnType(mOp, infoSink);
+        break;
+    }
     return CreateFoldedNode(constArray, this);
 }
 
@@ -1178,22 +1199,18 @@ TConstantUnion *TIntermConstantUnion::foldBinary(TOperator op, TIntermConstantUn
 //
 // Returns the constant value to keep using or nullptr.
 //
-TConstantUnion *TIntermConstantUnion::foldUnary(TOperator op, TInfoSink &infoSink)
+TConstantUnion *TIntermConstantUnion::foldUnaryWithDifferentReturnType(TOperator op, TInfoSink &infoSink)
 {
-    TConstantUnion *operandArray = getUnionArrayPointer();
+    //
+    // Do operations where the return type has a different number of components compared to the operand type.
+    //
 
+    TConstantUnion *operandArray = getUnionArrayPointer();
     if (!operandArray)
         return nullptr;
 
     size_t objectSize = getType().getObjectSize();
-
-    if (op == EOpAny || op == EOpAll || op == EOpLength || op == EOpTranspose || op == EOpDeterminant ||
-        op == EOpInverse || op == EOpPackSnorm2x16 || op == EOpUnpackSnorm2x16 || op == EOpPackUnorm2x16 ||
-        op == EOpUnpackUnorm2x16 || op == EOpPackHalf2x16 || op == EOpUnpackHalf2x16)
-    {
-        // Do operations where the return type has a different number of components compared to the operand type.
     TConstantUnion *resultArray = nullptr;
-
     switch (op)
     {
       case EOpAny:
@@ -1393,12 +1410,20 @@ TConstantUnion *TIntermConstantUnion::foldUnary(TOperator op, TInfoSink &infoSin
     }
 
     return resultArray;
-    }
-    else
-    {
+}
+
+TConstantUnion *TIntermConstantUnion::foldUnaryWithSameReturnType(TOperator op, TInfoSink &infoSink)
+{
     //
     // Do unary operations where the return type is the same as operand type.
     //
+
+    TConstantUnion *operandArray = getUnionArrayPointer();
+    if (!operandArray)
+        return nullptr;
+
+    size_t objectSize = getType().getObjectSize();
+
     TConstantUnion *resultArray = new TConstantUnion[objectSize];
     for (size_t i = 0; i < objectSize; i++)
     {
@@ -1752,8 +1777,8 @@ TConstantUnion *TIntermConstantUnion::foldUnary(TOperator op, TInfoSink &infoSin
             return nullptr;
         }
     }
+
     return resultArray;
-    }
 }
 
 bool TIntermConstantUnion::foldFloatTypeUnary(const TConstantUnion &parameter, FloatTypeUnaryFunc builtinFunc,

src/compiler/translator/IntermNode.h

@@ -300,7 +300,8 @@ class TIntermConstantUnion : public TIntermTyped
     virtual bool replaceChildNode(TIntermNode *, TIntermNode *) { return false; }
 
     TConstantUnion *foldBinary(TOperator op, TIntermConstantUnion *rightNode, TInfoSink &infoSink);
-    TConstantUnion *foldUnary(TOperator op, TInfoSink &infoSink);
+    TConstantUnion *foldUnaryWithDifferentReturnType(TOperator op, TInfoSink &infoSink);
+    TConstantUnion *foldUnaryWithSameReturnType(TOperator op, TInfoSink &infoSink);
 
     static TConstantUnion *FoldAggregateBuiltIn(TIntermAggregate *aggregate, TInfoSink &infoSink);