Reorganize AST traversal utility code

src/compiler.gypi

@@ -60,6 +60,7 @@
             'compiler/translator/FindSymbolNode.h',
             'compiler/translator/FlagStd140Structs.cpp',
             'compiler/translator/FlagStd140Structs.h',
+            'compiler/translator/HashNames.cpp',
             'compiler/translator/HashNames.h',
             'compiler/translator/InfoSink.cpp',
             'compiler/translator/InfoSink.h',
@@ -75,11 +76,16 @@
             'compiler/translator/IntermNodePatternMatcher.cpp',
             'compiler/translator/IntermNodePatternMatcher.h',
             'compiler/translator/IntermTraverse.cpp',
+            'compiler/translator/IntermTraverse.h',
             'compiler/translator/Intermediate.h',
             'compiler/translator/Intermediate.cpp',
+            'compiler/translator/IsASTDepthBelowLimit.cpp',
+            'compiler/translator/IsASTDepthBelowLimit.h',
             'compiler/translator/NodeSearch.h',
             'compiler/translator/Operator.cpp',
             'compiler/translator/Operator.h',
+            'compiler/translator/OutputTree.cpp',
+            'compiler/translator/OutputTree.h',
             'compiler/translator/ParamType.h',
             'compiler/translator/ParseContext.cpp',
             'compiler/translator/ParseContext.h',
@@ -151,7 +157,6 @@
             'compiler/translator/glslang_lex.cpp',
             'compiler/translator/glslang_tab.cpp',
             'compiler/translator/glslang_tab.h',
-            'compiler/translator/intermOut.cpp',
             'compiler/translator/length_limits.h',
             'compiler/translator/util.cpp',
             'compiler/translator/util.h',

src/compiler/translator/ASTMetadataHLSL.cpp

@@ -9,6 +9,7 @@
 #include "compiler/translator/ASTMetadataHLSL.h"
 
 #include "compiler/translator/CallDAG.h"
+#include "compiler/translator/IntermTraverse.h"
 #include "compiler/translator/SymbolTable.h"
 
 namespace sh

src/compiler/translator/AddAndTrueToLoopCondition.cpp

@@ -6,7 +6,7 @@
 
 #include "compiler/translator/AddAndTrueToLoopCondition.h"
 
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/ArrayReturnValueToOutParameter.cpp

@@ -9,7 +9,7 @@
 
 #include "compiler/translator/ArrayReturnValueToOutParameter.h"
 
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/BreakVariableAliasingInInnerLoops.cpp

@@ -10,7 +10,7 @@
 
 #include "BreakVariableAliasingInInnerLoops.h"
 
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 
 // A HLSL compiler developer gave us more details on the root cause and the workaround needed:
 //     The root problem is that if the HLSL compiler is applying aliasing information even on

src/compiler/translator/BuiltInFunctionEmulator.cpp

@@ -4,10 +4,11 @@
 // found in the LICENSE file.
 //
 
-#include "angle_gl.h"
 #include "compiler/translator/BuiltInFunctionEmulator.h"
-#include "compiler/translator/SymbolTable.h"
+#include "angle_gl.h"
 #include "compiler/translator/Cache.h"
+#include "compiler/translator/IntermTraverse.h"
+#include "compiler/translator/SymbolTable.h"
 
 namespace sh
 {

src/compiler/translator/CallDAG.cpp

@@ -11,6 +11,7 @@
 #include "compiler/translator/CallDAG.h"
 
 #include "compiler/translator/Diagnostics.h"
+#include "compiler/translator/IntermTraverse.h"
 #include "compiler/translator/SymbolTable.h"
 
 namespace sh

src/compiler/translator/Compiler.cpp

@@ -20,6 +20,8 @@
 #include "compiler/translator/Initialize.h"
 #include "compiler/translator/InitializeVariables.h"
 #include "compiler/translator/IntermNodePatternMatcher.h"
+#include "compiler/translator/IsASTDepthBelowLimit.h"
+#include "compiler/translator/OutputTree.h"
 #include "compiler/translator/ParseContext.h"
 #include "compiler/translator/PruneEmptyDeclarations.h"
 #include "compiler/translator/RegenerateStructNames.h"
@@ -578,7 +580,7 @@ bool TCompiler::compile(const char *const shaderStrings[],
     if (root)
     {
         if (compileOptions & SH_INTERMEDIATE_TREE)
-            TIntermediate::outputTree(root, infoSink.info);
+            OutputTree(root, infoSink.info);
 
         if (compileOptions & SH_OBJECT_CODE)
             translate(root, compileOptions);
@@ -910,10 +912,7 @@ bool TCompiler::pruneUnusedFunctions(TIntermBlock *root)
 
 bool TCompiler::limitExpressionComplexity(TIntermBlock *root)
 {
-    TMaxDepthTraverser traverser(maxExpressionComplexity + 1);
-    root->traverse(&traverser);
-
-    if (traverser.getMaxDepth() > maxExpressionComplexity)
+    if (!IsASTDepthBelowLimit(root, maxExpressionComplexity))
     {
         mDiagnostics.globalError("Expression too complex.");
         return false;

src/compiler/translator/DeclareAndInitBuiltinsForInstancedMultiview.cpp

@@ -11,7 +11,7 @@
 
 #include "compiler/translator/FindMain.h"
 #include "compiler/translator/InitializeVariables.h"
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 #include "compiler/translator/SymbolTable.h"
 
 namespace sh

src/compiler/translator/EmulateGLFragColorBroadcast.cpp

@@ -14,7 +14,7 @@
 #include "compiler/translator/EmulateGLFragColorBroadcast.h"
 
 #include "compiler/translator/FindMain.h"
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/EmulatePrecision.h

@@ -7,11 +7,11 @@
 #ifndef COMPILER_TRANSLATOR_EMULATE_PRECISION_H_
 #define COMPILER_TRANSLATOR_EMULATE_PRECISION_H_
 
+#include "GLSLANG/ShaderLang.h"
 #include "common/angleutils.h"
 #include "compiler/translator/Compiler.h"
 #include "compiler/translator/InfoSink.h"
-#include "compiler/translator/IntermNode.h"
-#include "GLSLANG/ShaderLang.h"
+#include "compiler/translator/IntermTraverse.h"
 
 // This class gathers all compound assignments from the AST and can then write
 // the functions required for their precision emulation. This way there is no

src/compiler/translator/ExpandIntegerPowExpressions.cpp

@@ -11,7 +11,7 @@
 #include <cmath>
 #include <cstdlib>
 
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/ExtensionGLSL.h

@@ -12,7 +12,7 @@
 #include <set>
 #include <string>
 
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/FindSymbolNode.cpp

@@ -8,7 +8,7 @@
 
 #include "compiler/translator/FindSymbolNode.h"
 
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/FlagStd140Structs.h

@@ -7,7 +7,7 @@
 #ifndef COMPILER_TRANSLATOR_FLAGSTD140STRUCTS_H_
 #define COMPILER_TRANSLATOR_FLAGSTD140STRUCTS_H_
 
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/HashNames.cpp

+//
+// Copyright (c) 2017 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.
+//
+
+#include "compiler/translator/HashNames.h"
+
+namespace sh
+{
+
+TString HashName(const TString &name, ShHashFunction64 hashFunction)
+{
+    if (hashFunction == nullptr || name.empty())
+        return name;
+    khronos_uint64_t number = (*hashFunction)(name.c_str(), name.length());
+    TStringStream stream;
+    stream << HASHED_NAME_PREFIX << std::hex << number;
+    TString hashedName = stream.str();
+    return hashedName;
+}
+
+}  // namespace sh

src/compiler/translator/HashNames.h

@@ -9,10 +9,20 @@
 
 #include <map>
 
-#include "compiler/translator/IntermNode.h"
+#include "GLSLANG/ShaderLang.h"
+#include "compiler/translator/Common.h"
 
 #define HASHED_NAME_PREFIX "webgl_"
 
+namespace sh
+{
+
 typedef std::map<TPersistString, TPersistString> NameMap;
 
+// Return the original name if hash function pointer is NULL;
+// otherwise return the hashed name.
+TString HashName(const TString &name, ShHashFunction64 hashFunction);
+
+}  // namespace sh
+
 #endif  // COMPILER_TRANSLATOR_HASHNAMES_H_

src/compiler/translator/InitializeVariables.cpp

@@ -9,7 +9,7 @@
 #include "angle_gl.h"
 #include "common/debug.h"
 #include "compiler/translator/FindMain.h"
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 #include "compiler/translator/SymbolTable.h"
 #include "compiler/translator/util.h"
 

src/compiler/translator/IntermNode.cpp

@@ -18,7 +18,6 @@
 #include "common/mathutil.h"
 #include "common/matrix_utils.h"
 #include "compiler/translator/Diagnostics.h"
-#include "compiler/translator/HashNames.h"
 #include "compiler/translator/IntermNode.h"
 #include "compiler/translator/SymbolTable.h"
 #include "compiler/translator/util.h"
@@ -3306,149 +3305,4 @@ TConstantUnion *TIntermConstantUnion::FoldAggregateBuiltIn(TIntermAggregate *agg
     return resultArray;
 }
 
-// static
-TString TIntermTraverser::hash(const TString &name, ShHashFunction64 hashFunction)
-{
-    if (hashFunction == nullptr || name.empty())
-        return name;
-    khronos_uint64_t number = (*hashFunction)(name.c_str(), name.length());
-    TStringStream stream;
-    stream << HASHED_NAME_PREFIX << std::hex << number;
-    TString hashedName = stream.str();
-    return hashedName;
-}
-
-bool TIntermTraverser::CompareInsertion(const NodeInsertMultipleEntry &a,
-                                        const NodeInsertMultipleEntry &b)
-{
-    if (a.parent != b.parent)
-    {
-        return a.parent > b.parent;
-    }
-    return a.position > b.position;
-}
-
-void TIntermTraverser::updateTree()
-{
-    // Sort the insertions so that insertion position is decreasing. This way multiple insertions to
-    // the same parent node are handled correctly.
-    std::sort(mInsertions.begin(), mInsertions.end(), CompareInsertion);
-    for (size_t ii = 0; ii < mInsertions.size(); ++ii)
-    {
-        // We can't know here what the intended ordering of two insertions to the same position is,
-        // so it is not supported.
-        ASSERT(ii == 0 || mInsertions[ii].position != mInsertions[ii - 1].position ||
-               mInsertions[ii].parent != mInsertions[ii - 1].parent);
-        const NodeInsertMultipleEntry &insertion = mInsertions[ii];
-        ASSERT(insertion.parent);
-        if (!insertion.insertionsAfter.empty())
-        {
-            bool inserted = insertion.parent->insertChildNodes(insertion.position + 1,
-                                                               insertion.insertionsAfter);
-            ASSERT(inserted);
-        }
-        if (!insertion.insertionsBefore.empty())
-        {
-            bool inserted =
-                insertion.parent->insertChildNodes(insertion.position, insertion.insertionsBefore);
-            ASSERT(inserted);
-        }
-    }
-    for (size_t ii = 0; ii < mReplacements.size(); ++ii)
-    {
-        const NodeUpdateEntry &replacement = mReplacements[ii];
-        ASSERT(replacement.parent);
-        bool replaced =
-            replacement.parent->replaceChildNode(replacement.original, replacement.replacement);
-        ASSERT(replaced);
-
-        if (!replacement.originalBecomesChildOfReplacement)
-        {
-            // In AST traversing, a parent is visited before its children.
-            // After we replace a node, if its immediate child is to
-            // be replaced, we need to make sure we don't update the replaced
-            // node; instead, we update the replacement node.
-            for (size_t jj = ii + 1; jj < mReplacements.size(); ++jj)
-            {
-                NodeUpdateEntry &replacement2 = mReplacements[jj];
-                if (replacement2.parent == replacement.original)
-                    replacement2.parent = replacement.replacement;
-            }
-        }
-    }
-    for (size_t ii = 0; ii < mMultiReplacements.size(); ++ii)
-    {
-        const NodeReplaceWithMultipleEntry &replacement = mMultiReplacements[ii];
-        ASSERT(replacement.parent);
-        bool replaced = replacement.parent->replaceChildNodeWithMultiple(replacement.original,
-                                                                         replacement.replacements);
-        ASSERT(replaced);
-    }
-
-    clearReplacementQueue();
-}
-
-void TIntermTraverser::clearReplacementQueue()
-{
-    mReplacements.clear();
-    mMultiReplacements.clear();
-    mInsertions.clear();
-}
-
-void TIntermTraverser::queueReplacement(TIntermNode *original,
-                                        TIntermNode *replacement,
-                                        OriginalNode originalStatus)
-{
-    queueReplacementWithParent(getParentNode(), original, replacement, originalStatus);
-}
-
-void TIntermTraverser::queueReplacementWithParent(TIntermNode *parent,
-                                                  TIntermNode *original,
-                                                  TIntermNode *replacement,
-                                                  OriginalNode originalStatus)
-{
-    bool originalBecomesChild = (originalStatus == OriginalNode::BECOMES_CHILD);
-    mReplacements.push_back(NodeUpdateEntry(parent, original, replacement, originalBecomesChild));
-}
-
-TName TIntermTraverser::GetInternalFunctionName(const char *name)
-{
-    TString nameStr(name);
-    TName nameObj(nameStr);
-    nameObj.setInternal(true);
-    return nameObj;
-}
-
-TIntermFunctionPrototype *TIntermTraverser::CreateInternalFunctionPrototypeNode(
-    const TType &returnType,
-    const char *name,
-    const TSymbolUniqueId &functionId)
-{
-    TIntermFunctionPrototype *functionNode = new TIntermFunctionPrototype(returnType, functionId);
-    functionNode->getFunctionSymbolInfo()->setNameObj(GetInternalFunctionName(name));
-    return functionNode;
-}
-
-TIntermFunctionDefinition *TIntermTraverser::CreateInternalFunctionDefinitionNode(
-    const TType &returnType,
-    const char *name,
-    TIntermBlock *functionBody,
-    const TSymbolUniqueId &functionId)
-{
-    TIntermFunctionPrototype *prototypeNode =
-        CreateInternalFunctionPrototypeNode(returnType, name, functionId);
-    return new TIntermFunctionDefinition(prototypeNode, functionBody);
-}
-
-TIntermAggregate *TIntermTraverser::CreateInternalFunctionCallNode(
-    const TType &returnType,
-    const char *name,
-    const TSymbolUniqueId &functionId,
-    TIntermSequence *arguments)
-{
-    TIntermAggregate *functionNode = TIntermAggregate::CreateFunctionCall(
-        returnType, functionId, GetInternalFunctionName(name), arguments);
-    return functionNode;
-}
-
 }  // namespace sh

src/compiler/translator/IntermTraverse.cpp

@@ -4,7 +4,8 @@
 // found in the LICENSE file.
 //
 
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
+
 #include "compiler/translator/InfoSink.h"
 #include "compiler/translator/SymbolTable.h"
 
@@ -621,6 +622,152 @@ void TIntermTraverser::traverseAggregate(TIntermAggregate *node)
         visitAggregate(PostVisit, node);
 }
 
+bool TIntermTraverser::CompareInsertion(const NodeInsertMultipleEntry &a,
+                                        const NodeInsertMultipleEntry &b)
+{
+    if (a.parent != b.parent)
+    {
+        return a.parent > b.parent;
+    }
+    return a.position > b.position;
+}
+
+void TIntermTraverser::updateTree()
+{
+    // Sort the insertions so that insertion position is decreasing. This way multiple insertions to
+    // the same parent node are handled correctly.
+    std::sort(mInsertions.begin(), mInsertions.end(), CompareInsertion);
+    for (size_t ii = 0; ii < mInsertions.size(); ++ii)
+    {
+        // We can't know here what the intended ordering of two insertions to the same position is,
+        // so it is not supported.
+        ASSERT(ii == 0 || mInsertions[ii].position != mInsertions[ii - 1].position ||
+               mInsertions[ii].parent != mInsertions[ii - 1].parent);
+        const NodeInsertMultipleEntry &insertion = mInsertions[ii];
+        ASSERT(insertion.parent);
+        if (!insertion.insertionsAfter.empty())
+        {
+            bool inserted = insertion.parent->insertChildNodes(insertion.position + 1,
+                                                               insertion.insertionsAfter);
+            ASSERT(inserted);
+        }
+        if (!insertion.insertionsBefore.empty())
+        {
+            bool inserted =
+                insertion.parent->insertChildNodes(insertion.position, insertion.insertionsBefore);
+            ASSERT(inserted);
+        }
+    }
+    for (size_t ii = 0; ii < mReplacements.size(); ++ii)
+    {
+        const NodeUpdateEntry &replacement = mReplacements[ii];
+        ASSERT(replacement.parent);
+        bool replaced =
+            replacement.parent->replaceChildNode(replacement.original, replacement.replacement);
+        ASSERT(replaced);
+
+        if (!replacement.originalBecomesChildOfReplacement)
+        {
+            // In AST traversing, a parent is visited before its children.
+            // After we replace a node, if its immediate child is to
+            // be replaced, we need to make sure we don't update the replaced
+            // node; instead, we update the replacement node.
+            for (size_t jj = ii + 1; jj < mReplacements.size(); ++jj)
+            {
+                NodeUpdateEntry &replacement2 = mReplacements[jj];
+                if (replacement2.parent == replacement.original)
+                    replacement2.parent = replacement.replacement;
+            }
+        }
+    }
+    for (size_t ii = 0; ii < mMultiReplacements.size(); ++ii)
+    {
+        const NodeReplaceWithMultipleEntry &replacement = mMultiReplacements[ii];
+        ASSERT(replacement.parent);
+        bool replaced = replacement.parent->replaceChildNodeWithMultiple(replacement.original,
+                                                                         replacement.replacements);
+        ASSERT(replaced);
+    }
+
+    clearReplacementQueue();
+}
+
+void TIntermTraverser::clearReplacementQueue()
+{
+    mReplacements.clear();
+    mMultiReplacements.clear();
+    mInsertions.clear();
+}
+
+void TIntermTraverser::queueReplacement(TIntermNode *original,
+                                        TIntermNode *replacement,
+                                        OriginalNode originalStatus)
+{
+    queueReplacementWithParent(getParentNode(), original, replacement, originalStatus);
+}
+
+void TIntermTraverser::queueReplacementWithParent(TIntermNode *parent,
+                                                  TIntermNode *original,
+                                                  TIntermNode *replacement,
+                                                  OriginalNode originalStatus)
+{
+    bool originalBecomesChild = (originalStatus == OriginalNode::BECOMES_CHILD);
+    mReplacements.push_back(NodeUpdateEntry(parent, original, replacement, originalBecomesChild));
+}
+
+TName TIntermTraverser::GetInternalFunctionName(const char *name)
+{
+    TString nameStr(name);
+    TName nameObj(nameStr);
+    nameObj.setInternal(true);
+    return nameObj;
+}
+
+TIntermFunctionPrototype *TIntermTraverser::CreateInternalFunctionPrototypeNode(
+    const TType &returnType,
+    const char *name,
+    const TSymbolUniqueId &functionId)
+{
+    TIntermFunctionPrototype *functionNode = new TIntermFunctionPrototype(returnType, functionId);
+    functionNode->getFunctionSymbolInfo()->setNameObj(GetInternalFunctionName(name));
+    return functionNode;
+}
+
+TIntermFunctionDefinition *TIntermTraverser::CreateInternalFunctionDefinitionNode(
+    const TType &returnType,
+    const char *name,
+    TIntermBlock *functionBody,
+    const TSymbolUniqueId &functionId)
+{
+    TIntermFunctionPrototype *prototypeNode =
+        CreateInternalFunctionPrototypeNode(returnType, name, functionId);
+    return new TIntermFunctionDefinition(prototypeNode, functionBody);
+}
+
+TIntermAggregate *TIntermTraverser::CreateInternalFunctionCallNode(
+    const TType &returnType,
+    const char *name,
+    const TSymbolUniqueId &functionId,
+    TIntermSequence *arguments)
+{
+    TIntermAggregate *functionNode = TIntermAggregate::CreateFunctionCall(
+        returnType, functionId, GetInternalFunctionName(name), arguments);
+    return functionNode;
+}
+
+TLValueTrackingTraverser::TLValueTrackingTraverser(bool preVisit,
+                                                   bool inVisit,
+                                                   bool postVisit,
+                                                   const TSymbolTable &symbolTable,
+                                                   int shaderVersion)
+    : TIntermTraverser(preVisit, inVisit, postVisit),
+      mOperatorRequiresLValue(false),
+      mInFunctionCallOutParameter(false),
+      mSymbolTable(symbolTable),
+      mShaderVersion(shaderVersion)
+{
+}
+
 void TLValueTrackingTraverser::traverseFunctionPrototype(TIntermFunctionPrototype *node)
 {
     TIntermSequence *sequence = node->getSequence();

src/compiler/translator/Intermediate.h

@@ -54,8 +54,6 @@ class TIntermediate
                                     const TVectorFields &fields,
                                     const TSourceLoc &dotLocation);
 
-    static void outputTree(TIntermNode *, TInfoSinkBase &);
-
     TIntermTyped *foldAggregateBuiltIn(TIntermAggregate *aggregate, TDiagnostics *diagnostics);
 
   private:

src/compiler/translator/IsASTDepthBelowLimit.cpp

+//
+// Copyright (c) 2017 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.
+//
+
+#include "compiler/translator/IsASTDepthBelowLimit.h"
+
+#include "compiler/translator/IntermTraverse.h"
+
+namespace sh
+{
+
+namespace
+{
+
+// Traverse the tree and compute max depth. Takes a maximum depth limit to prevent stack overflow.
+class MaxDepthTraverser : public TIntermTraverser
+{
+  public:
+    MaxDepthTraverser(int depthLimit) : TIntermTraverser(true, true, false), mDepthLimit(depthLimit)
+    {
+    }
+
+    bool visitBinary(Visit, TIntermBinary *) override { return depthCheck(); }
+    bool visitUnary(Visit, TIntermUnary *) override { return depthCheck(); }
+    bool visitTernary(Visit, TIntermTernary *) override { return depthCheck(); }
+    bool visitSwizzle(Visit, TIntermSwizzle *) override { return depthCheck(); }
+    bool visitIfElse(Visit, TIntermIfElse *) override { return depthCheck(); }
+    bool visitAggregate(Visit, TIntermAggregate *) override { return depthCheck(); }
+    bool visitBlock(Visit, TIntermBlock *) override { return depthCheck(); }
+    bool visitLoop(Visit, TIntermLoop *) override { return depthCheck(); }
+    bool visitBranch(Visit, TIntermBranch *) override { return depthCheck(); }
+
+  protected:
+    bool depthCheck() const { return mMaxDepth < mDepthLimit; }
+
+    int mDepthLimit;
+};
+
+}  // anonymous namespace
+
+bool IsASTDepthBelowLimit(TIntermNode *root, int maxDepth)
+{
+    MaxDepthTraverser traverser(maxDepth + 1);
+    root->traverse(&traverser);
+
+    return traverser.getMaxDepth() <= maxDepth;
+}
+
+}  // namespace sh

src/compiler/translator/IsASTDepthBelowLimit.h

+//
+// Copyright (c) 2017 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.
+//
+// IsASTDepthBelowLimit: Check whether AST depth is below a specific limit.
+
+#ifndef COMPILER_TRANSLATOR_ISASTDEPTHBELOWLIMIT_H_
+#define COMPILER_TRANSLATOR_ISASTDEPTHBELOWLIMIT_H_
+
+namespace sh
+{
+
+class TIntermNode;
+
+bool IsASTDepthBelowLimit(TIntermNode *root, int maxDepth);
+
+}  // namespace sh
+
+#endif  // COMPILER_TRANSLATOR_ISASTDEPTHBELOWLIMIT_H_

src/compiler/translator/NodeSearch.h

@@ -9,7 +9,7 @@
 #ifndef COMPILER_TRANSLATOR_NODESEARCH_H_
 #define COMPILER_TRANSLATOR_NODESEARCH_H_
 
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/OutputGLSL.cpp

@@ -6,6 +6,8 @@
 
 #include "compiler/translator/OutputGLSL.h"
 
+#include "compiler/translator/Compiler.h"
+
 namespace sh
 {
 

src/compiler/translator/OutputGLSLBase.cpp

@@ -8,6 +8,7 @@
 
 #include "common/debug.h"
 #include "common/mathutil.h"
+#include "compiler/translator/Compiler.h"
 
 #include <cfloat>
 
@@ -1160,7 +1161,7 @@ TString TOutputGLSLBase::hashName(const TName &name)
     NameMap::const_iterator it = mNameMap.find(name.getString().c_str());
     if (it != mNameMap.end())
         return it->second.c_str();
-    TString hashedName                 = TIntermTraverser::hash(name.getString(), mHashFunction);
+    TString hashedName                 = HashName(name.getString(), mHashFunction);
     mNameMap[name.getString().c_str()] = hashedName.c_str();
     return hashedName;
 }

src/compiler/translator/OutputGLSLBase.h

@@ -9,8 +9,9 @@
 
 #include <set>
 
-#include "compiler/translator/IntermNode.h"
-#include "compiler/translator/ParseContext.h"
+#include "compiler/translator/HashNames.h"
+#include "compiler/translator/InfoSink.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/OutputHLSL.h

@@ -13,8 +13,8 @@
 
 #include "angle_gl.h"
 #include "compiler/translator/ASTMetadataHLSL.h"
-#include "compiler/translator/IntermNode.h"
-#include "compiler/translator/ParseContext.h"
+#include "compiler/translator/Compiler.h"
+#include "compiler/translator/IntermTraverse.h"
 
 class BuiltInFunctionEmulator;
 

src/compiler/translator/OutputTree.h

+//
+// Copyright (c) 2017 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.
+//
+// Output the AST intermediate representation of the GLSL code.
+
+#ifndef COMPILER_TRANSLATOR_OUTPUTTREE_H_
+#define COMPILER_TRANSLATOR_OUTPUTTREE_H_
+
+namespace sh
+{
+
+class TIntermNode;
+class TInfoSinkBase;
+
+// Output the AST along with metadata.
+void OutputTree(TIntermNode *root, TInfoSinkBase &out);
+
+}  // namespace sh
+
+#endif  // COMPILER_TRANSLATOR_OUTPUTTREE_H_
\ No newline at end of file

src/compiler/translator/PruneEmptyDeclarations.cpp

@@ -8,7 +8,7 @@
 
 #include "compiler/translator/PruneEmptyDeclarations.h"
 
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/PrunePureLiteralStatements.cpp

@@ -7,7 +7,7 @@
 
 #include "compiler/translator/PrunePureLiteralStatements.h"
 
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/RecordConstantPrecision.cpp

@@ -17,7 +17,7 @@
 #include "compiler/translator/RecordConstantPrecision.h"
 
 #include "compiler/translator/InfoSink.h"
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/RegenerateStructNames.h

@@ -7,7 +7,7 @@
 #ifndef COMPILER_TRANSLATOR_REGENERATESTRUCTNAMES_H_
 #define COMPILER_TRANSLATOR_REGENERATESTRUCTNAMES_H_
 
-#include "compiler/translator/Intermediate.h"
+#include "compiler/translator/IntermTraverse.h"
 #include "compiler/translator/SymbolTable.h"
 
 #include <set>

src/compiler/translator/RemoveDynamicIndexing.cpp

@@ -10,8 +10,8 @@
 #include "compiler/translator/RemoveDynamicIndexing.h"
 
 #include "compiler/translator/InfoSink.h"
-#include "compiler/translator/IntermNode.h"
 #include "compiler/translator/IntermNodePatternMatcher.h"
+#include "compiler/translator/IntermTraverse.h"
 #include "compiler/translator/SymbolTable.h"
 
 namespace sh

src/compiler/translator/RemoveInvariantDeclaration.cpp

@@ -6,7 +6,7 @@
 
 #include "compiler/translator/RemoveInvariantDeclaration.h"
 
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/RemovePow.cpp

@@ -11,7 +11,7 @@
 #include "compiler/translator/RemovePow.h"
 
 #include "compiler/translator/InfoSink.h"
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/RemoveSwitchFallThrough.h

@@ -7,7 +7,7 @@
 #ifndef COMPILER_TRANSLATOR_REMOVESWITCHFALLTHROUGH_H_
 #define COMPILER_TRANSLATOR_REMOVESWITCHFALLTHROUGH_H_
 
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/RewriteDoWhile.cpp

@@ -9,7 +9,7 @@
 
 #include "compiler/translator/RewriteDoWhile.h"
 
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/RewriteTexelFetchOffset.cpp

@@ -9,7 +9,7 @@
 #include "compiler/translator/RewriteTexelFetchOffset.h"
 
 #include "common/angleutils.h"
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 #include "compiler/translator/SymbolTable.h"
 
 namespace sh

src/compiler/translator/RewriteUnaryMinusOperatorFloat.cpp

@@ -6,7 +6,7 @@
 
 #include "compiler/translator/RewriteUnaryMinusOperatorFloat.h"
 
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/RewriteUnaryMinusOperatorInt.cpp

@@ -8,7 +8,7 @@
 
 #include "compiler/translator/RewriteUnaryMinusOperatorInt.h"
 
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/ScalarizeVecAndMatConstructorArgs.cpp

@@ -15,7 +15,7 @@
 
 #include "angle_gl.h"
 #include "common/angleutils.h"
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/SearchSymbol.h

@@ -9,7 +9,7 @@
 #ifndef COMPILER_TRANSLATOR_SEARCHSYMBOL_H_
 #define COMPILER_TRANSLATOR_SEARCHSYMBOL_H_
 
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 #include "compiler/translator/ParseContext.h"
 
 namespace sh

src/compiler/translator/SeparateDeclarations.cpp

@@ -15,7 +15,7 @@
 
 #include "compiler/translator/SeparateDeclarations.h"
 
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/SeparateExpressionsReturningArrays.cpp

@@ -11,8 +11,8 @@
 
 #include "compiler/translator/SeparateExpressionsReturningArrays.h"
 
-#include "compiler/translator/IntermNode.h"
 #include "compiler/translator/IntermNodePatternMatcher.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/SimplifyLoopConditions.cpp

@@ -10,8 +10,8 @@
 
 #include "compiler/translator/SimplifyLoopConditions.h"
 
-#include "compiler/translator/IntermNode.h"
 #include "compiler/translator/IntermNodePatternMatcher.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/SplitSequenceOperator.cpp

@@ -11,8 +11,8 @@
 
 #include "compiler/translator/SplitSequenceOperator.h"
 
-#include "compiler/translator/IntermNode.h"
 #include "compiler/translator/IntermNodePatternMatcher.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/UnfoldShortCircuitAST.h

@@ -11,7 +11,7 @@
 #define COMPILER_TRANSLATOR_UNFOLDSHORTCIRCUITAST_H_
 
 #include "common/angleutils.h"
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/UnfoldShortCircuitToIf.cpp

@@ -11,8 +11,8 @@
 
 #include "compiler/translator/UnfoldShortCircuitToIf.h"
 
-#include "compiler/translator/IntermNode.h"
 #include "compiler/translator/IntermNodePatternMatcher.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/ValidateGlobalInitializer.cpp

@@ -6,6 +6,7 @@
 
 #include "compiler/translator/ValidateGlobalInitializer.h"
 
+#include "compiler/translator/IntermTraverse.h"
 #include "compiler/translator/ParseContext.h"
 
 namespace sh

src/compiler/translator/ValidateLimitations.cpp

@@ -8,6 +8,7 @@
 
 #include "angle_gl.h"
 #include "compiler/translator/Diagnostics.h"
+#include "compiler/translator/IntermTraverse.h"
 #include "compiler/translator/ParseContext.h"
 
 namespace sh

src/compiler/translator/ValidateMultiviewWebGL.cpp

@@ -15,7 +15,7 @@
 #include "angle_gl.h"
 #include "compiler/translator/Diagnostics.h"
 #include "compiler/translator/FindSymbolNode.h"
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 #include "compiler/translator/SymbolTable.h"
 
 namespace sh

src/compiler/translator/ValidateOutputs.cpp

@@ -12,7 +12,7 @@
 #include <set>
 
 #include "compiler/translator/InfoSink.h"
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 #include "compiler/translator/ParseContext.h"
 
 namespace sh

src/compiler/translator/ValidateSwitch.cpp

@@ -6,8 +6,8 @@
 
 #include "compiler/translator/ValidateSwitch.h"
 
-#include "compiler/translator/IntermNode.h"
 #include "compiler/translator/Diagnostics.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/compiler/translator/VariableInfo.cpp

@@ -8,7 +8,8 @@
 
 #include "angle_gl.h"
 #include "common/utilities.h"
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/HashNames.h"
+#include "compiler/translator/IntermTraverse.h"
 #include "compiler/translator/SymbolTable.h"
 #include "compiler/translator/util.h"
 
@@ -440,7 +441,7 @@ void CollectVariablesTraverser::setCommonVariableProperties(const TType &type,
         }
     }
     variableOut->name       = name.c_str();
-    variableOut->mappedName = TIntermTraverser::hash(name, mHashFunction).c_str();
+    variableOut->mappedName = HashName(name, mHashFunction).c_str();
     variableOut->arraySize  = type.getArraySize();
 }
 
@@ -504,8 +505,7 @@ InterfaceBlock CollectVariablesTraverser::recordInterfaceBlock(const TIntermSymb
 
     InterfaceBlock interfaceBlock;
     interfaceBlock.name = blockType->name().c_str();
-    interfaceBlock.mappedName =
-        TIntermTraverser::hash(blockType->name().c_str(), mHashFunction).c_str();
+    interfaceBlock.mappedName = HashName(blockType->name().c_str(), mHashFunction).c_str();
     interfaceBlock.instanceName =
         (blockType->hasInstanceName() ? blockType->instanceName().c_str() : "");
     interfaceBlock.arraySize        = variable.getArraySize();

src/compiler/translator/VersionGLSL.h

@@ -7,7 +7,7 @@
 #ifndef COMPILER_TRANSLATOR_VERSIONGLSL_H_
 #define COMPILER_TRANSLATOR_VERSIONGLSL_H_
 
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 
 #include "compiler/translator/Pragma.h"
 

src/tests/compiler_tests/InitOutputVariables_test.cpp

@@ -10,7 +10,7 @@
 #include "common/angleutils.h"
 
 #include "compiler/translator/FindMain.h"
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 #include "tests/test_utils/ShaderCompileTreeTest.h"
 
 #include <algorithm>

src/tests/compiler_tests/WEBGL_multiview_test.cpp

@@ -8,7 +8,7 @@
 //
 
 #include "GLSLANG/ShaderLang.h"
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 #include "tests/test_utils/ShaderCompileTreeTest.h"
 #include "tests/test_utils/compiler_test.h"
 

src/tests/test_utils/ConstantFoldingTest.h

@@ -13,7 +13,7 @@
 #include <vector>
 
 #include "common/mathutil.h"
-#include "compiler/translator/IntermNode.h"
+#include "compiler/translator/IntermTraverse.h"
 #include "tests/test_utils/ShaderCompileTreeTest.h"
 
 namespace sh

src/tests/test_utils/ShaderCompileTreeTest.cpp

@@ -9,6 +9,7 @@
 
 #include "tests/test_utils/ShaderCompileTreeTest.h"
 
+#include "compiler/translator/IntermTraverse.h"
 #include "compiler/translator/TranslatorESSL.h"
 
 namespace sh

src/tests/test_utils/compiler_test.cpp

@@ -10,6 +10,7 @@
 
 #include "angle_gl.h"
 #include "compiler/translator/Compiler.h"
+#include "compiler/translator/IntermTraverse.h"
 
 namespace sh
 {

src/third_party/compiler/ArrayBoundsClamper.cpp

@@ -25,6 +25,8 @@
 
 #include "third_party/compiler/ArrayBoundsClamper.h"
 
+#include "compiler/translator/IntermTraverse.h"
+
 // The built-in 'clamp' instruction only accepts floats and returns a float.  I
 // iterated a few times with our driver team who examined the output from our
 // compiler - they said the multiple casts generates more code than a single