Track whether a name is internal to ANGLE in a separate class

src/compiler/translator/IntermNode.h

@@ -44,6 +44,23 @@ class TIntermRaw;
 
 class TSymbolTable;
 
+// Encapsulate an identifier string and track whether it is coming from the original shader code
+// (not internal) or from ANGLE (internal). Usually internal names shouldn't be decorated or hashed.
+class TName
+{
+  public:
+    POOL_ALLOCATOR_NEW_DELETE();
+    explicit TName(const TString &name) : mName(name), mIsInternal(false) {}
+
+    const TString &getString() const { return mName; }
+    bool isInternal() const { return mIsInternal; }
+    void setInternal(bool isInternal) { mIsInternal = isInternal; }
+
+  private:
+    TString mName;
+    bool mIsInternal;
+};
+
 //
 // Base class for the tree nodes
 //
@@ -212,22 +229,19 @@ class TIntermSymbol : public TIntermTyped
     // If sym comes from per process globalpoolallocator, then it causes increased memory usage
     // per compile it is essential to use "symbol = sym" to assign to symbol
     TIntermSymbol(int id, const TString &symbol, const TType &type)
-        : TIntermTyped(type),
-          mId(id),
-          mInternal(false)
+        : TIntermTyped(type), mId(id), mSymbol(symbol)
     {
-        mSymbol = symbol;
     }
 
     bool hasSideEffects() const override { return false; }
 
     int getId() const { return mId; }
-    const TString &getSymbol() const { return mSymbol; }
+    const TString &getSymbol() const { return mSymbol.getString(); }
+    const TName &getName() const { return mSymbol; }
 
     void setId(int newId) { mId = newId; }
 
-    bool isInternal() const { return mInternal; }
-    void setInternal(bool isInternal) { mInternal = isInternal; }
+    void setInternal(bool internal) { mSymbol.setInternal(internal); }
 
     void traverse(TIntermTraverser *it) override;
     TIntermSymbol *getAsSymbolNode() override { return this; }
@@ -235,8 +249,7 @@ class TIntermSymbol : public TIntermTyped
 
   protected:
     int mId;
-    bool mInternal;
-    TString mSymbol;
+    TName mSymbol;
 };
 
 // A Raw node stores raw code, that the translator will insert verbatim

src/compiler/translator/OutputHLSL.cpp

@@ -1391,13 +1391,9 @@ void OutputHLSL::visitSymbol(TIntermSymbol *node)
             mUsesFragDepth = true;
             out << "gl_Depth";
         }
-        else if (node->isInternal())
-        {
-            out << name;
-        }
         else
         {
-            out << Decorate(name);
+            out << DecorateIfNeeded(node->getName());
         }
     }
 }
@@ -2849,25 +2845,27 @@ void OutputHLSL::outputLineDirective(int line)
 TString OutputHLSL::argumentString(const TIntermSymbol *symbol)
 {
     TQualifier qualifier = symbol->getQualifier();
-    const TType &type = symbol->getType();
-    TString name = symbol->getSymbol();
+    const TType &type    = symbol->getType();
+    const TName &name    = symbol->getName();
+    TString nameStr;
 
-    if (name.empty())   // HLSL demands named arguments, also for prototypes
+    if (name.getString().empty())  // HLSL demands named arguments, also for prototypes
     {
-        name = "x" + str(mUniqueIndex++);
+        nameStr = "x" + str(mUniqueIndex++);
     }
-    else if (!symbol->isInternal())
+    else
     {
-        name = Decorate(name);
+        nameStr = DecorateIfNeeded(name);
     }
 
     if (mOutputType == SH_HLSL11_OUTPUT && IsSampler(type.getBasicType()))
     {
-        return QualifierString(qualifier) + " " + TextureString(type) + " texture_" + name + ArrayString(type) + ", " +
-               QualifierString(qualifier) + " " + SamplerString(type) + " sampler_" + name + ArrayString(type);
+        return QualifierString(qualifier) + " " + TextureString(type) + " texture_" + nameStr +
+               ArrayString(type) + ", " + QualifierString(qualifier) + " " + SamplerString(type) +
+               " sampler_" + nameStr + ArrayString(type);
     }
 
-    return QualifierString(qualifier) + " " + TypeString(type) + " " + name + ArrayString(type);
+    return QualifierString(qualifier) + " " + TypeString(type) + " " + nameStr + ArrayString(type);
 }
 
 TString OutputHLSL::initializer(const TType &type)

src/compiler/translator/UtilsHLSL.cpp

@@ -8,6 +8,7 @@
 //
 
 #include "compiler/translator/UtilsHLSL.h"
+#include "compiler/translator/IntermNode.h"
 #include "compiler/translator/StructureHLSL.h"
 #include "compiler/translator/SymbolTable.h"
 
@@ -87,6 +88,18 @@ TString Decorate(const TString &string)
     return string;
 }
 
+TString DecorateIfNeeded(const TName &name)
+{
+    if (name.isInternal())
+    {
+        return name.getString();
+    }
+    else
+    {
+        return Decorate(name.getString());
+    }
+}
+
 TString TypeString(const TType &type)
 {
     const TStructure* structure = type.getStruct();

src/compiler/translator/UtilsHLSL.h

@@ -15,6 +15,8 @@
 
 #include "angle_gl.h"
 
+class TName;
+
 namespace sh
 {
 
@@ -22,6 +24,7 @@ TString TextureString(const TType &type);
 TString SamplerString(const TType &type);
 // Prepends an underscore to avoid naming clashes
 TString Decorate(const TString &string);
+TString DecorateIfNeeded(const TName &name);
 TString DecorateUniform(const TString &string, const TType &type);
 TString DecorateField(const TString &string, const TStructure &structure);
 TString DecoratePrivate(const TString &privateText);