Make aggregate node creation more robust

src/compiler/translator/ArrayReturnValueToOutParameter.cpp

@@ -43,17 +43,17 @@ TIntermSymbol *CreateReturnValueOutSymbol(const TType &type)
 TIntermAggregate *CreateReplacementCall(TIntermAggregate *originalCall,
                                         TIntermTyped *returnValueTarget)
 {
-    TIntermAggregate *replacementCall = new TIntermAggregate(EOpCallFunctionInAST);
-    replacementCall->setType(TType(EbtVoid));
-    *replacementCall->getFunctionSymbolInfo() = *originalCall->getFunctionSymbolInfo();
-    replacementCall->setLine(originalCall->getLine());
-    TIntermSequence *replacementParameters = replacementCall->getSequence();
-    TIntermSequence *originalParameters    = originalCall->getSequence();
-    for (auto &param : *originalParameters)
+    TIntermSequence *replacementArguments = new TIntermSequence();
+    TIntermSequence *originalArguments    = originalCall->getSequence();
+    for (auto &arg : *originalArguments)
     {
-        replacementParameters->push_back(param);
+        replacementArguments->push_back(arg);
     }
-    replacementParameters->push_back(returnValueTarget);
+    replacementArguments->push_back(returnValueTarget);
+    TIntermAggregate *replacementCall =
+        new TIntermAggregate(TType(EbtVoid), EOpCallFunctionInAST, replacementArguments);
+    *replacementCall->getFunctionSymbolInfo() = *originalCall->getFunctionSymbolInfo();
+    replacementCall->setLine(originalCall->getLine());
     return replacementCall;
 }
 

src/compiler/translator/DeferGlobalInitializers.cpp

@@ -50,10 +50,10 @@ TIntermFunctionDefinition *CreateFunctionDefinitionNode(const char *name,
 
 TIntermAggregate *CreateFunctionCallNode(const char *name, const int functionId)
 {
-    TIntermAggregate *functionNode = new TIntermAggregate(EOpCallFunctionInAST);
-    SetInternalFunctionName(functionNode->getFunctionSymbolInfo(), name);
     TType returnType(EbtVoid);
-    functionNode->setType(returnType);
+    TIntermAggregate *functionNode =
+        new TIntermAggregate(returnType, EOpCallFunctionInAST, nullptr);
+    SetInternalFunctionName(functionNode->getFunctionSymbolInfo(), name);
     functionNode->getFunctionSymbolInfo()->setId(functionId);
     return functionNode;
 }

src/compiler/translator/EmulatePrecision.cpp

@@ -427,13 +427,14 @@ bool canRoundFloat(const TType &type)
            (type.getPrecision() == EbpLow || type.getPrecision() == EbpMedium);
 }
 
-TIntermAggregate *createInternalFunctionCallNode(TString name, TIntermNode *child)
+TIntermAggregate *createInternalFunctionCallNode(const TType &type,
+                                                 TString name,
+                                                 TIntermSequence *arguments)
 {
-    TIntermAggregate *callNode = new TIntermAggregate(EOpCallInternalRawFunction);
-    TName nameObj(TFunction::mangleName(name));
+    TName nameObj(TFunction::GetMangledNameFromCall(name, *arguments));
     nameObj.setInternal(true);
+    TIntermAggregate *callNode = new TIntermAggregate(type, EOpCallInternalRawFunction, arguments);
     callNode->getFunctionSymbolInfo()->setNameObj(nameObj);
-    callNode->getSequence()->push_back(child);
     return callNode;
 }
 
@@ -444,9 +445,9 @@ TIntermAggregate *createRoundingFunctionCallNode(TIntermTyped *roundedChild)
         roundFunctionName = "angle_frm";
     else
         roundFunctionName      = "angle_frl";
-    TIntermAggregate *callNode = createInternalFunctionCallNode(roundFunctionName, roundedChild);
-    callNode->setType(roundedChild->getType());
-    return callNode;
+    TIntermSequence *arguments = new TIntermSequence();
+    arguments->push_back(roundedChild);
+    return createInternalFunctionCallNode(roundedChild->getType(), roundFunctionName, arguments);
 }
 
 TIntermAggregate *createCompoundAssignmentFunctionCallNode(TIntermTyped *left,
@@ -459,9 +460,10 @@ TIntermAggregate *createCompoundAssignmentFunctionCallNode(TIntermTyped *left,
     else
         strstr << "angle_compound_" << opNameStr << "_frl";
     TString functionName       = strstr.str().c_str();
-    TIntermAggregate *callNode = createInternalFunctionCallNode(functionName, left);
-    callNode->getSequence()->push_back(right);
-    return callNode;
+    TIntermSequence *arguments = new TIntermSequence();
+    arguments->push_back(left);
+    arguments->push_back(right);
+    return createInternalFunctionCallNode(TType(EbtVoid), functionName, arguments);
 }
 
 bool parentUsesResult(TIntermNode *parent, TIntermNode *node)

src/compiler/translator/IntermNode.cpp

@@ -272,12 +272,48 @@ bool TIntermAggregateBase::insertChildNodes(TIntermSequence::size_type position,
     return true;
 }
 
+TIntermAggregate::TIntermAggregate(const TType &type, TOperator op, TIntermSequence *arguments)
+    : TIntermOperator(op), mUseEmulatedFunction(false), mGotPrecisionFromChildren(false)
+{
+    if (arguments != nullptr)
+    {
+        mArguments.swap(*arguments);
+    }
+    setTypePrecisionAndQualifier(type);
+}
+
+void TIntermAggregate::setTypePrecisionAndQualifier(const TType &type)
+{
+    setType(type);
+    mType.setQualifier(EvqTemporary);
+    if (!isFunctionCall())
+    {
+        if (isConstructor())
+        {
+            // Structs should not be precision qualified, the individual members may be.
+            // Built-in types on the other hand should be precision qualified.
+            if (mOp != EOpConstructStruct)
+            {
+                setPrecisionFromChildren();
+            }
+        }
+        else
+        {
+            setPrecisionForBuiltInOp();
+        }
+        if (areChildrenConstQualified())
+        {
+            mType.setQualifier(EvqConst);
+        }
+    }
+}
+
 bool TIntermAggregate::areChildrenConstQualified()
 {
-    for (TIntermNode *&child : mSequence)
+    for (TIntermNode *&arg : mArguments)
     {
-        TIntermTyped *typed = child->getAsTyped();
-        if (typed && typed->getQualifier() != EvqConst)
+        TIntermTyped *typedArg = arg->getAsTyped();
+        if (typedArg && typedArg->getQualifier() != EvqConst)
         {
             return false;
         }
@@ -295,8 +331,8 @@ void TIntermAggregate::setPrecisionFromChildren()
     }
 
     TPrecision precision                = EbpUndefined;
-    TIntermSequence::iterator childIter = mSequence.begin();
-    while (childIter != mSequence.end())
+    TIntermSequence::iterator childIter = mArguments.begin();
+    while (childIter != mArguments.end())
     {
         TIntermTyped *typed = (*childIter)->getAsTyped();
         if (typed)
@@ -321,11 +357,13 @@ bool TIntermAggregate::setPrecisionForSpecialBuiltInOp()
     switch (mOp)
     {
         case EOpBitfieldExtract:
-            mType.setPrecision(mSequence[0]->getAsTyped()->getPrecision());
+            mType.setPrecision(mArguments[0]->getAsTyped()->getPrecision());
+            mGotPrecisionFromChildren = true;
             return true;
         case EOpBitfieldInsert:
-            mType.setPrecision(GetHigherPrecision(mSequence[0]->getAsTyped()->getPrecision(),
-                                                  mSequence[1]->getAsTyped()->getPrecision()));
+            mType.setPrecision(GetHigherPrecision(mArguments[0]->getAsTyped()->getPrecision(),
+                                                  mArguments[1]->getAsTyped()->getPrecision()));
+            mGotPrecisionFromChildren = true;
             return true;
         case EOpUaddCarry:
         case EOpUsubBorrow:
@@ -343,17 +381,15 @@ void TIntermAggregate::setBuiltInFunctionPrecision()
     ASSERT(mOp == EOpCallBuiltInFunction);
 
     TPrecision precision = EbpUndefined;
-    TIntermSequence::iterator childIter = mSequence.begin();
-    while (childIter != mSequence.end())
+    for (TIntermNode *arg : mArguments)
     {
-        TIntermTyped *typed = (*childIter)->getAsTyped();
+        TIntermTyped *typed = arg->getAsTyped();
         // ESSL spec section 8: texture functions get their precision from the sampler.
         if (typed && IsSampler(typed->getBasicType()))
         {
             precision = typed->getPrecision();
             break;
         }
-        ++childIter;
     }
     // ESSL 3.0 spec section 8: textureSize always gets highp precision.
     // All other functions that take a sampler are assumed to be texture functions.
@@ -497,8 +533,7 @@ TIntermTyped *TIntermTyped::CreateZero(const TType &type)
         return node;
     }
 
-    TIntermAggregate *constructor = new TIntermAggregate(sh::TypeToConstructorOperator(type));
-    constructor->setType(constType);
+    TIntermSequence *arguments = new TIntermSequence();
 
     if (type.isArray())
     {
@@ -508,7 +543,7 @@ TIntermTyped *TIntermTyped::CreateZero(const TType &type)
         size_t arraySize = type.getArraySize();
         for (size_t i = 0; i < arraySize; ++i)
         {
-            constructor->getSequence()->push_back(CreateZero(elementType));
+            arguments->push_back(CreateZero(elementType));
         }
     }
     else
@@ -518,11 +553,11 @@ TIntermTyped *TIntermTyped::CreateZero(const TType &type)
         TStructure *structure = type.getStruct();
         for (const auto &field : structure->fields())
         {
-            constructor->getSequence()->push_back(CreateZero(*field->type()));
+            arguments->push_back(CreateZero(*field->type()));
         }
     }
 
-    return constructor;
+    return new TIntermAggregate(constType, sh::TypeToConstructorOperator(type), arguments);
 }
 
 // static
@@ -553,12 +588,12 @@ TIntermAggregate::TIntermAggregate(const TIntermAggregate &node)
       mGotPrecisionFromChildren(node.mGotPrecisionFromChildren),
       mFunctionInfo(node.mFunctionInfo)
 {
-    for (TIntermNode *child : node.mSequence)
+    for (TIntermNode *arg : node.mArguments)
     {
-        TIntermTyped *typedChild = child->getAsTyped();
-        ASSERT(typedChild != nullptr);
-        TIntermTyped *childCopy = typedChild->deepCopy();
-        mSequence.push_back(childCopy);
+        TIntermTyped *typedArg = arg->getAsTyped();
+        ASSERT(typedArg != nullptr);
+        TIntermTyped *argCopy = typedArg->deepCopy();
+        mArguments.push_back(argCopy);
     }
 }
 
@@ -1308,8 +1343,7 @@ TIntermTyped *TIntermAggregate::fold(TDiagnostics *diagnostics)
         constArray = TIntermConstantUnion::FoldAggregateBuiltIn(this, diagnostics);
 
     // Nodes may be constant folded without being qualified as constant.
-    TQualifier resultQualifier = areChildrenConstQualified() ? EvqConst : EvqTemporary;
-    return CreateFoldedNode(constArray, this, resultQualifier);
+    return CreateFoldedNode(constArray, this, getQualifier());
 }
 
 //
@@ -2417,32 +2451,32 @@ TConstantUnion *TIntermConstantUnion::FoldAggregateBuiltIn(TIntermAggregate *agg
                                                            TDiagnostics *diagnostics)
 {
     TOperator op              = aggregate->getOp();
-    TIntermSequence *sequence = aggregate->getSequence();
-    unsigned int paramsCount  = static_cast<unsigned int>(sequence->size());
-    std::vector<const TConstantUnion *> unionArrays(paramsCount);
-    std::vector<size_t> objectSizes(paramsCount);
+    TIntermSequence *arguments = aggregate->getSequence();
+    unsigned int argsCount     = static_cast<unsigned int>(arguments->size());
+    std::vector<const TConstantUnion *> unionArrays(argsCount);
+    std::vector<size_t> objectSizes(argsCount);
     size_t maxObjectSize = 0;
     TBasicType basicType = EbtVoid;
     TSourceLoc loc;
-    for (unsigned int i = 0; i < paramsCount; i++)
+    for (unsigned int i = 0; i < argsCount; i++)
     {
-        TIntermConstantUnion *paramConstant = (*sequence)[i]->getAsConstantUnion();
-        ASSERT(paramConstant != nullptr);  // Should be checked already.
+        TIntermConstantUnion *argConstant = (*arguments)[i]->getAsConstantUnion();
+        ASSERT(argConstant != nullptr);  // Should be checked already.
 
         if (i == 0)
         {
-            basicType = paramConstant->getType().getBasicType();
-            loc       = paramConstant->getLine();
+            basicType = argConstant->getType().getBasicType();
+            loc       = argConstant->getLine();
         }
-        unionArrays[i] = paramConstant->getUnionArrayPointer();
-        objectSizes[i] = paramConstant->getType().getObjectSize();
+        unionArrays[i] = argConstant->getUnionArrayPointer();
+        objectSizes[i] = argConstant->getType().getObjectSize();
         if (objectSizes[i] > maxObjectSize)
             maxObjectSize = objectSizes[i];
     }
 
-    if (!(*sequence)[0]->getAsTyped()->isMatrix() && aggregate->getOp() != EOpOuterProduct)
+    if (!(*arguments)[0]->getAsTyped()->isMatrix() && aggregate->getOp() != EOpOuterProduct)
     {
-        for (unsigned int i = 0; i < paramsCount; i++)
+        for (unsigned int i = 0; i < argsCount; i++)
             if (objectSizes[i] != maxObjectSize)
                 unionArrays[i] = Vectorize(*unionArrays[i], maxObjectSize);
     }
@@ -2791,11 +2825,11 @@ TConstantUnion *TIntermConstantUnion::FoldAggregateBuiltIn(TIntermAggregate *agg
 
         case EOpMulMatrixComponentWise:
         {
-            ASSERT(basicType == EbtFloat && (*sequence)[0]->getAsTyped()->isMatrix() &&
-                   (*sequence)[1]->getAsTyped()->isMatrix());
+            ASSERT(basicType == EbtFloat && (*arguments)[0]->getAsTyped()->isMatrix() &&
+                   (*arguments)[1]->getAsTyped()->isMatrix());
             // Perform component-wise matrix multiplication.
             resultArray = new TConstantUnion[maxObjectSize];
-            int size    = (*sequence)[0]->getAsTyped()->getNominalSize();
+            int size    = (*arguments)[0]->getAsTyped()->getNominalSize();
             angle::Matrix<float> result =
                 GetMatrix(unionArrays[0], size).compMult(GetMatrix(unionArrays[1], size));
             SetUnionArrayFromMatrix(result, resultArray);
@@ -2805,8 +2839,8 @@ TConstantUnion *TIntermConstantUnion::FoldAggregateBuiltIn(TIntermAggregate *agg
         case EOpOuterProduct:
         {
             ASSERT(basicType == EbtFloat);
-            size_t numRows = (*sequence)[0]->getAsTyped()->getType().getObjectSize();
-            size_t numCols = (*sequence)[1]->getAsTyped()->getType().getObjectSize();
+            size_t numRows = (*arguments)[0]->getAsTyped()->getType().getObjectSize();
+            size_t numCols = (*arguments)[1]->getAsTyped()->getType().getObjectSize();
             resultArray    = new TConstantUnion[numRows * numCols];
             angle::Matrix<float> result =
                 GetMatrix(unionArrays[0], static_cast<int>(numRows), 1)
@@ -2878,7 +2912,7 @@ TConstantUnion *TIntermConstantUnion::FoldAggregateBuiltIn(TIntermAggregate *agg
             {
                 float x         = unionArrays[0][i].getFConst();
                 float y         = unionArrays[1][i].getFConst();
-                TBasicType type = (*sequence)[2]->getAsTyped()->getType().getBasicType();
+                TBasicType type = (*arguments)[2]->getAsTyped()->getType().getBasicType();
                 if (type == EbtFloat)
                 {
                     // Returns the linear blend of x and y, i.e., x * (1 - a) + y * a.

src/compiler/translator/IntermNode.h

@@ -136,15 +136,6 @@ struct TIntermNodePair
 };
 
 //
-// This is just to help yacc.
-//
-struct TIntermFunctionCallOrMethod
-{
-    TIntermAggregate *argumentsNode;
-    TIntermNode *thisNode;
-};
-
-//
 // Intermediate class for nodes that have a type.
 //
 class TIntermTyped : public TIntermNode
@@ -569,6 +560,15 @@ class TFunctionSymbolInfo
 typedef TVector<TIntermNode *> TIntermSequence;
 typedef TVector<int> TQualifierList;
 
+//
+// This is just to help yacc.
+//
+struct TIntermFunctionCallOrMethod
+{
+    TIntermSequence *arguments;
+    TIntermNode *thisNode;
+};
+
 // Interface for node classes that have an arbitrarily sized set of children.
 class TIntermAggregateBase
 {
@@ -593,19 +593,12 @@ class TIntermAggregateBase
 class TIntermAggregate : public TIntermOperator, public TIntermAggregateBase
 {
   public:
-    TIntermAggregate(TOperator op)
-        : TIntermOperator(op),
-          mUseEmulatedFunction(false),
-          mGotPrecisionFromChildren(false)
-    {
-    }
+    TIntermAggregate(const TType &type, TOperator op, TIntermSequence *arguments);
     ~TIntermAggregate() {}
 
     // Note: only supported for nodes that can be a part of an expression.
     TIntermTyped *deepCopy() const override { return new TIntermAggregate(*this); }
 
-    void setOp(TOperator op) { mOp = op; }
-
     TIntermAggregate *getAsAggregate() override { return this; }
     void traverse(TIntermTraverser *it) override;
     bool replaceChildNode(TIntermNode *original, TIntermNode *replacement) override;
@@ -614,29 +607,24 @@ class TIntermAggregate : public TIntermOperator, public TIntermAggregateBase
     bool hasSideEffects() const override { return true; }
     TIntermTyped *fold(TDiagnostics *diagnostics);
 
-    TIntermSequence *getSequence() override { return &mSequence; }
-    const TIntermSequence *getSequence() const override { return &mSequence; }
+    TIntermSequence *getSequence() override { return &mArguments; }
+    const TIntermSequence *getSequence() const override { return &mArguments; }
 
     void setUseEmulatedFunction() { mUseEmulatedFunction = true; }
     bool getUseEmulatedFunction() { return mUseEmulatedFunction; }
 
-    bool areChildrenConstQualified();
-
-    void setPrecisionForBuiltInOp();
-
-    void setPrecisionFromChildren();
-
-    // Used for built-in functions under EOpCallBuiltInFunction.
-    void setBuiltInFunctionPrecision();
-
     // Returns true if changing parameter precision may affect the return value.
     bool gotPrecisionFromChildren() const { return mGotPrecisionFromChildren; }
 
     TFunctionSymbolInfo *getFunctionSymbolInfo() { return &mFunctionInfo; }
     const TFunctionSymbolInfo *getFunctionSymbolInfo() const { return &mFunctionInfo; }
 
+    // Used for built-in functions under EOpCallBuiltInFunction. The function name in the symbol
+    // info needs to be set before calling this.
+    void setBuiltInFunctionPrecision();
+
   protected:
-    TIntermSequence mSequence;
+    TIntermSequence mArguments;
 
     // If set to true, replace the built-in function call with an emulated one
     // to work around driver bugs. Only for calls mapped to ops other than EOpCall*.
@@ -649,6 +637,14 @@ class TIntermAggregate : public TIntermOperator, public TIntermAggregateBase
   private:
     TIntermAggregate(const TIntermAggregate &node);  // note: not deleted, just private!
 
+    void setTypePrecisionAndQualifier(const TType &type);
+
+    bool areChildrenConstQualified();
+
+    void setPrecisionFromChildren();
+
+    void setPrecisionForBuiltInOp();
+
     // Returns true if precision was set according to special rules for this built-in.
     bool setPrecisionForSpecialBuiltInOp();
 };

src/compiler/translator/ParseContext.cpp

@@ -552,7 +552,7 @@ bool TParseContext::checkIsNotReserved(const TSourceLoc &line, const TString &id
 // something of the type of the constructor.  Also returns the type of
 // the constructor.
 bool TParseContext::checkConstructorArguments(const TSourceLoc &line,
-                                              const TIntermAggregate *argumentsNode,
+                                              const TIntermSequence *arguments,
                                               TOperator op,
                                               const TType &type)
 {
@@ -585,7 +585,7 @@ bool TParseContext::checkConstructorArguments(const TSourceLoc &line,
     bool overFull       = false;
     bool matrixInMatrix = false;
     bool arrayArg       = false;
-    for (TIntermNode *arg : *argumentsNode->getSequence())
+    for (TIntermNode *arg : *arguments)
     {
         const TIntermTyped *argTyped = arg->getAsTyped();
         size += argTyped->getType().getObjectSize();
@@ -604,7 +604,7 @@ bool TParseContext::checkConstructorArguments(const TSourceLoc &line,
     {
         // The size of an unsized constructor should already have been determined.
         ASSERT(!type.isUnsizedArray());
-        if (static_cast<size_t>(type.getArraySize()) != argumentsNode->getSequence()->size())
+        if (static_cast<size_t>(type.getArraySize()) != arguments->size())
         {
             error(line, "array constructor needs one argument per array element", "constructor");
             return false;
@@ -619,7 +619,7 @@ bool TParseContext::checkConstructorArguments(const TSourceLoc &line,
 
     if (matrixInMatrix && !type.isArray())
     {
-        if (argumentsNode->getSequence()->size() != 1)
+        if (arguments->size() != 1)
         {
             error(line, "constructing matrix from matrix can only take one argument",
                   "constructor");
@@ -634,7 +634,7 @@ bool TParseContext::checkConstructorArguments(const TSourceLoc &line,
     }
 
     if (op == EOpConstructStruct && !type.isArray() &&
-        type.getStruct()->fields().size() != argumentsNode->getSequence()->size())
+        type.getStruct()->fields().size() != arguments->size())
     {
         error(line,
               "Number of constructor parameters does not match the number of structure fields",
@@ -652,13 +652,13 @@ bool TParseContext::checkConstructorArguments(const TSourceLoc &line,
         }
     }
 
-    if (argumentsNode->getSequence()->empty())
+    if (arguments->empty())
     {
         error(line, "constructor does not have any arguments", "constructor");
         return false;
     }
 
-    for (TIntermNode *const &argNode : *argumentsNode->getSequence())
+    for (TIntermNode *const &argNode : *arguments)
     {
         TIntermTyped *argTyped = argNode->getAsTyped();
         ASSERT(argTyped != nullptr);
@@ -683,7 +683,7 @@ bool TParseContext::checkConstructorArguments(const TSourceLoc &line,
     {
         // GLSL ES 3.00 section 5.4.4: Each argument must be the same type as the element type of
         // the array.
-        for (TIntermNode *const &argNode : *argumentsNode->getSequence())
+        for (TIntermNode *const &argNode : *arguments)
         {
             const TType &argType = argNode->getAsTyped()->getType();
             // It has already been checked that the argument is not an array.
@@ -698,11 +698,11 @@ bool TParseContext::checkConstructorArguments(const TSourceLoc &line,
     else if (op == EOpConstructStruct)
     {
         const TFieldList &fields = type.getStruct()->fields();
-        const TIntermSequence *args = argumentsNode->getSequence();
 
         for (size_t i = 0; i < fields.size(); i++)
         {
-            if (i >= args->size() || (*args)[i]->getAsTyped()->getType() != *fields[i]->type())
+            if (i >= arguments->size() ||
+                (*arguments)[i]->getAsTyped()->getType() != *fields[i]->type())
             {
                 error(line, "Structure constructor arguments do not match structure fields",
                       "constructor");
@@ -1528,40 +1528,6 @@ TIntermTyped *TParseContext::parseVariableIdentifier(const TSourceLoc &location,
 }
 
 //
-// Look up a function name in the symbol table, and make sure it is a function.
-//
-// Return the function symbol if found, otherwise 0.
-//
-const TFunction *TParseContext::findFunction(const TSourceLoc &line,
-                                             TFunction *call,
-                                             int inputShaderVersion,
-                                             bool *builtIn)
-{
-    // First find by unmangled name to check whether the function name has been
-    // hidden by a variable name or struct typename.
-    // If a function is found, check for one with a matching argument list.
-    const TSymbol *symbol = symbolTable.find(call->getName(), inputShaderVersion, builtIn);
-    if (symbol == 0 || symbol->isFunction())
-    {
-        symbol = symbolTable.find(call->getMangledName(), inputShaderVersion, builtIn);
-    }
-
-    if (symbol == 0)
-    {
-        error(line, "no matching overloaded function found", call->getName().c_str());
-        return 0;
-    }
-
-    if (!symbol->isFunction())
-    {
-        error(line, "function name expected", call->getName().c_str());
-        return 0;
-    }
-
-    return static_cast<const TFunction *>(symbol);
-}
-
-//
 // Initializers show up in several places in the grammar.  Have one set of
 // code to handle them here.
 //
@@ -2690,61 +2656,39 @@ TFunction *TParseContext::addConstructorFunc(const TPublicType &publicTypeIn)
 //
 // Returns a node to add to the tree regardless of if an error was generated or not.
 //
-TIntermTyped *TParseContext::addConstructor(TIntermAggregate *arguments,
+TIntermTyped *TParseContext::addConstructor(TIntermSequence *arguments,
                                             TOperator op,
                                             TType type,
                                             const TSourceLoc &line)
 {
     if (type.isUnsizedArray())
     {
-        if (arguments->getSequence()->empty())
+        if (arguments->empty())
         {
             error(line, "implicitly sized array constructor must have at least one argument", "[]");
             type.setArraySize(1u);
             return TIntermTyped::CreateZero(type);
         }
-        type.setArraySize(static_cast<unsigned int>(arguments->getSequence()->size()));
+        type.setArraySize(static_cast<unsigned int>(arguments->size()));
     }
-    bool constType = true;
-    for (TIntermNode *arg : *arguments->getSequence())
-    {
-        TIntermTyped *argTyped = arg->getAsTyped();
-        ASSERT(argTyped);
-        if (argTyped->getQualifier() != EvqConst)
-            constType = false;
-    }
-    if (constType)
-        type.setQualifier(EvqConst);
 
     if (!checkConstructorArguments(line, arguments, op, type))
     {
         return TIntermTyped::CreateZero(type);
     }
-    // Turn the argument list itself into a constructor
-    arguments->setOp(op);
-    arguments->setLine(line);
-    ASSERT(arguments->isConstructor());
-
-    // Need to set type before setPrecisionFromChildren() because bool doesn't have precision.
-    arguments->setType(type);
-
-    // Structs should not be precision qualified, the individual members may be.
-    // Built-in types on the other hand should be precision qualified.
-    if (op != EOpConstructStruct)
-    {
-        arguments->setPrecisionFromChildren();
-        type.setPrecision(arguments->getPrecision());
-    }
 
-    arguments->setType(type);
+    TIntermAggregate *constructorNode = new TIntermAggregate(type, op, arguments);
+    constructorNode->setLine(line);
+    ASSERT(constructorNode->isConstructor());
 
-    TIntermTyped *constConstructor = intermediate.foldAggregateBuiltIn(arguments, mDiagnostics);
+    TIntermTyped *constConstructor =
+        intermediate.foldAggregateBuiltIn(constructorNode, mDiagnostics);
     if (constConstructor)
     {
         return constConstructor;
     }
 
-    return arguments;
+    return constructorNode;
 }
 
 //
@@ -4320,23 +4264,37 @@ void TParseContext::checkImageMemoryAccessForUserDefinedFunctions(
     }
 }
 
-TIntermAggregate *TParseContext::createEmptyArgumentsNode(const TSourceLoc &loc)
+TIntermSequence *TParseContext::createEmptyArgumentsList()
 {
-    TIntermAggregate *argumentsNode = new TIntermAggregate(EOpNull);
-    argumentsNode->setLine(loc);
-    return argumentsNode;
+    return new TIntermSequence();
 }
 
 TIntermTyped *TParseContext::addFunctionCallOrMethod(TFunction *fnCall,
-                                                     TIntermAggregate *argumentsNode,
+                                                     TIntermSequence *arguments,
                                                      TIntermNode *thisNode,
                                                      const TSourceLoc &loc)
 {
-    TOperator op           = fnCall->getBuiltInOp();
-    TIntermTyped *callNode = nullptr;
-
     if (thisNode != nullptr)
     {
+        return addMethod(fnCall, arguments, thisNode, loc);
+    }
+
+    TOperator op = fnCall->getBuiltInOp();
+    if (op != EOpNull)
+    {
+        return addConstructor(arguments, op, fnCall->getReturnType(), loc);
+    }
+    else
+    {
+        return addNonConstructorFunctionCall(fnCall, arguments, loc);
+    }
+}
+
+TIntermTyped *TParseContext::addMethod(TFunction *fnCall,
+                                       TIntermSequence *arguments,
+                                       TIntermNode *thisNode,
+                                       const TSourceLoc &loc)
+{
     TConstantUnion *unionArray = new TConstantUnion[1];
     int arraySize              = 0;
     TIntermTyped *typedThis    = thisNode->getAsTyped();
@@ -4348,7 +4306,7 @@ TIntermTyped *TParseContext::addFunctionCallOrMethod(TFunction *fnCall,
     {
         error(loc, "invalid method", fnCall->getName().c_str());
     }
-        else if (!argumentsNode->getSequence()->empty())
+    else if (!arguments->empty())
     {
         error(loc, "method takes no parameters", "length");
     }
@@ -4375,28 +4333,33 @@ TIntermTyped *TParseContext::addFunctionCallOrMethod(TFunction *fnCall,
         }
     }
     unionArray->setIConst(arraySize);
-        callNode =
-            intermediate.addConstantUnion(unionArray, TType(EbtInt, EbpUndefined, EvqConst), loc);
-    }
-    else if (op != EOpNull)
+    return intermediate.addConstantUnion(unionArray, TType(EbtInt, EbpUndefined, EvqConst), loc);
+}
+
+TIntermTyped *TParseContext::addNonConstructorFunctionCall(TFunction *fnCall,
+                                                           TIntermSequence *arguments,
+                                                           const TSourceLoc &loc)
+{
+    // First find by unmangled name to check whether the function name has been
+    // hidden by a variable name or struct typename.
+    // If a function is found, check for one with a matching argument list.
+    bool builtIn;
+    const TSymbol *symbol = symbolTable.find(fnCall->getName(), mShaderVersion, &builtIn);
+    if (symbol != nullptr && !symbol->isFunction())
     {
-        // Then this should be a constructor.
-        callNode = addConstructor(argumentsNode, op, fnCall->getReturnType(), loc);
+        error(loc, "function name expected", fnCall->getName().c_str());
     }
     else
     {
-        //
-        // Not a constructor.  Find it in the symbol table.
-        //
-        const TFunction *fnCandidate;
-        bool builtIn;
-        for (TIntermNode *arg : *argumentsNode->getSequence())
+        symbol = symbolTable.find(TFunction::GetMangledNameFromCall(fnCall->getName(), *arguments),
+                                  mShaderVersion, &builtIn);
+        if (symbol == nullptr)
         {
-            fnCall->addParameter(TConstParameter(&arg->getAsTyped()->getType()));
+            error(loc, "no matching overloaded function found", fnCall->getName().c_str());
         }
-        fnCandidate = findFunction(loc, fnCall, mShaderVersion, &builtIn);
-        if (fnCandidate)
+        else
         {
+            const TFunction *fnCandidate = static_cast<const TFunction *>(symbol);
             //
             // A declared function.
             //
@@ -4404,51 +4367,42 @@ TIntermTyped *TParseContext::addFunctionCallOrMethod(TFunction *fnCall,
             {
                 checkCanUseExtension(loc, fnCandidate->getExtension());
             }
-            op = fnCandidate->getBuiltInOp();
+            TOperator op = fnCandidate->getBuiltInOp();
             if (builtIn && op != EOpNull)
             {
                 // A function call mapped to a built-in operation.
                 if (fnCandidate->getParamCount() == 1)
                 {
                     // Treat it like a built-in unary operator.
-                    TIntermNode *unaryParamNode = argumentsNode->getSequence()->front();
-                    callNode = createUnaryMath(op, unaryParamNode->getAsTyped(), loc);
+                    TIntermNode *unaryParamNode = arguments->front();
+                    TIntermTyped *callNode = createUnaryMath(op, unaryParamNode->getAsTyped(), loc);
                     ASSERT(callNode != nullptr);
+                    return callNode;
                 }
                 else
                 {
-                    ASSERT(argumentsNode->getOp() == EOpNull);
-                    argumentsNode->setOp(op);
-                    argumentsNode->setType(fnCandidate->getReturnType());
-                    argumentsNode->setPrecisionForBuiltInOp();
-                    if (argumentsNode->areChildrenConstQualified())
-                    {
-                        argumentsNode->getTypePointer()->setQualifier(EvqConst);
-                    }
+                    TIntermAggregate *callNode =
+                        new TIntermAggregate(fnCandidate->getReturnType(), op, arguments);
+                    callNode->setLine(loc);
 
                     // Some built-in functions have out parameters too.
-                    functionCallLValueErrorCheck(fnCandidate, argumentsNode);
+                    functionCallLValueErrorCheck(fnCandidate, callNode);
 
                     // See if we can constant fold a built-in. Note that this may be possible even
                     // if it is not const-qualified.
                     TIntermTyped *foldedNode =
-                        intermediate.foldAggregateBuiltIn(argumentsNode, mDiagnostics);
+                        intermediate.foldAggregateBuiltIn(callNode, mDiagnostics);
                     if (foldedNode)
                     {
-                        callNode = foldedNode;
-                    }
-                    else
-                    {
-                        callNode = argumentsNode;
+                        return foldedNode;
                     }
+                    return callNode;
                 }
             }
             else
             {
                 // This is a real function call
-                ASSERT(argumentsNode->getOp() == EOpNull);
-                argumentsNode->setType(fnCandidate->getReturnType());
-                argumentsNode->getFunctionSymbolInfo()->setFromFunction(*fnCandidate);
+                TIntermAggregate *callNode = nullptr;
 
                 // If builtIn == false, the function is user defined - could be an overloaded
                 // built-in as well.
@@ -4456,31 +4410,33 @@ TIntermTyped *TParseContext::addFunctionCallOrMethod(TFunction *fnCall,
                 // This needs to happen after the function info including name is set.
                 if (builtIn)
                 {
-                    argumentsNode->setOp(EOpCallBuiltInFunction);
-                    argumentsNode->setBuiltInFunctionPrecision();
-
-                    checkTextureOffsetConst(argumentsNode);
-                    checkImageMemoryAccessForBuiltinFunctions(argumentsNode);
+                    callNode = new TIntermAggregate(fnCandidate->getReturnType(),
+                                                    EOpCallBuiltInFunction, arguments);
+                    // Note that name needs to be set before texture function type is determined.
+                    callNode->getFunctionSymbolInfo()->setFromFunction(*fnCandidate);
+                    callNode->setBuiltInFunctionPrecision();
+                    checkTextureOffsetConst(callNode);
+                    checkImageMemoryAccessForBuiltinFunctions(callNode);
                 }
                 else
                 {
-                    argumentsNode->setOp(EOpCallFunctionInAST);
-                    checkImageMemoryAccessForUserDefinedFunctions(fnCandidate, argumentsNode);
+                    callNode = new TIntermAggregate(fnCandidate->getReturnType(),
+                                                    EOpCallFunctionInAST, arguments);
+                    callNode->getFunctionSymbolInfo()->setFromFunction(*fnCandidate);
+                    checkImageMemoryAccessForUserDefinedFunctions(fnCandidate, callNode);
                 }
 
-                callNode = argumentsNode;
+                functionCallLValueErrorCheck(fnCandidate, callNode);
 
-                functionCallLValueErrorCheck(fnCandidate, argumentsNode);
-            }
+                callNode->setLine(loc);
+
+                return callNode;
             }
-        else
-        {
-            // error message was put out by findFunction()
-            // Put on a dummy node for error recovery
-            callNode = TIntermTyped::CreateZero(TType(EbtFloat, EbpMedium, EvqConst));
         }
     }
-    return callNode;
+
+    // Error message was already written. Put on a dummy node for error recovery.
+    return TIntermTyped::CreateZero(TType(EbtFloat, EbpMedium, EvqConst));
 }
 
 TIntermTyped *TParseContext::addTernarySelection(TIntermTyped *cond,

src/compiler/translator/ParseContext.h

@@ -112,7 +112,7 @@ class TParseContext : angle::NonCopyable
     void checkIsScalarInteger(TIntermTyped *node, const char *token);
     bool checkIsAtGlobalLevel(const TSourceLoc &line, const char *token);
     bool checkConstructorArguments(const TSourceLoc &line,
-                                   const TIntermAggregate *argumentsNode,
+                                   const TIntermSequence *arguments,
                                    TOperator op,
                                    const TType &type);
 
@@ -167,10 +167,6 @@ class TParseContext : angle::NonCopyable
                                const char *value,
                                bool stdgl);
 
-    const TFunction *findFunction(const TSourceLoc &line,
-                                  TFunction *pfnCall,
-                                  int inputShaderVersion,
-                                  bool *builtIn = 0);
     bool executeInitializer(const TSourceLoc &line,
                             const TString &identifier,
                             const TPublicType &pType,
@@ -252,10 +248,6 @@ class TParseContext : angle::NonCopyable
                                    const TString *name,
                                    const TSourceLoc &location);
     TFunction *addConstructorFunc(const TPublicType &publicType);
-    TIntermTyped *addConstructor(TIntermAggregate *arguments,
-                                 TOperator op,
-                                 TType type,
-                                 const TSourceLoc &line);
 
     TIntermTyped *addIndexExpression(TIntermTyped *baseExpression,
                                      const TSourceLoc &location,
@@ -345,12 +337,12 @@ class TParseContext : angle::NonCopyable
     void checkImageMemoryAccessForBuiltinFunctions(TIntermAggregate *functionCall);
     void checkImageMemoryAccessForUserDefinedFunctions(const TFunction *functionDefinition,
                                                        const TIntermAggregate *functionCall);
-    TIntermAggregate *createEmptyArgumentsNode(const TSourceLoc &loc);
+    TIntermSequence *createEmptyArgumentsList();
 
-    // fnCall is only storing the built-in op, and function name or constructor type. argumentsNode
+    // fnCall is only storing the built-in op, and function name or constructor type. arguments
     // has the arguments.
     TIntermTyped *addFunctionCallOrMethod(TFunction *fnCall,
-                                          TIntermAggregate *argumentsNode,
+                                          TIntermSequence *arguments,
                                           TIntermNode *thisNode,
                                           const TSourceLoc &loc);
 
@@ -406,8 +398,18 @@ class TParseContext : angle::NonCopyable
                                 TIntermTyped *left,
                                 TIntermTyped *right,
                                 const TSourceLoc &loc);
-    TIntermTyped *createUnaryMath(TOperator op,
-                                  TIntermTyped *child,
+    TIntermTyped *createUnaryMath(TOperator op, TIntermTyped *child, const TSourceLoc &loc);
+
+    TIntermTyped *addMethod(TFunction *fnCall,
+                            TIntermSequence *arguments,
+                            TIntermNode *thisNode,
+                            const TSourceLoc &loc);
+    TIntermTyped *addConstructor(TIntermSequence *arguments,
+                                 TOperator op,
+                                 TType type,
+                                 const TSourceLoc &line);
+    TIntermTyped *addNonConstructorFunctionCall(TFunction *fnCall,
+                                                TIntermSequence *arguments,
                                                 const TSourceLoc &loc);
 
     // Return true if the checks pass

src/compiler/translator/RemoveDynamicIndexing.cpp

@@ -113,11 +113,9 @@ TIntermTyped *EnsureSignedInt(TIntermTyped *node)
     if (node->getBasicType() == EbtInt)
         return node;
 
-    TIntermAggregate *convertedNode = new TIntermAggregate(EOpConstructInt);
-    convertedNode->setType(TType(EbtInt));
-    convertedNode->getSequence()->push_back(node);
-    convertedNode->setPrecisionFromChildren();
-    return convertedNode;
+    TIntermSequence *arguments = new TIntermSequence();
+    arguments->push_back(node);
+    return new TIntermAggregate(TType(EbtInt), EOpConstructInt, arguments);
 }
 
 TType GetFieldType(const TType &indexedType)
@@ -351,15 +349,16 @@ TIntermAggregate *CreateIndexFunctionCall(TIntermBinary *node,
                                           TIntermTyped *index)
 {
     ASSERT(node->getOp() == EOpIndexIndirect);
-    TIntermAggregate *indexingCall = new TIntermAggregate(EOpCallFunctionInAST);
+    TIntermSequence *arguments = new TIntermSequence();
+    arguments->push_back(indexedNode);
+    arguments->push_back(index);
+
+    TType fieldType = GetFieldType(indexedNode->getType());
+    TIntermAggregate *indexingCall =
+        new TIntermAggregate(fieldType, EOpCallFunctionInAST, arguments);
     indexingCall->setLine(node->getLine());
     indexingCall->getFunctionSymbolInfo()->setNameObj(
         GetIndexFunctionName(indexedNode->getType(), false));
-    indexingCall->getSequence()->push_back(indexedNode);
-    indexingCall->getSequence()->push_back(index);
-
-    TType fieldType = GetFieldType(indexedNode->getType());
-    indexingCall->setType(fieldType);
     return indexingCall;
 }
 

src/compiler/translator/RewriteTexelFetchOffset.cpp

@@ -94,14 +94,11 @@ bool Traverser::visitAggregate(Visit visit, TIntermAggregate *node)
 
     // Create new node that represents the call of function texelFetch.
     // Its argument list will be: texelFetch(sampler, Position+offset, lod).
-    TIntermAggregate *texelFetchNode = new TIntermAggregate(EOpCallBuiltInFunction);
-    texelFetchNode->getFunctionSymbolInfo()->setName(newName);
-    texelFetchNode->getFunctionSymbolInfo()->setId(uniqueId);
-    texelFetchNode->setType(node->getType());
-    texelFetchNode->setLine(node->getLine());
+
+    TIntermSequence *texelFetchArguments = new TIntermSequence();
 
     // sampler
-    texelFetchNode->getSequence()->push_back(sequence->at(0));
+    texelFetchArguments->push_back(sequence->at(0));
 
     // Position
     TIntermTyped *texCoordNode = sequence->at(1)->getAsTyped();
@@ -114,20 +111,15 @@ bool Traverser::visitAggregate(Visit visit, TIntermAggregate *node)
     {
         // For 2DArray samplers, Position is ivec3 and offset is ivec2;
         // So offset must be converted into an ivec3 before being added to Position.
-        TIntermAggregate *constructIVec3Node = new TIntermAggregate(EOpConstructIVec3);
-        constructIVec3Node->setLine(texCoordNode->getLine());
-        constructIVec3Node->setType(texCoordNode->getType());
-
-        constructIVec3Node->getSequence()->push_back(sequence->at(3)->getAsTyped());
+        TIntermSequence *constructOffsetIvecArguments = new TIntermSequence();
+        constructOffsetIvecArguments->push_back(sequence->at(3)->getAsTyped());
 
-        TConstantUnion *zero = new TConstantUnion();
-        zero->setIConst(0);
-        TType *intType = new TType(EbtInt);
+        TIntermTyped *zeroNode = TIntermTyped::CreateZero(TType(EbtInt));
+        constructOffsetIvecArguments->push_back(zeroNode);
 
-        TIntermConstantUnion *zeroNode = new TIntermConstantUnion(zero, *intType);
-        constructIVec3Node->getSequence()->push_back(zeroNode);
-
-        offsetNode = constructIVec3Node;
+        offsetNode = new TIntermAggregate(texCoordNode->getType(), EOpConstructIVec3,
+                                          constructOffsetIvecArguments);
+        offsetNode->setLine(texCoordNode->getLine());
     }
     else
     {
@@ -137,12 +129,18 @@ bool Traverser::visitAggregate(Visit visit, TIntermAggregate *node)
     // Position+offset
     TIntermBinary *add = new TIntermBinary(EOpAdd, texCoordNode, offsetNode);
     add->setLine(texCoordNode->getLine());
-    texelFetchNode->getSequence()->push_back(add);
+    texelFetchArguments->push_back(add);
 
     // lod
-    texelFetchNode->getSequence()->push_back(sequence->at(2));
+    texelFetchArguments->push_back(sequence->at(2));
+
+    ASSERT(texelFetchArguments->size() == 3u);
 
-    ASSERT(texelFetchNode->getSequence()->size() == 3u);
+    TIntermAggregate *texelFetchNode =
+        new TIntermAggregate(node->getType(), EOpCallBuiltInFunction, texelFetchArguments);
+    texelFetchNode->getFunctionSymbolInfo()->setName(newName);
+    texelFetchNode->getFunctionSymbolInfo()->setId(uniqueId);
+    texelFetchNode->setLine(node->getLine());
 
     // Replace the old node by this new node.
     queueReplacement(node, texelFetchNode, OriginalNode::IS_DROPPED);

src/compiler/translator/SeparateExpressionsReturningArrays.cpp

@@ -58,10 +58,9 @@ TIntermBinary *CopyAssignmentNode(TIntermBinary *node)
 // Performs a shallow copy of a constructor/function call node.
 TIntermAggregate *CopyAggregateNode(TIntermAggregate *node)
 {
-    TIntermAggregate *copyNode = new TIntermAggregate(node->getOp());
-    TIntermSequence *copySeq   = copyNode->getSequence();
+    TIntermSequence *copySeq = new TIntermSequence();
     copySeq->insert(copySeq->begin(), node->getSequence()->begin(), node->getSequence()->end());
-    copyNode->setType(node->getType());
+    TIntermAggregate *copyNode = new TIntermAggregate(node->getType(), node->getOp(), copySeq);
     *copyNode->getFunctionSymbolInfo() = *node->getFunctionSymbolInfo();
     return copyNode;
 }

src/compiler/translator/SymbolTable.cpp

@@ -67,6 +67,17 @@ const TString *TFunction::buildMangledName() const
     return NewPoolTString(newName.c_str());
 }
 
+const TString &TFunction::GetMangledNameFromCall(const TString &unmangledFunctionName,
+                                                 TIntermSequence &arguments)
+{
+    std::string newName = mangleName(unmangledFunctionName).c_str();
+    for (TIntermNode *argument : arguments)
+    {
+        newName += argument->getAsTyped()->getType().getMangledName().c_str();
+    }
+    return *NewPoolTString(newName.c_str());
+}
+
 //
 // Symbol table levels are a map of pointers to symbols that have to be deleted.
 //
@@ -160,22 +171,12 @@ TFunction *TSymbolTable::findBuiltInOp(TIntermAggregate *callNode, int shaderVer
     ASSERT(!callNode->isConstructor());
     ASSERT(!callNode->isFunctionCall());
     TString opString = GetOperatorString(callNode->getOp());
-    // The return type doesn't affect the mangled name of the function, which is used to look it up.
-    TType dummyReturnType;
-    TFunction call(&opString, &dummyReturnType, callNode->getOp());
-    TIntermSequence *sequence = callNode->getSequence();
-    for (auto *child : *sequence)
-    {
-        TType *paramType = child->getAsTyped()->getTypePointer();
-        TConstParameter p(paramType);
-        call.addParameter(p);
-    }
-
-    TSymbol *sym = findBuiltIn(call.getMangledName(), shaderVersion);
+    TSymbol *sym     = findBuiltIn(
+        TFunction::GetMangledNameFromCall(opString, *callNode->getSequence()), shaderVersion);
     ASSERT(sym != nullptr && sym->isFunction());
 
     TFunction *builtInFunc = static_cast<TFunction *>(sym);
-    ASSERT(builtInFunc->getParamCount() == sequence->size());
+    ASSERT(builtInFunc->getParamCount() == callNode->getSequence()->size());
     return builtInFunc;
 }
 

src/compiler/translator/SymbolTable.h

@@ -41,8 +41,6 @@
 namespace sh
 {
 
-class TIntermAggregate;
-
 // Symbol base class. (Can build functions or variables out of these...)
 class TSymbol : angle::NonCopyable
 {
@@ -182,6 +180,10 @@ class TFunction : public TSymbol
         }
         return *mangledName;
     }
+
+    static const TString &GetMangledNameFromCall(const TString &unmangledFunctionName,
+                                                 TIntermSequence &arguments);
+
     const TType &getReturnType() const { return *returnType; }
 
     TOperator getBuiltInOp() const { return op; }

src/compiler/translator/glslang.y

@@ -315,7 +315,7 @@ integer_expression
 
 function_call
     : function_call_or_method {
-        $$ = context->addFunctionCallOrMethod($1.function, $1.callOrMethodPair.argumentsNode, $1.callOrMethodPair.thisNode, @1);
+        $$ = context->addFunctionCallOrMethod($1.function, $1.callOrMethodPair.arguments, $1.callOrMethodPair.thisNode, @1);
     }
     ;
 
@@ -343,23 +343,23 @@ function_call_generic
 function_call_header_no_parameters
     : function_call_header VOID_TYPE {
         $$.function = $1;
-        $$.callOrMethodPair.argumentsNode = context->createEmptyArgumentsNode(@1);
+        $$.callOrMethodPair.arguments = context->createEmptyArgumentsList();
     }
     | function_call_header {
         $$.function = $1;
-        $$.callOrMethodPair.argumentsNode = context->createEmptyArgumentsNode(@1);
+        $$.callOrMethodPair.arguments = context->createEmptyArgumentsList();
     }
     ;
 
 function_call_header_with_parameters
     : function_call_header assignment_expression {
-        $$.callOrMethodPair.argumentsNode = context->createEmptyArgumentsNode(@1);
+        $$.callOrMethodPair.arguments = context->createEmptyArgumentsList();
         $$.function = $1;
-        $$.callOrMethodPair.argumentsNode->getSequence()->push_back($2);
+        $$.callOrMethodPair.arguments->push_back($2);
     }
     | function_call_header_with_parameters COMMA assignment_expression {
         $$.function = $1.function;
-        $$.callOrMethodPair.argumentsNode->getSequence()->push_back($3);
+        $$.callOrMethodPair.arguments->push_back($3);
     }
     ;
 

src/compiler/translator/glslang_tab.cpp

@@ -2619,7 +2619,7 @@ yyreduce:
   case 18:
 
     {
-        (yyval.interm.intermTypedNode) = context->addFunctionCallOrMethod((yyvsp[0].interm).function, (yyvsp[0].interm).callOrMethodPair.argumentsNode, (yyvsp[0].interm).callOrMethodPair.thisNode, (yylsp[0]));
+        (yyval.interm.intermTypedNode) = context->addFunctionCallOrMethod((yyvsp[0].interm).function, (yyvsp[0].interm).callOrMethodPair.arguments, (yyvsp[0].interm).callOrMethodPair.thisNode, (yylsp[0]));
     }
 
     break;
@@ -2663,7 +2663,7 @@ yyreduce:
 
     {
         (yyval.interm).function = (yyvsp[-1].interm.function);
-        (yyval.interm).callOrMethodPair.argumentsNode = context->createEmptyArgumentsNode((yylsp[-1]));
+        (yyval.interm).callOrMethodPair.arguments = context->createEmptyArgumentsList();
     }
 
     break;
@@ -2672,7 +2672,7 @@ yyreduce:
 
     {
         (yyval.interm).function = (yyvsp[0].interm.function);
-        (yyval.interm).callOrMethodPair.argumentsNode = context->createEmptyArgumentsNode((yylsp[0]));
+        (yyval.interm).callOrMethodPair.arguments = context->createEmptyArgumentsList();
     }
 
     break;
@@ -2680,9 +2680,9 @@ yyreduce:
   case 25:
 
     {
-        (yyval.interm).callOrMethodPair.argumentsNode = context->createEmptyArgumentsNode((yylsp[-1]));
+        (yyval.interm).callOrMethodPair.arguments = context->createEmptyArgumentsList();
         (yyval.interm).function = (yyvsp[-1].interm.function);
-        (yyval.interm).callOrMethodPair.argumentsNode->getSequence()->push_back((yyvsp[0].interm.intermTypedNode));
+        (yyval.interm).callOrMethodPair.arguments->push_back((yyvsp[0].interm.intermTypedNode));
     }
 
     break;
@@ -2691,7 +2691,7 @@ yyreduce:
 
     {
         (yyval.interm).function = (yyvsp[-2].interm).function;
-        (yyval.interm).callOrMethodPair.argumentsNode->getSequence()->push_back((yyvsp[0].interm.intermTypedNode));
+        (yyval.interm).callOrMethodPair.arguments->push_back((yyvsp[0].interm.intermTypedNode));
     }
 
     break;

src/tests/compiler_tests/IntermNode_test.cpp

@@ -184,14 +184,14 @@ TEST_F(IntermNodeTest, DeepCopyUnaryNode)
 // original. Child nodes also need to be copies with the same attributes as the original children.
 TEST_F(IntermNodeTest, DeepCopyAggregateNode)
 {
-    TType type(EbtFloat, EbpHigh);
-
-    TIntermAggregate *original = new TIntermAggregate(EOpMix);
-    original->setLine(getTestSourceLoc());
-    TIntermSequence *originalSeq = original->getSequence();
+    TIntermSequence *originalSeq = new TIntermSequence();
     originalSeq->push_back(createTestSymbol());
     originalSeq->push_back(createTestSymbol());
     originalSeq->push_back(createTestSymbol());
+    TIntermAggregate *original =
+        new TIntermAggregate(originalSeq->at(0)->getAsTyped()->getType(), EOpMix, originalSeq);
+    original->setLine(getTestSourceLoc());
+
     TIntermTyped *copyTyped = original->deepCopy();
     TIntermAggregate *copy = copyTyped->getAsAggregate();
     ASSERT_NE(nullptr, copy);
@@ -203,7 +203,7 @@ TEST_F(IntermNodeTest, DeepCopyAggregateNode)
     TIntermSequence::size_type i = 0;
     for (auto *copyChild : *copy->getSequence())
     {
-        TIntermNode *originalChild = originalSeq->at(i);
+        TIntermNode *originalChild = original->getSequence()->at(i);
         checkSymbolCopy(originalChild, copyChild);
         ++i;
     }