Add a class for function lookups

src/compiler.gypi

@@ -69,6 +69,8 @@
             'compiler/translator/FlagStd140Structs.h',
             'compiler/translator/FoldExpressions.cpp',
             'compiler/translator/FoldExpressions.h',
+            'compiler/translator/FunctionLookup.cpp',
+            'compiler/translator/FunctionLookup.h',
             'compiler/translator/HashNames.cpp',
             'compiler/translator/HashNames.h',
             'compiler/translator/ImmutableString.cpp',

src/compiler/translator/EmulatePrecision.cpp

@@ -6,6 +6,8 @@
 
 #include "compiler/translator/EmulatePrecision.h"
 
+#include "compiler/translator/FunctionLookup.h"
+
 #include <memory>
 
 namespace sh
@@ -713,7 +715,7 @@ const TFunction *EmulatePrecision::getInternalFunction(TString *functionName,
                                                        const TVector<TConstParameter> &parameters,
                                                        bool knownToNotHaveSideEffects)
 {
-    TString mangledName = TFunction::GetMangledNameFromCall(*functionName, *arguments);
+    TString mangledName = TFunctionLookup::GetMangledName(*functionName, *arguments);
     if (mInternalFunctions.find(mangledName) == mInternalFunctions.end())
     {
         TFunction *func = new TFunction(mSymbolTable, functionName, new TType(returnType),

src/compiler/translator/FunctionLookup.cpp

+//
+// Copyright (c) 2018 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// FunctionLookup.cpp: Used for storing function calls that have not yet been resolved during
+// parsing.
+//
+
+#include "compiler/translator/FunctionLookup.h"
+
+namespace sh
+{
+
+namespace
+{
+
+const char kFunctionMangledNameSeparator = '(';
+
+}  // anonymous namespace
+
+TFunctionLookup::TFunctionLookup(const TString *name, const TType *constructorType)
+    : mName(name), mConstructorType(constructorType), mThisNode(nullptr)
+{
+}
+
+// static
+TFunctionLookup *TFunctionLookup::CreateConstructor(const TType *type)
+{
+    ASSERT(type != nullptr);
+    return new TFunctionLookup(nullptr, type);
+}
+
+// static
+TFunctionLookup *TFunctionLookup::CreateFunctionCall(const TString *name)
+{
+    ASSERT(name != nullptr);
+    return new TFunctionLookup(name, nullptr);
+}
+
+const TString &TFunctionLookup::name() const
+{
+    return *mName;
+}
+
+const TString &TFunctionLookup::getMangledName() const
+{
+    return GetMangledName(*mName, mArguments);
+}
+
+const TString &TFunctionLookup::GetMangledName(const TString &functionName,
+                                               const TIntermSequence &arguments)
+{
+    std::string newName = functionName.c_str();
+    newName += kFunctionMangledNameSeparator;
+
+    for (TIntermNode *argument : arguments)
+    {
+        newName += argument->getAsTyped()->getType().getMangledName();
+    }
+    return *NewPoolTString(newName.c_str());
+}
+
+bool TFunctionLookup::isConstructor() const
+{
+    return mConstructorType != nullptr;
+}
+
+const TType &TFunctionLookup::constructorType() const
+{
+    return *mConstructorType;
+}
+
+void TFunctionLookup::setThisNode(TIntermTyped *thisNode)
+{
+    mThisNode = thisNode;
+}
+
+TIntermTyped *TFunctionLookup::thisNode() const
+{
+    return mThisNode;
+}
+
+void TFunctionLookup::addArgument(TIntermTyped *argument)
+{
+    mArguments.push_back(argument);
+}
+
+TIntermSequence &TFunctionLookup::arguments()
+{
+    return mArguments;
+}
+
+}  // namespace sh

src/compiler/translator/FunctionLookup.h

+//
+// Copyright (c) 2018 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// FunctionLookup.h: Used for storing function calls that have not yet been resolved during parsing.
+//
+
+#ifndef COMPILER_TRANSLATOR_FUNCTIONLOOKUP_H_
+#define COMPILER_TRANSLATOR_FUNCTIONLOOKUP_H_
+
+#include "compiler/translator/IntermNode.h"
+
+namespace sh
+{
+
+// A function look-up.
+class TFunctionLookup : angle::NonCopyable
+{
+  public:
+    POOL_ALLOCATOR_NEW_DELETE();
+
+    static TFunctionLookup *CreateConstructor(const TType *type);
+    static TFunctionLookup *CreateFunctionCall(const TString *name);
+
+    const TString &name() const;
+    const TString &getMangledName() const;
+    static const TString &GetMangledName(const TString &functionName,
+                                         const TIntermSequence &arguments);
+
+    bool isConstructor() const;
+    const TType &constructorType() const;
+
+    void setThisNode(TIntermTyped *thisNode);
+    TIntermTyped *thisNode() const;
+
+    void addArgument(TIntermTyped *argument);
+    TIntermSequence &arguments();
+
+  private:
+    TFunctionLookup(const TString *name, const TType *constructorType);
+
+    const TString *mName;
+    const TType *const mConstructorType;
+    TIntermTyped *mThisNode;
+    TIntermSequence mArguments;
+};
+
+}  // namespace sh
+
+#endif  // COMPILER_TRANSLATOR_FUNCTIONLOOKUP_H_

src/compiler/translator/IntermNode.cpp

@@ -509,21 +509,6 @@ void TIntermAggregate::setBuiltInFunctionPrecision()
         mType.setPrecision(precision);
 }
 
-TString TIntermAggregate::getSymbolTableMangledName() const
-{
-    ASSERT(!isConstructor());
-    switch (mOp)
-    {
-        case EOpCallInternalRawFunction:
-        case EOpCallBuiltInFunction:
-        case EOpCallFunctionInAST:
-            return TFunction::GetMangledNameFromCall(mFunction->name(), mArguments);
-        default:
-            TString opString = GetOperatorString(mOp);
-            return TFunction::GetMangledNameFromCall(opString, mArguments);
-    }
-}
-
 const char *TIntermAggregate::functionName() const
 {
     ASSERT(!isConstructor());

src/compiler/translator/IntermNode.h

@@ -533,15 +533,6 @@ class TIntermUnary : public TIntermOperator
 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
 {
@@ -599,8 +590,6 @@ class TIntermAggregate : public TIntermOperator, public TIntermAggregateBase
     TIntermSequence *getSequence() override { return &mArguments; }
     const TIntermSequence *getSequence() const override { return &mArguments; }
 
-    TString getSymbolTableMangledName() const;
-
     void setUseEmulatedFunction() { mUseEmulatedFunction = true; }
     bool getUseEmulatedFunction() { return mUseEmulatedFunction; }
 

src/compiler/translator/IntermNode_util.cpp

@@ -8,6 +8,7 @@
 
 #include "compiler/translator/IntermNode_util.h"
 
+#include "compiler/translator/FunctionLookup.h"
 #include "compiler/translator/SymbolTable.h"
 
 namespace sh
@@ -21,7 +22,7 @@ const TFunction *LookUpBuiltInFunction(const TString &name,
                                        const TSymbolTable &symbolTable,
                                        int shaderVersion)
 {
-    TString mangledName = TFunction::GetMangledNameFromCall(name, *arguments);
+    const TString &mangledName = TFunctionLookup::GetMangledName(name, *arguments);
     const TSymbol *symbol = symbolTable.findBuiltIn(mangledName, shaderVersion);
     if (symbol)
     {

src/compiler/translator/ParseContext.cpp

@@ -695,16 +695,16 @@ bool TParseContext::checkIsNotReserved(const TSourceLoc &line, const TString &id
 
 // Make sure the argument types are correct for constructing a specific type.
 bool TParseContext::checkConstructorArguments(const TSourceLoc &line,
-                                              const TIntermSequence *arguments,
+                                              const TIntermSequence &arguments,
                                               const TType &type)
 {
-    if (arguments->empty())
+    if (arguments.empty())
     {
         error(line, "constructor does not have any arguments", "constructor");
         return false;
     }
 
-    for (TIntermNode *arg : *arguments)
+    for (TIntermNode *arg : arguments)
     {
         const TIntermTyped *argTyped = arg->getAsTyped();
         ASSERT(argTyped != nullptr);
@@ -731,14 +731,14 @@ 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.getOutermostArraySize()) != arguments->size())
+        if (static_cast<size_t>(type.getOutermostArraySize()) != arguments.size())
         {
             error(line, "array constructor needs one argument per array element", "constructor");
             return false;
         }
         // 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 : *arguments)
+        for (TIntermNode *const &argNode : arguments)
         {
             const TType &argType = argNode->getAsTyped()->getType();
             if (mShaderVersion < 310 && argType.isArray())
@@ -756,7 +756,7 @@ bool TParseContext::checkConstructorArguments(const TSourceLoc &line,
     else if (type.getBasicType() == EbtStruct)
     {
         const TFieldList &fields = type.getStruct()->fields();
-        if (fields.size() != arguments->size())
+        if (fields.size() != arguments.size())
         {
             error(line,
                   "Number of constructor parameters does not match the number of structure fields",
@@ -766,8 +766,8 @@ bool TParseContext::checkConstructorArguments(const TSourceLoc &line,
 
         for (size_t i = 0; i < fields.size(); i++)
         {
-            if (i >= arguments->size() ||
-                (*arguments)[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");
@@ -787,7 +787,7 @@ bool TParseContext::checkConstructorArguments(const TSourceLoc &line,
         bool full      = false;
         bool overFull  = false;
         bool matrixArg = false;
-        for (TIntermNode *arg : *arguments)
+        for (TIntermNode *arg : arguments)
         {
             const TIntermTyped *argTyped = arg->getAsTyped();
             ASSERT(argTyped != nullptr);
@@ -821,7 +821,7 @@ bool TParseContext::checkConstructorArguments(const TSourceLoc &line,
 
         if (type.isMatrix() && matrixArg)
         {
-            if (arguments->size() != 1)
+            if (arguments.size() != 1)
             {
                 error(line, "constructing matrix from matrix can only take one argument",
                       "constructor");
@@ -3418,19 +3418,12 @@ TFunction *TParseContext::parseFunctionHeader(const TPublicType &type,
     return new TFunction(&symbolTable, name, new TType(type), SymbolType::UserDefined, false);
 }
 
-TFunction *TParseContext::addNonConstructorFunc(const TString *name, const TSourceLoc &loc)
+TFunctionLookup *TParseContext::addNonConstructorFunc(const TString *name)
 {
-    const TType *returnType = StaticType::GetQualified<EbtVoid, EvqTemporary>();
-    // TODO(oetuaho): Some more appropriate data structure than TFunction could be used here. We're
-    // really only interested in the mangled name of the function to look up the actual function
-    // from the symbol table. If we just had the name string and the types of the parameters that
-    // would be enough, but TFunction carries a lot of extra information in addition to that.
-    // Besides function calls we do have to store constructor calls in the same data structure, for
-    // them we need to store a TType.
-    return new TFunction(&symbolTable, name, returnType, SymbolType::NotResolved, false);
+    return TFunctionLookup::CreateFunctionCall(name);
 }
 
-TFunction *TParseContext::addConstructorFunc(const TPublicType &publicType)
+TFunctionLookup *TParseContext::addConstructorFunc(const TPublicType &publicType)
 {
     if (mShaderVersion < 300 && publicType.isArray())
     {
@@ -3450,8 +3443,7 @@ TFunction *TParseContext::addConstructorFunc(const TPublicType &publicType)
               getBasicString(publicType.getBasicType()));
         type->setBasicType(EbtFloat);
     }
-
-    return new TFunction(&symbolTable, nullptr, type, SymbolType::NotResolved, true, EOpConstruct);
+    return TFunctionLookup::CreateConstructor(type);
 }
 
 void TParseContext::checkIsNotUnsizedArray(const TSourceLoc &line,
@@ -3502,18 +3494,19 @@ TParameter TParseContext::parseParameterArrayDeclarator(const TString *name,
     return parseParameterDeclarator(arrayType, name, nameLoc);
 }
 
-bool TParseContext::checkUnsizedArrayConstructorArgumentDimensionality(TIntermSequence *arguments,
-                                                                       TType type,
-                                                                       const TSourceLoc &line)
+bool TParseContext::checkUnsizedArrayConstructorArgumentDimensionality(
+    const TIntermSequence &arguments,
+    TType type,
+    const TSourceLoc &line)
 {
-    if (arguments->empty())
+    if (arguments.empty())
     {
         error(line, "implicitly sized array constructor must have at least one argument", "[]");
         return false;
     }
-    for (TIntermNode *arg : *arguments)
+    for (TIntermNode *arg : arguments)
     {
-        TIntermTyped *element = arg->getAsTyped();
+        const TIntermTyped *element = arg->getAsTyped();
         ASSERT(element);
         size_t dimensionalityFromElement = element->getType().getNumArraySizes() + 1u;
         if (dimensionalityFromElement > type.getNumArraySizes())
@@ -3546,10 +3539,10 @@ bool TParseContext::checkUnsizedArrayConstructorArgumentDimensionality(TIntermSe
 //
 // Returns a node to add to the tree regardless of if an error was generated or not.
 //
-TIntermTyped *TParseContext::addConstructor(TIntermSequence *arguments,
-                                            TType type,
-                                            const TSourceLoc &line)
+TIntermTyped *TParseContext::addConstructor(TFunctionLookup *fnCall, const TSourceLoc &line)
 {
+    TType type                 = fnCall->constructorType();
+    TIntermSequence &arguments = fnCall->arguments();
     if (type.isUnsizedArray())
     {
         if (!checkUnsizedArrayConstructorArgumentDimensionality(arguments, type, line))
@@ -3557,11 +3550,11 @@ TIntermTyped *TParseContext::addConstructor(TIntermSequence *arguments,
             type.sizeUnsizedArrays(nullptr);
             return CreateZeroNode(type);
         }
-        TIntermTyped *firstElement = arguments->at(0)->getAsTyped();
+        TIntermTyped *firstElement = arguments.at(0)->getAsTyped();
         ASSERT(firstElement);
         if (type.getOutermostArraySize() == 0u)
         {
-            type.sizeOutermostUnsizedArray(static_cast<unsigned int>(arguments->size()));
+            type.sizeOutermostUnsizedArray(static_cast<unsigned int>(arguments.size()));
         }
         for (size_t i = 0; i < firstElement->getType().getNumArraySizes(); ++i)
         {
@@ -3578,7 +3571,7 @@ TIntermTyped *TParseContext::addConstructor(TIntermSequence *arguments,
         return CreateZeroNode(type);
     }
 
-    TIntermAggregate *constructorNode = TIntermAggregate::CreateConstructor(type, arguments);
+    TIntermAggregate *constructorNode = TIntermAggregate::CreateConstructor(type, &arguments);
     constructorNode->setLine(line);
 
     return constructorNode->fold(mDiagnostics);
@@ -5744,56 +5737,39 @@ void TParseContext::checkImageMemoryAccessForUserDefinedFunctions(
     }
 }
 
-TIntermSequence *TParseContext::createEmptyArgumentsList()
+TIntermTyped *TParseContext::addFunctionCallOrMethod(TFunctionLookup *fnCall, const TSourceLoc &loc)
 {
-    return new TIntermSequence();
-}
-
-TIntermTyped *TParseContext::addFunctionCallOrMethod(TFunction *fnCall,
-                                                     TIntermSequence *arguments,
-                                                     TIntermNode *thisNode,
-                                                     const TSourceLoc &loc)
-{
-    if (thisNode != nullptr)
+    if (fnCall->thisNode() != nullptr)
     {
-        return addMethod(fnCall->name(), arguments, thisNode, loc);
+        return addMethod(fnCall, loc);
     }
-
-    TOperator op = fnCall->getBuiltInOp();
-    if (op == EOpConstruct)
+    if (fnCall->isConstructor())
     {
-        return addConstructor(arguments, fnCall->getReturnType(), loc);
-    }
-    else
-    {
-        ASSERT(op == EOpNull);
-        return addNonConstructorFunctionCall(fnCall->name(), arguments, loc);
+        return addConstructor(fnCall, loc);
     }
+    return addNonConstructorFunctionCall(fnCall, loc);
 }
 
-TIntermTyped *TParseContext::addMethod(const TString &name,
-                                       TIntermSequence *arguments,
-                                       TIntermNode *thisNode,
-                                       const TSourceLoc &loc)
+TIntermTyped *TParseContext::addMethod(TFunctionLookup *fnCall, const TSourceLoc &loc)
 {
-    TIntermTyped *typedThis    = thisNode->getAsTyped();
+    TIntermTyped *thisNode = fnCall->thisNode();
     // 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
     // mode after a dot, which makes type identifiers to be parsed as FIELD_SELECTION instead.
     // So accessing fnCall->name() below is safe.
-    if (name != "length")
+    if (fnCall->name() != "length")
     {
-        error(loc, "invalid method", name.c_str());
+        error(loc, "invalid method", fnCall->name().c_str());
     }
-    else if (!arguments->empty())
+    else if (!fnCall->arguments().empty())
     {
         error(loc, "method takes no parameters", "length");
     }
-    else if (typedThis == nullptr || !typedThis->isArray())
+    else if (!thisNode->isArray())
     {
         error(loc, "length can only be called on arrays", "length");
     }
-    else if (typedThis->getQualifier() == EvqPerVertexIn &&
+    else if (thisNode->getQualifier() == EvqPerVertexIn &&
              mGeometryShaderInputPrimitiveType == EptUndefined)
     {
         ASSERT(mShaderType == GL_GEOMETRY_SHADER_EXT);
@@ -5801,32 +5777,30 @@ TIntermTyped *TParseContext::addMethod(const TString &name,
     }
     else
     {
-        TIntermUnary *node = new TIntermUnary(EOpArrayLength, typedThis);
+        TIntermUnary *node = new TIntermUnary(EOpArrayLength, thisNode);
         node->setLine(loc);
         return node->fold(mDiagnostics);
     }
     return CreateZeroNode(TType(EbtInt, EbpUndefined, EvqConst));
 }
 
-TIntermTyped *TParseContext::addNonConstructorFunctionCall(const TString &name,
-                                                           TIntermSequence *arguments,
+TIntermTyped *TParseContext::addNonConstructorFunctionCall(TFunctionLookup *fnCall,
                                                            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.
-    const TSymbol *symbol = symbolTable.find(name, mShaderVersion);
+    const TSymbol *symbol = symbolTable.find(fnCall->name(), mShaderVersion);
     if (symbol != nullptr && !symbol->isFunction())
     {
-        error(loc, "function name expected", name.c_str());
+        error(loc, "function name expected", fnCall->name().c_str());
     }
     else
     {
-        symbol =
-            symbolTable.find(TFunction::GetMangledNameFromCall(name, *arguments), mShaderVersion);
+        symbol = symbolTable.find(fnCall->getMangledName(), mShaderVersion);
         if (symbol == nullptr)
         {
-            error(loc, "no matching overloaded function found", name.c_str());
+            error(loc, "no matching overloaded function found", fnCall->name().c_str());
         }
         else
         {
@@ -5839,13 +5813,13 @@ TIntermTyped *TParseContext::addNonConstructorFunctionCall(const TString &name,
                 checkCanUseExtension(loc, fnCandidate->extension());
             }
             TOperator op = fnCandidate->getBuiltInOp();
-            if (fnCandidate->symbolType() == SymbolType::BuiltIn && op != EOpNull)
+            if (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 = arguments->front();
+                    TIntermNode *unaryParamNode = fnCall->arguments().front();
                     TIntermTyped *callNode = createUnaryMath(op, unaryParamNode->getAsTyped(), loc);
                     ASSERT(callNode != nullptr);
                     return callNode;
@@ -5853,7 +5827,7 @@ TIntermTyped *TParseContext::addNonConstructorFunctionCall(const TString &name,
                 else
                 {
                     TIntermAggregate *callNode =
-                        TIntermAggregate::Create(*fnCandidate, op, arguments);
+                        TIntermAggregate::Create(*fnCandidate, op, &fnCall->arguments());
                     callNode->setLine(loc);
 
                     // Some built-in functions have out parameters too.
@@ -5874,7 +5848,8 @@ TIntermTyped *TParseContext::addNonConstructorFunctionCall(const TString &name,
                 // function with no op associated with it.
                 if (fnCandidate->symbolType() == SymbolType::BuiltIn)
                 {
-                    callNode = TIntermAggregate::CreateBuiltInFunctionCall(*fnCandidate, arguments);
+                    callNode = TIntermAggregate::CreateBuiltInFunctionCall(*fnCandidate,
+                                                                           &fnCall->arguments());
                     checkTextureOffsetConst(callNode);
                     checkTextureGather(callNode);
                     checkImageMemoryAccessForBuiltinFunctions(callNode);
@@ -5882,7 +5857,8 @@ TIntermTyped *TParseContext::addNonConstructorFunctionCall(const TString &name,
                 }
                 else
                 {
-                    callNode = TIntermAggregate::CreateFunctionCall(*fnCandidate, arguments);
+                    callNode =
+                        TIntermAggregate::CreateFunctionCall(*fnCandidate, &fnCall->arguments());
                     checkImageMemoryAccessForUserDefinedFunctions(fnCandidate, callNode);
                 }
 

src/compiler/translator/ParseContext.h

@@ -11,6 +11,7 @@
 #include "compiler/translator/Declarator.h"
 #include "compiler/translator/Diagnostics.h"
 #include "compiler/translator/DirectiveHandler.h"
+#include "compiler/translator/FunctionLookup.h"
 #include "compiler/translator/QualifierTypes.h"
 #include "compiler/translator/SymbolTable.h"
 
@@ -120,7 +121,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 TIntermSequence *arguments,
+                                   const TIntermSequence &arguments,
                                    const TType &type);
 
     // Returns a sanitized array size to use (the size is at least 1).
@@ -291,8 +292,8 @@ class TParseContext : angle::NonCopyable
     TFunction *parseFunctionHeader(const TPublicType &type,
                                    const TString *name,
                                    const TSourceLoc &location);
-    TFunction *addNonConstructorFunc(const TString *name, const TSourceLoc &loc);
-    TFunction *addConstructorFunc(const TPublicType &publicType);
+    TFunctionLookup *addNonConstructorFunc(const TString *name);
+    TFunctionLookup *addConstructorFunc(const TPublicType &publicType);
     TParameter parseParameterDeclarator(const TPublicType &publicType,
                                         const TString *name,
                                         const TSourceLoc &nameLoc);
@@ -419,14 +420,10 @@ class TParseContext : angle::NonCopyable
     void checkImageMemoryAccessForUserDefinedFunctions(const TFunction *functionDefinition,
                                                        const TIntermAggregate *functionCall);
     void checkAtomicMemoryBuiltinFunctions(TIntermAggregate *functionCall);
-    TIntermSequence *createEmptyArgumentsList();
 
     // fnCall is only storing the built-in op, and function name or constructor type. arguments
     // has the arguments.
-    TIntermTyped *addFunctionCallOrMethod(TFunction *fnCall,
-                                          TIntermSequence *arguments,
-                                          TIntermNode *thisNode,
-                                          const TSourceLoc &loc);
+    TIntermTyped *addFunctionCallOrMethod(TFunctionLookup *fnCall, const TSourceLoc &loc);
 
     TIntermTyped *addTernarySelection(TIntermTyped *cond,
                                       TIntermTyped *trueExpression,
@@ -523,7 +520,7 @@ class TParseContext : angle::NonCopyable
 
     void checkYuvIsNotSpecified(const TSourceLoc &location, bool yuv);
 
-    bool checkUnsizedArrayConstructorArgumentDimensionality(TIntermSequence *arguments,
+    bool checkUnsizedArrayConstructorArgumentDimensionality(const TIntermSequence &arguments,
                                                             TType type,
                                                             const TSourceLoc &line);
 
@@ -549,16 +546,9 @@ class TParseContext : angle::NonCopyable
                                 const TSourceLoc &loc);
     TIntermTyped *createUnaryMath(TOperator op, TIntermTyped *child, const TSourceLoc &loc);
 
-    TIntermTyped *addMethod(const TString &name,
-                            TIntermSequence *arguments,
-                            TIntermNode *thisNode,
-                            const TSourceLoc &loc);
-    TIntermTyped *addConstructor(TIntermSequence *arguments,
-                                 TType type,
-                                 const TSourceLoc &line);
-    TIntermTyped *addNonConstructorFunctionCall(const TString &name,
-                                                TIntermSequence *arguments,
-                                                const TSourceLoc &loc);
+    TIntermTyped *addMethod(TFunctionLookup *fnCall, const TSourceLoc &loc);
+    TIntermTyped *addConstructor(TFunctionLookup *fnCall, const TSourceLoc &line);
+    TIntermTyped *addNonConstructorFunctionCall(TFunctionLookup *fnCall, const TSourceLoc &loc);
 
     // Return either the original expression or the folded version of the expression in case the
     // folded node will validate the same way during subsequent parsing.

src/compiler/translator/Symbol.cpp

@@ -35,7 +35,7 @@ TSymbol::TSymbol(TSymbolTable *symbolTable,
 {
     ASSERT(mSymbolType == SymbolType::BuiltIn || mExtension == TExtension::UNDEFINED);
     ASSERT(mName != nullptr || mSymbolType == SymbolType::AngleInternal ||
-           mSymbolType == SymbolType::NotResolved || mSymbolType == SymbolType::Empty);
+           mSymbolType == SymbolType::Empty);
     ASSERT(mName == nullptr || *mName != "");
 }
 
@@ -167,19 +167,6 @@ const TString *TFunction::buildMangledName() const
     return NewPoolTString(newName.c_str());
 }
 
-const TString &TFunction::GetMangledNameFromCall(const TString &functionName,
-                                                 const TIntermSequence &arguments)
-{
-    std::string newName = functionName.c_str();
-    newName += kFunctionMangledNameSeparator;
-
-    for (TIntermNode *argument : arguments)
-    {
-        newName += argument->getAsTyped()->getType().getMangledName();
-    }
-    return *NewPoolTString(newName.c_str());
-}
-
 bool TFunction::isMain() const
 {
     return symbolType() == SymbolType::UserDefined && name() == "main";

src/compiler/translator/Symbol.h

@@ -24,8 +24,7 @@ enum class SymbolType
     BuiltIn,
     UserDefined,
     AngleInternal,
-    Empty,  // Meaning symbol without a name.
-    NotResolved
+    Empty  // Meaning symbol without a name.
 };
 
 // Symbol base class. (Can build functions or variables out of these...)
@@ -209,9 +208,6 @@ class TFunction : public TSymbol
         return *mangledName;
     }
 
-    static const TString &GetMangledNameFromCall(const TString &functionName,
-                                                 const TIntermSequence &arguments);
-
     const TType &getReturnType() const { return *returnType; }
 
     TOperator getBuiltInOp() const { return op; }
@@ -236,11 +232,9 @@ class TFunction : public TSymbol
 
     typedef TVector<TConstParameter> TParamList;
     TParamList parameters;
-    const TType *returnType;
+    const TType *const returnType;
     mutable const TString *mangledName;
-    // TODO(oetuaho): Remove op from TFunction once TFunction is not used for looking up builtins or
-    // constructors.
-    TOperator op;
+    const TOperator op;  // Only set for built-ins
     bool defined;
     bool mHasPrototypeDeclaration;
     bool mKnownToNotHaveSideEffects;

src/compiler/translator/glslang.y

@@ -76,7 +76,6 @@ using namespace sh;
         union {
             TIntermNode *intermNode;
             TIntermNodePair nodePair;
-            TIntermFunctionCallOrMethod callOrMethodPair;
             TIntermTyped *intermTypedNode;
             TIntermAggregate *intermAggregate;
             TIntermBlock *intermBlock;
@@ -93,6 +92,7 @@ using namespace sh;
             TLayoutQualifier layoutQualifier;
             TQualifier qualifier;
             TFunction *function;
+            TFunctionLookup *functionLookup;
             TParameter param;
             TDeclarator *declarator;
             TDeclaratorList *declaratorList;
@@ -236,10 +236,12 @@ extern void yyerror(YYLTYPE* yylloc, TParseContext* context, void *scanner, cons
 %type <interm.declarator> struct_declarator
 %type <interm.declaratorList> struct_declarator_list
 %type <interm.fieldList> struct_declaration struct_declaration_list
-%type <interm.function> function_header function_declarator function_identifier
-%type <interm.function> function_header_with_parameters function_call_header
-%type <interm> function_call_header_with_parameters function_call_header_no_parameters function_call_generic function_prototype
-%type <interm> function_call_or_method
+%type <interm.function> function_header function_declarator
+%type <interm.function> function_header_with_parameters
+%type <interm.functionLookup> function_identifier function_call_header
+%type <interm.functionLookup> function_call_header_with_parameters function_call_header_no_parameters
+%type <interm.functionLookup> function_call_generic function_call_or_method
+%type <interm> function_prototype
 
 %type <lex> enter_struct
 
@@ -328,19 +330,18 @@ integer_expression
 
 function_call
     : function_call_or_method {
-        $$ = context->addFunctionCallOrMethod($1.function, $1.callOrMethodPair.arguments, $1.callOrMethodPair.thisNode, @1);
+        $$ = context->addFunctionCallOrMethod($1, @1);
     }
     ;
 
 function_call_or_method
     : function_call_generic {
         $$ = $1;
-        $$.callOrMethodPair.thisNode = nullptr;
     }
     | postfix_expression DOT function_call_generic {
         ES3_OR_NEWER("", @3, "methods");
         $$ = $3;
-        $$.callOrMethodPair.thisNode = $1;
+        $$->setThisNode($1);
     }
     ;
 
@@ -355,24 +356,21 @@ function_call_generic
 
 function_call_header_no_parameters
     : function_call_header VOID_TYPE {
-        $$.function = $1;
-        $$.callOrMethodPair.arguments = context->createEmptyArgumentsList();
+        $$ = $1;
     }
     | function_call_header {
-        $$.function = $1;
-        $$.callOrMethodPair.arguments = context->createEmptyArgumentsList();
+        $$ = $1;
     }
     ;
 
 function_call_header_with_parameters
     : function_call_header assignment_expression {
-        $$.callOrMethodPair.arguments = context->createEmptyArgumentsList();
-        $$.function = $1;
-        $$.callOrMethodPair.arguments->push_back($2);
+        $$ = $1;
+        $$->addArgument($2);
     }
     | function_call_header_with_parameters COMMA assignment_expression {
-        $$.function = $1.function;
-        $$.callOrMethodPair.arguments->push_back($3);
+        $$ = $1;
+        $$->addArgument($3);
     }
     ;
 
@@ -389,10 +387,10 @@ function_identifier
         $$ = context->addConstructorFunc($1);
     }
     | IDENTIFIER {
-        $$ = context->addNonConstructorFunc($1.string, @1);
+        $$ = context->addNonConstructorFunc($1.string);
     }
     | FIELD_SELECTION {
-        $$ = context->addNonConstructorFunc($1.string, @1);
+        $$ = context->addNonConstructorFunc($1.string);
     }
     ;
 

src/compiler/translator/glslang_tab.cpp

@@ -317,7 +317,6 @@ union YYSTYPE
         union {
             TIntermNode *intermNode;
             TIntermNodePair nodePair;
-            TIntermFunctionCallOrMethod callOrMethodPair;
             TIntermTyped *intermTypedNode;
             TIntermAggregate *intermAggregate;
             TIntermBlock *intermBlock;
@@ -334,6 +333,7 @@ union YYSTYPE
             TLayoutQualifier layoutQualifier;
             TQualifier qualifier;
             TFunction *function;
+            TFunctionLookup *functionLookup;
             TParameter param;
             TDeclarator *declarator;
             TDeclaratorList *declaratorList;
@@ -743,36 +743,36 @@ static const yytype_uint8 yytranslate[] =
   /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
 static const yytype_uint16 yyrline[] =
 {
-       0,   250,   250,   251,   254,   264,   267,   272,   277,   282,
-     287,   296,   302,   305,   308,   311,   314,   317,   323,   330,
-     336,   340,   348,   351,   357,   361,   368,   373,   380,   388,
-     391,   394,   400,   403,   406,   409,   416,   417,   418,   419,
-     427,   428,   431,   434,   441,   442,   445,   451,   452,   456,
-     463,   464,   467,   470,   473,   479,   480,   483,   489,   490,
-     497,   498,   505,   506,   513,   514,   520,   521,   527,   528,
-     534,   535,   541,   542,   548,   549,   550,   551,   555,   556,
-     557,   561,   565,   569,   573,   580,   583,   589,   596,   603,
-     606,   609,   613,   617,   621,   625,   629,   636,   643,   646,
-     653,   661,   678,   688,   691,   697,   701,   705,   709,   716,
-     723,   726,   730,   734,   739,   746,   750,   754,   758,   763,
-     770,   774,   780,   783,   789,   793,   800,   806,   810,   814,
-     817,   820,   829,   834,   838,   841,   844,   847,   850,   854,
-     857,   861,   864,   867,   870,   873,   876,   883,   890,   893,
-     896,   902,   909,   912,   918,   921,   924,   927,   933,   936,
-     943,   948,   955,   960,   971,   974,   977,   980,   983,   986,
-     990,   994,   998,  1002,  1006,  1010,  1014,  1018,  1022,  1026,
-    1030,  1034,  1038,  1042,  1046,  1050,  1054,  1058,  1062,  1066,
-    1070,  1077,  1080,  1083,  1086,  1089,  1092,  1095,  1098,  1101,
-    1104,  1107,  1110,  1113,  1116,  1119,  1122,  1125,  1128,  1131,
-    1141,  1148,  1155,  1158,  1161,  1164,  1167,  1170,  1173,  1176,
-    1179,  1182,  1185,  1188,  1191,  1194,  1197,  1205,  1205,  1208,
-    1208,  1214,  1217,  1223,  1226,  1233,  1237,  1243,  1246,  1252,
-    1256,  1260,  1261,  1267,  1268,  1269,  1270,  1271,  1272,  1273,
-    1277,  1281,  1281,  1281,  1288,  1289,  1293,  1293,  1294,  1294,
-    1299,  1303,  1310,  1314,  1321,  1322,  1326,  1332,  1336,  1345,
-    1345,  1352,  1355,  1361,  1365,  1371,  1371,  1376,  1376,  1380,
-    1380,  1388,  1391,  1397,  1400,  1406,  1410,  1417,  1420,  1423,
-    1426,  1429,  1437,  1443,  1449,  1452,  1458,  1458
+       0,   252,   252,   253,   256,   266,   269,   274,   279,   284,
+     289,   298,   304,   307,   310,   313,   316,   319,   325,   332,
+     338,   341,   349,   352,   358,   361,   367,   371,   378,   386,
+     389,   392,   398,   401,   404,   407,   414,   415,   416,   417,
+     425,   426,   429,   432,   439,   440,   443,   449,   450,   454,
+     461,   462,   465,   468,   471,   477,   478,   481,   487,   488,
+     495,   496,   503,   504,   511,   512,   518,   519,   525,   526,
+     532,   533,   539,   540,   546,   547,   548,   549,   553,   554,
+     555,   559,   563,   567,   571,   578,   581,   587,   594,   601,
+     604,   607,   611,   615,   619,   623,   627,   634,   641,   644,
+     651,   659,   676,   686,   689,   695,   699,   703,   707,   714,
+     721,   724,   728,   732,   737,   744,   748,   752,   756,   761,
+     768,   772,   778,   781,   787,   791,   798,   804,   808,   812,
+     815,   818,   827,   832,   836,   839,   842,   845,   848,   852,
+     855,   859,   862,   865,   868,   871,   874,   881,   888,   891,
+     894,   900,   907,   910,   916,   919,   922,   925,   931,   934,
+     941,   946,   953,   958,   969,   972,   975,   978,   981,   984,
+     988,   992,   996,  1000,  1004,  1008,  1012,  1016,  1020,  1024,
+    1028,  1032,  1036,  1040,  1044,  1048,  1052,  1056,  1060,  1064,
+    1068,  1075,  1078,  1081,  1084,  1087,  1090,  1093,  1096,  1099,
+    1102,  1105,  1108,  1111,  1114,  1117,  1120,  1123,  1126,  1129,
+    1139,  1146,  1153,  1156,  1159,  1162,  1165,  1168,  1171,  1174,
+    1177,  1180,  1183,  1186,  1189,  1192,  1195,  1203,  1203,  1206,
+    1206,  1212,  1215,  1221,  1224,  1231,  1235,  1241,  1244,  1250,
+    1254,  1258,  1259,  1265,  1266,  1267,  1268,  1269,  1270,  1271,
+    1275,  1279,  1279,  1279,  1286,  1287,  1291,  1291,  1292,  1292,
+    1297,  1301,  1308,  1312,  1319,  1320,  1324,  1330,  1334,  1343,
+    1343,  1350,  1353,  1359,  1363,  1369,  1369,  1374,  1374,  1378,
+    1378,  1386,  1389,  1395,  1398,  1404,  1408,  1415,  1418,  1421,
+    1424,  1427,  1435,  1441,  1447,  1450,  1456,  1456
 };
 #endif
 
@@ -2636,7 +2636,7 @@ yyreduce:
   case 19:
 
     {
-        (yyval.interm.intermTypedNode) = context->addFunctionCallOrMethod((yyvsp[0].interm).function, (yyvsp[0].interm).callOrMethodPair.arguments, (yyvsp[0].interm).callOrMethodPair.thisNode, (yylsp[0]));
+        (yyval.interm.intermTypedNode) = context->addFunctionCallOrMethod((yyvsp[0].interm.functionLookup), (yylsp[0]));
     }
 
     break;
@@ -2644,8 +2644,7 @@ yyreduce:
   case 20:
 
     {
-        (yyval.interm) = (yyvsp[0].interm);
-        (yyval.interm).callOrMethodPair.thisNode = nullptr;
+        (yyval.interm.functionLookup) = (yyvsp[0].interm.functionLookup);
     }
 
     break;
@@ -2654,8 +2653,8 @@ yyreduce:
 
     {
         ES3_OR_NEWER("", (yylsp[0]), "methods");
-        (yyval.interm) = (yyvsp[0].interm);
-        (yyval.interm).callOrMethodPair.thisNode = (yyvsp[-2].interm.intermTypedNode);
+        (yyval.interm.functionLookup) = (yyvsp[0].interm.functionLookup);
+        (yyval.interm.functionLookup)->setThisNode((yyvsp[-2].interm.intermTypedNode));
     }
 
     break;
@@ -2663,7 +2662,7 @@ yyreduce:
   case 22:
 
     {
-        (yyval.interm) = (yyvsp[-1].interm);
+        (yyval.interm.functionLookup) = (yyvsp[-1].interm.functionLookup);
     }
 
     break;
@@ -2671,7 +2670,7 @@ yyreduce:
   case 23:
 
     {
-        (yyval.interm) = (yyvsp[-1].interm);
+        (yyval.interm.functionLookup) = (yyvsp[-1].interm.functionLookup);
     }
 
     break;
@@ -2679,8 +2678,7 @@ yyreduce:
   case 24:
 
     {
-        (yyval.interm).function = (yyvsp[-1].interm.function);
-        (yyval.interm).callOrMethodPair.arguments = context->createEmptyArgumentsList();
+        (yyval.interm.functionLookup) = (yyvsp[-1].interm.functionLookup);
     }
 
     break;
@@ -2688,8 +2686,7 @@ yyreduce:
   case 25:
 
     {
-        (yyval.interm).function = (yyvsp[0].interm.function);
-        (yyval.interm).callOrMethodPair.arguments = context->createEmptyArgumentsList();
+        (yyval.interm.functionLookup) = (yyvsp[0].interm.functionLookup);
     }
 
     break;
@@ -2697,9 +2694,8 @@ yyreduce:
   case 26:
 
     {
-        (yyval.interm).callOrMethodPair.arguments = context->createEmptyArgumentsList();
-        (yyval.interm).function = (yyvsp[-1].interm.function);
-        (yyval.interm).callOrMethodPair.arguments->push_back((yyvsp[0].interm.intermTypedNode));
+        (yyval.interm.functionLookup) = (yyvsp[-1].interm.functionLookup);
+        (yyval.interm.functionLookup)->addArgument((yyvsp[0].interm.intermTypedNode));
     }
 
     break;
@@ -2707,8 +2703,8 @@ yyreduce:
   case 27:
 
     {
-        (yyval.interm).function = (yyvsp[-2].interm).function;
-        (yyval.interm).callOrMethodPair.arguments->push_back((yyvsp[0].interm.intermTypedNode));
+        (yyval.interm.functionLookup) = (yyvsp[-2].interm.functionLookup);
+        (yyval.interm.functionLookup)->addArgument((yyvsp[0].interm.intermTypedNode));
     }
 
     break;
@@ -2716,7 +2712,7 @@ yyreduce:
   case 28:
 
     {
-        (yyval.interm.function) = (yyvsp[-1].interm.function);
+        (yyval.interm.functionLookup) = (yyvsp[-1].interm.functionLookup);
     }
 
     break;
@@ -2724,7 +2720,7 @@ yyreduce:
   case 29:
 
     {
-        (yyval.interm.function) = context->addConstructorFunc((yyvsp[0].interm.type));
+        (yyval.interm.functionLookup) = context->addConstructorFunc((yyvsp[0].interm.type));
     }
 
     break;
@@ -2732,7 +2728,7 @@ yyreduce:
   case 30:
 
     {
-        (yyval.interm.function) = context->addNonConstructorFunc((yyvsp[0].lex).string, (yylsp[0]));
+        (yyval.interm.functionLookup) = context->addNonConstructorFunc((yyvsp[0].lex).string);
     }
 
     break;
@@ -2740,7 +2736,7 @@ yyreduce:
   case 31:
 
     {
-        (yyval.interm.function) = context->addNonConstructorFunc((yyvsp[0].lex).string, (yylsp[0]));
+        (yyval.interm.functionLookup) = context->addNonConstructorFunc((yyvsp[0].lex).string);
     }
 
     break;

src/compiler/translator/glslang_tab.h

@@ -228,7 +228,6 @@ union YYSTYPE
         union {
             TIntermNode *intermNode;
             TIntermNodePair nodePair;
-            TIntermFunctionCallOrMethod callOrMethodPair;
             TIntermTyped *intermTypedNode;
             TIntermAggregate *intermAggregate;
             TIntermBlock *intermBlock;
@@ -245,6 +244,7 @@ union YYSTYPE
             TLayoutQualifier layoutQualifier;
             TQualifier qualifier;
             TFunction *function;
+            TFunctionLookup *functionLookup;
             TParameter param;
             TDeclarator *declarator;
             TDeclaratorList *declaratorList;

src/tests/test_utils/compiler_test.cpp

@@ -10,6 +10,7 @@
 
 #include "angle_gl.h"
 #include "compiler/translator/Compiler.h"
+#include "compiler/translator/FunctionLookup.h"
 #include "compiler/translator/IntermTraverse.h"
 
 namespace sh
@@ -18,6 +19,22 @@ namespace sh
 namespace
 {
 
+const TString &GetSymbolTableMangledName(TIntermAggregate *node)
+{
+    ASSERT(!node->isConstructor());
+    switch (node->getOp())
+    {
+        case EOpCallInternalRawFunction:
+        case EOpCallBuiltInFunction:
+        case EOpCallFunctionInAST:
+            return TFunctionLookup::GetMangledName(node->getFunction()->name(),
+                                                   *node->getSequence());
+        default:
+            TString opString = GetOperatorString(node->getOp());
+            return TFunctionLookup::GetMangledName(opString, *node->getSequence());
+    }
+}
+
 class FunctionCallFinder : public TIntermTraverser
 {
   public:
@@ -30,7 +47,7 @@ class FunctionCallFinder : public TIntermTraverser
 
     bool visitAggregate(Visit visit, TIntermAggregate *node) override
     {
-        if (node->isFunctionCall() && node->getSymbolTableMangledName() == mFunctionMangledName)
+        if (node->isFunctionCall() && GetSymbolTableMangledName(node) == mFunctionMangledName)
         {
             mNodeFound = node;
             return false;