Split TIntermInvariantDeclaration from TIntermAggregate

src/compiler/translator/EmulatePrecision.cpp

@@ -623,6 +623,11 @@ bool EmulatePrecision::visitDeclaration(Visit visit, TIntermDeclaration *node)
     return true;
 }
 
+bool EmulatePrecision::visitInvariantDeclaration(Visit visit, TIntermInvariantDeclaration *node)
+{
+    return false;
+}
+
 bool EmulatePrecision::visitAggregate(Visit visit, TIntermAggregate *node)
 {
     bool visitChildren = true;
@@ -636,9 +641,6 @@ bool EmulatePrecision::visitAggregate(Visit visit, TIntermAggregate *node)
         case EOpParameters:
             visitChildren = false;
             break;
-        case EOpInvariantDeclaration:
-            visitChildren = false;
-            break;
         case EOpFunctionCall:
         {
             // Function call.

src/compiler/translator/EmulatePrecision.h

@@ -30,6 +30,7 @@ class EmulatePrecision : public TLValueTrackingTraverser
     bool visitBinary(Visit visit, TIntermBinary *node) override;
     bool visitUnary(Visit visit, TIntermUnary *node) override;
     bool visitAggregate(Visit visit, TIntermAggregate *node) override;
+    bool visitInvariantDeclaration(Visit visit, TIntermInvariantDeclaration *node) override;
     bool visitDeclaration(Visit visit, TIntermDeclaration *node) override;
 
     void writeEmulationHelpers(TInfoSinkBase &sink,

src/compiler/translator/IntermNode.cpp

@@ -203,6 +203,12 @@ bool TIntermUnary::replaceChildNode(TIntermNode *original, TIntermNode *replacem
     return false;
 }
 
+bool TIntermInvariantDeclaration::replaceChildNode(TIntermNode *original, TIntermNode *replacement)
+{
+    REPLACE_IF_IS(mSymbol, TIntermSymbol, original, replacement);
+    return false;
+}
+
 bool TIntermFunctionDefinition::replaceChildNode(TIntermNode *original, TIntermNode *replacement)
 {
     REPLACE_IF_IS(mParameters, TIntermAggregate, original, replacement);
@@ -775,6 +781,13 @@ TIntermBinary::TIntermBinary(TOperator op, TIntermTyped *left, TIntermTyped *rig
     promote();
 }
 
+TIntermInvariantDeclaration::TIntermInvariantDeclaration(TIntermSymbol *symbol, const TSourceLoc &line)
+    : TIntermNode(), mSymbol(symbol)
+{
+    ASSERT(symbol);
+    setLine(line);
+}
+
 TIntermTernary::TIntermTernary(TIntermTyped *cond,
                                TIntermTyped *trueExpression,
                                TIntermTyped *falseExpression)

src/compiler/translator/IntermNode.h

@@ -35,6 +35,7 @@ class TDiagnostics;
 class TIntermTraverser;
 class TIntermAggregate;
 class TIntermBlock;
+class TIntermInvariantDeclaration;
 class TIntermDeclaration;
 class TIntermFunctionDefinition;
 class TIntermSwizzle;
@@ -724,6 +725,21 @@ class TIntermDeclaration : public TIntermNode, public TIntermAggregateBase
     TIntermSequence mDeclarators;
 };
 
+// Specialized declarations for attributing invariance.
+class TIntermInvariantDeclaration : public TIntermNode
+{
+  public:
+    TIntermInvariantDeclaration(TIntermSymbol *symbol, const TSourceLoc &line);
+
+    TIntermSymbol *getSymbol() { return mSymbol; }
+
+    void traverse(TIntermTraverser *it) override;
+    bool replaceChildNode(TIntermNode *original, TIntermNode *replacement) override;
+
+  private:
+    TIntermSymbol *mSymbol;
+};
+
 // For ternary operators like a ? b : c.
 class TIntermTernary : public TIntermTyped
 {
@@ -866,6 +882,10 @@ class TIntermTraverser : angle::NonCopyable
     }
     virtual bool visitAggregate(Visit visit, TIntermAggregate *node) { return true; }
     virtual bool visitBlock(Visit visit, TIntermBlock *node) { return true; }
+    virtual bool visitInvariantDeclaration(Visit visit, TIntermInvariantDeclaration *node)
+    {
+        return true;
+    }
     virtual bool visitDeclaration(Visit visit, TIntermDeclaration *node) { return true; }
     virtual bool visitLoop(Visit visit, TIntermLoop *node) { return true; }
     virtual bool visitBranch(Visit visit, TIntermBranch *node) { return true; }
@@ -886,6 +906,7 @@ class TIntermTraverser : angle::NonCopyable
     virtual void traverseFunctionDefinition(TIntermFunctionDefinition *node);
     virtual void traverseAggregate(TIntermAggregate *node);
     virtual void traverseBlock(TIntermBlock *node);
+    virtual void traverseInvariantDeclaration(TIntermInvariantDeclaration *node);
     virtual void traverseDeclaration(TIntermDeclaration *node);
     virtual void traverseLoop(TIntermLoop *node);
     virtual void traverseBranch(TIntermBranch *node);

src/compiler/translator/IntermTraverse.cpp

@@ -71,6 +71,11 @@ void TIntermBlock::traverse(TIntermTraverser *it)
     it->traverseBlock(this);
 }
 
+void TIntermInvariantDeclaration::traverse(TIntermTraverser *it)
+{
+    it->traverseInvariantDeclaration(this);
+}
+
 void TIntermDeclaration::traverse(TIntermTraverser *it)
 {
     it->traverseDeclaration(this);
@@ -504,6 +509,25 @@ void TIntermTraverser::traverseBlock(TIntermBlock *node)
         visitBlock(PostVisit, node);
 }
 
+void TIntermTraverser::traverseInvariantDeclaration(TIntermInvariantDeclaration *node)
+{
+    bool visit = true;
+
+    if (preVisit)
+    {
+        visit = visitInvariantDeclaration(PreVisit, node);
+    }
+
+    if (visit)
+    {
+        node->getSymbol()->traverse(this);
+        if (postVisit)
+        {
+            visitInvariantDeclaration(PostVisit, node);
+        }
+    }
+}
+
 // Traverse a declaration node.
 void TIntermTraverser::traverseDeclaration(TIntermDeclaration *node)
 {

src/compiler/translator/Operator.h

@@ -16,7 +16,6 @@ enum TOperator
     EOpFunctionCall,
     EOpParameters,  // an aggregate listing the parameters to a function
 
-    EOpInvariantDeclaration,  // Specialized declarations for attributing invariance
     EOpPrototype,
 
     //

src/compiler/translator/OutputGLSLBase.cpp

@@ -959,6 +959,15 @@ bool TOutputGLSLBase::visitFunctionDefinition(Visit visit, TIntermFunctionDefini
     return false;
 }
 
+bool TOutputGLSLBase::visitInvariantDeclaration(Visit visit, TIntermInvariantDeclaration *node)
+{
+    TInfoSinkBase &out = objSink();
+    ASSERT(visit == PreVisit);
+    const TIntermSymbol *symbol = node->getSymbol();
+    out << "invariant " << hashVariableName(symbol->getName());
+    return false;
+}
+
 bool TOutputGLSLBase::visitAggregate(Visit visit, TIntermAggregate *node)
 {
     bool visitChildren       = true;
@@ -1001,18 +1010,6 @@ bool TOutputGLSLBase::visitAggregate(Visit visit, TIntermAggregate *node)
             out << ")";
             visitChildren = false;
             break;
-        case EOpInvariantDeclaration:
-            // Invariant declaration.
-            ASSERT(visit == PreVisit);
-            {
-                const TIntermSequence *sequence = node->getSequence();
-                ASSERT(sequence && sequence->size() == 1);
-                const TIntermSymbol *symbol = sequence->front()->getAsSymbolNode();
-                ASSERT(symbol);
-                out << "invariant " << hashVariableName(symbol->getName());
-            }
-            visitChildren = false;
-            break;
         case EOpConstructFloat:
         case EOpConstructVec2:
         case EOpConstructVec3:

src/compiler/translator/OutputGLSLBase.h

@@ -55,6 +55,7 @@ class TOutputGLSLBase : public TIntermTraverser
     bool visitFunctionDefinition(Visit visit, TIntermFunctionDefinition *node) override;
     bool visitAggregate(Visit visit, TIntermAggregate *node) override;
     bool visitBlock(Visit visit, TIntermBlock *node) override;
+    bool visitInvariantDeclaration(Visit visit, TIntermInvariantDeclaration *node) override;
     bool visitDeclaration(Visit visit, TIntermDeclaration *node) override;
     bool visitLoop(Visit visit, TIntermLoop *node) override;
     bool visitBranch(Visit visit, TIntermBranch *node) override;

src/compiler/translator/OutputHLSL.cpp

@@ -1616,15 +1616,18 @@ bool OutputHLSL::visitDeclaration(Visit visit, TIntermDeclaration *node)
     return false;
 }
 
+bool OutputHLSL::visitInvariantDeclaration(Visit visit, TIntermInvariantDeclaration *node)
+{
+    // Do not do any translation
+    return false;
+}
+
 bool OutputHLSL::visitAggregate(Visit visit, TIntermAggregate *node)
 {
     TInfoSinkBase &out = getInfoSink();
 
     switch (node->getOp())
     {
-        case EOpInvariantDeclaration:
-            // Do not do any translation
-            return false;
         case EOpPrototype:
             if (visit == PreVisit)
             {

src/compiler/translator/OutputHLSL.h

@@ -79,6 +79,7 @@ class OutputHLSL : public TIntermTraverser
     bool visitFunctionDefinition(Visit visit, TIntermFunctionDefinition *node) override;
     bool visitAggregate(Visit visit, TIntermAggregate *);
     bool visitBlock(Visit visit, TIntermBlock *node);
+    bool visitInvariantDeclaration(Visit visit, TIntermInvariantDeclaration *node);
     bool visitDeclaration(Visit visit, TIntermDeclaration *node);
     bool visitLoop(Visit visit, TIntermLoop *);
     bool visitBranch(Visit visit, TIntermBranch *);

src/compiler/translator/ParseContext.cpp

@@ -2044,7 +2044,7 @@ TIntermDeclaration *TParseContext::parseSingleArrayInitDeclaration(
     return declaration;
 }
 
-TIntermAggregate *TParseContext::parseInvariantDeclaration(
+TIntermInvariantDeclaration *TParseContext::parseInvariantDeclaration(
     const TTypeQualifierBuilder &typeQualifierBuilder,
     const TSourceLoc &identifierLoc,
     const TString *identifier,
@@ -2094,9 +2094,7 @@ TIntermAggregate *TParseContext::parseInvariantDeclaration(
     TIntermSymbol *intermSymbol =
         intermediate.addSymbol(variable->getUniqueId(), *identifier, type, identifierLoc);
 
-    TIntermAggregate *aggregate = TIntermediate::MakeAggregate(intermSymbol, identifierLoc);
-    aggregate->setOp(EOpInvariantDeclaration);
-    return aggregate;
+    return new TIntermInvariantDeclaration(intermSymbol, identifierLoc);
 }
 
 void TParseContext::parseDeclarator(TPublicType &publicType,

src/compiler/translator/ParseContext.h

@@ -212,10 +212,11 @@ class TParseContext : angle::NonCopyable
                                                         const TSourceLoc &initLocation,
                                                         TIntermTyped *initializer);
 
-    TIntermAggregate *parseInvariantDeclaration(const TTypeQualifierBuilder &typeQualifierBuilder,
-                                                const TSourceLoc &identifierLoc,
-                                                const TString *identifier,
-                                                const TSymbol *symbol);
+    TIntermInvariantDeclaration *parseInvariantDeclaration(
+        const TTypeQualifierBuilder &typeQualifierBuilder,
+        const TSourceLoc &identifierLoc,
+        const TString *identifier,
+        const TSymbol *symbol);
 
     void parseDeclarator(TPublicType &publicType,
                          const TSourceLoc &identifierLocation,

src/compiler/translator/RemoveInvariantDeclaration.cpp

@@ -22,16 +22,12 @@ class RemoveInvariantDeclarationTraverser : public TIntermTraverser
     RemoveInvariantDeclarationTraverser() : TIntermTraverser(true, false, false) {}
 
   private:
-    bool visitAggregate(Visit visit, TIntermAggregate *node) override
+    bool visitInvariantDeclaration(Visit visit, TIntermInvariantDeclaration *node) override
     {
-        if (node->getOp() == EOpInvariantDeclaration)
-        {
-            TIntermSequence emptyReplacement;
-            mMultiReplacements.push_back(NodeReplaceWithMultipleEntry(getParentNode()->getAsBlock(),
-                                                                      node, emptyReplacement));
-            return false;
-        }
-        return true;
+        TIntermSequence emptyReplacement;
+        mMultiReplacements.push_back(
+            NodeReplaceWithMultipleEntry(getParentNode()->getAsBlock(), node, emptyReplacement));
+        return false;
     }
 };
 

src/compiler/translator/VersionGLSL.cpp

@@ -92,15 +92,18 @@ bool TVersionGLSL::visitDeclaration(Visit, TIntermDeclaration *node)
     return true;
 }
 
+bool TVersionGLSL::visitInvariantDeclaration(Visit, TIntermInvariantDeclaration *node)
+{
+    ensureVersionIsAtLeast(GLSL_VERSION_120);
+    return true;
+}
+
 bool TVersionGLSL::visitAggregate(Visit, TIntermAggregate *node)
 {
     bool visitChildren = true;
 
     switch (node->getOp())
     {
-        case EOpInvariantDeclaration:
-            ensureVersionIsAtLeast(GLSL_VERSION_120);
-            break;
         case EOpParameters:
         {
             const TIntermSequence &params = *(node->getSequence());

src/compiler/translator/VersionGLSL.h

@@ -59,8 +59,9 @@ class TVersionGLSL : public TIntermTraverser
     //   Else 110 is returned.
     int getVersion() const { return mVersion; }
 
-    void visitSymbol(TIntermSymbol *) override;
-    bool visitAggregate(Visit, TIntermAggregate *) override;
+    void visitSymbol(TIntermSymbol *node) override;
+    bool visitAggregate(Visit, TIntermAggregate *node) override;
+    bool visitInvariantDeclaration(Visit, TIntermInvariantDeclaration *node) override;
     bool visitDeclaration(Visit, TIntermDeclaration *node) override;
 
   private:

src/compiler/translator/intermOut.cpp

@@ -52,6 +52,7 @@ class TOutputTraverser : public TIntermTraverser
     bool visitFunctionDefinition(Visit visit, TIntermFunctionDefinition *node) override;
     bool visitAggregate(Visit visit, TIntermAggregate *) override;
     bool visitBlock(Visit visit, TIntermBlock *) override;
+    bool visitInvariantDeclaration(Visit visit, TIntermInvariantDeclaration *node) override;
     bool visitDeclaration(Visit visit, TIntermDeclaration *node) override;
     bool visitLoop(Visit visit, TIntermLoop *) override;
     bool visitBranch(Visit visit, TIntermBranch *) override;
@@ -495,6 +496,14 @@ bool TOutputTraverser::visitFunctionDefinition(Visit visit, TIntermFunctionDefin
     return true;
 }
 
+bool TOutputTraverser::visitInvariantDeclaration(Visit visit, TIntermInvariantDeclaration *node)
+{
+    TInfoSinkBase &out = sink;
+    OutputTreeText(out, node, mDepth);
+    out << "Invariant Declaration:\n";
+    return true;
+}
+
 bool TOutputTraverser::visitAggregate(Visit visit, TIntermAggregate *node)
 {
     TInfoSinkBase &out = sink;
@@ -677,10 +686,6 @@ bool TOutputTraverser::visitAggregate(Visit visit, TIntermAggregate *node)
             out << "outer product";
             break;
 
-        case EOpInvariantDeclaration:
-            out << "Invariant Declaration: ";
-            break;
-
         default:
             out.prefix(EPrefixError);
             out << "Bad aggregation op";