Refactor GLSL array length method parsing

src/compiler/translator/IntermNode.cpp

@@ -803,6 +803,13 @@ TOperator TIntermBinary::GetMulAssignOpBasedOnOperands(const TType &left, const
 //
 void TIntermUnary::promote()
 {
+    if (mOp == EOpArrayLength)
+    {
+        // Special case: the qualifier of .length() doesn't depend on the operand qualifier.
+        setType(TType(EbtInt, EbpUndefined, EvqConst));
+        return;
+    }
+
     TQualifier resultQualifier = EvqTemporary;
     if (mOperand->getQualifier() == EvqConst)
         resultQualifier = EvqConst;
@@ -1355,13 +1362,25 @@ TIntermTyped *TIntermBinary::fold(TDiagnostics *diagnostics)
 
 TIntermTyped *TIntermUnary::fold(TDiagnostics *diagnostics)
 {
+    TConstantUnion *constArray = nullptr;
+
+    if (mOp == EOpArrayLength)
+    {
+        if (mOperand->hasSideEffects())
+        {
+            return this;
+        }
+        constArray = new TConstantUnion[1];
+        constArray->setIConst(mOperand->getOutermostArraySize());
+    }
+    else
+    {
         TIntermConstantUnion *operandConstant = mOperand->getAsConstantUnion();
         if (operandConstant == nullptr)
         {
             return this;
         }
 
-    TConstantUnion *constArray = nullptr;
         switch (mOp)
         {
             case EOpAny:
@@ -1386,6 +1405,7 @@ TIntermTyped *TIntermUnary::fold(TDiagnostics *diagnostics)
                 constArray = operandConstant->foldUnaryComponentWise(mOp, diagnostics);
                 break;
         }
+    }
     if (constArray == nullptr)
     {
         return this;

src/compiler/translator/Operator.cpp

@@ -30,6 +30,9 @@ const char *GetOperatorString(TOperator op)
         case EOpPreDecrement:
             return "--";
 
+        case EOpArrayLength:
+            return ".length()";
+
         case EOpAdd:
             return "+";
         case EOpSub:

src/compiler/translator/Operator.h

@@ -42,6 +42,8 @@ enum TOperator
     EOpPreIncrement,
     EOpPreDecrement,
 
+    EOpArrayLength,
+
     //
     // binary operations (ones with special GLSL syntax are used in TIntermBinary nodes, others in
     // TIntermAggregate nodes)

src/compiler/translator/OutputTree.cpp

@@ -318,6 +318,10 @@ bool TOutputTraverser::visitUnary(Visit visit, TIntermUnary *node)
             mOut << "Pre-Decrement";
             break;
 
+        case EOpArrayLength:
+            mOut << "Array length";
+            break;
+
         case EOpLogicalNotComponentWise:
             mOut << "component-wise not";
             break;

src/compiler/translator/ParseContext.cpp

@@ -5447,8 +5447,6 @@ TIntermTyped *TParseContext::addMethod(TFunction *fnCall,
                                        TIntermNode *thisNode,
                                        const TSourceLoc &loc)
 {
-    TConstantUnion *unionArray = new TConstantUnion[1];
-    int arraySize              = 0;
     TIntermTyped *typedThis    = thisNode->getAsTyped();
     // It's possible for the name pointer in the TFunction to be null in case it gets parsed as
     // a constructor. But such a TFunction can't reach here, since the lexer goes into FIELDS
@@ -5471,29 +5469,18 @@ TIntermTyped *TParseContext::addMethod(TFunction *fnCall,
     {
         error(loc, "missing input primitive declaration before calling length on gl_in", "length");
     }
-    else
+    else if (typedThis->hasSideEffects())
     {
-        arraySize = typedThis->getOutermostArraySize();
-        if (typedThis->getAsSymbolNode() == nullptr)
-        {
-            // This code path can be hit with expressions like these:
-            // (a = b).length()
-            // (func()).length()
-            // (int[3](0, 1, 2)).length()
-            // ESSL 3.00 section 5.9 defines expressions so that this is not actually a valid
-            // expression.
-            // It allows "An array name with the length method applied" in contrast to GLSL 4.4
-            // spec section 5.9 which allows "An array, vector or matrix expression with the
-            // length method applied".
-            error(loc, "length can only be called on array names, not on array expressions",
+        error(loc, "length method not supported on expressions with possible side effects",
               "length");
     }
-    }
-    unionArray->setIConst(arraySize);
-    TIntermConstantUnion *node =
-        new TIntermConstantUnion(unionArray, TType(EbtInt, EbpUndefined, EvqConst));
+    else
+    {
+        TIntermUnary *node = new TIntermUnary(EOpArrayLength, typedThis);
         node->setLine(loc);
-    return node;
+        return node->fold(mDiagnostics);
+    }
+    return CreateZeroNode(TType(EbtInt, EbpUndefined, EvqConst));
 }
 
 TIntermTyped *TParseContext::addNonConstructorFunctionCall(TFunction *fnCall,