src/compiler/translator/PruneEmptyDeclarations.cpp

//
// Copyright (c) 2002-2015 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.
//
// The PruneEmptyDeclarations function prunes unnecessary empty declarations and declarators from the AST.

#include "compiler/translator/PruneEmptyDeclarations.h"

#include "compiler/translator/IntermNode.h"

namespace
{

class PruneEmptyDeclarationsTraverser : private TIntermTraverser
{
  public:
    static void apply(TIntermNode *root);
  private:
    PruneEmptyDeclarationsTraverser();
    bool visitAggregate(Visit, TIntermAggregate *node) override;
};

void PruneEmptyDeclarationsTraverser::apply(TIntermNode *root)
{
    PruneEmptyDeclarationsTraverser prune;
    root->traverse(&prune);
    prune.updateTree();
}

PruneEmptyDeclarationsTraverser::PruneEmptyDeclarationsTraverser()
    : TIntermTraverser(true, false, false)
{
}

bool PruneEmptyDeclarationsTraverser::visitAggregate(Visit, TIntermAggregate *node)
{
    if (node->getOp() == EOpDeclaration)
    {
        TIntermSequence *sequence = node->getSequence();
        if (sequence->size() >= 1)
        {
            TIntermSymbol *sym = sequence->front()->getAsSymbolNode();
            // Prune declarations without a variable name, unless it's an interface block declaration.
            if (sym != nullptr && sym->getSymbol() == "" && !sym->isInterfaceBlock())
            {
                if (sequence->size() > 1)
                {
                    // Generate a replacement that will remove the empty declarator in the beginning of a declarator
                    // list. Example of a declaration that will be changed:
                    // float, a;
                    // will be changed to
                    // float a;
                    // This applies also to struct declarations.
                    TIntermSequence emptyReplacement;
                    mMultiReplacements.push_back(NodeReplaceWithMultipleEntry(node, sym, emptyReplacement));
                }
                else if (sym->getBasicType() != EbtStruct)
                {
                    // Single struct declarations may just declare the struct type and no variables, so they should
                    // not be pruned. All other single empty declarations can be pruned entirely. Example of an empty
                    // declaration that will be pruned:
                    // float;
                    TIntermSequence emptyReplacement;
                    TIntermBlock *parentAsBlock = getParentNode()->getAsBlock();
                    // The declaration may be inside a block or in a loop init expression.
                    ASSERT(parentAsBlock != nullptr || getParentNode()->getAsLoopNode() != nullptr);
                    if (parentAsBlock)
                    {
                        mMultiReplacements.push_back(
                            NodeReplaceWithMultipleEntry(parentAsBlock, node, emptyReplacement));
                    }
                    else
                    {
                        queueReplacement(node, nullptr, OriginalNode::IS_DROPPED);
                    }
                }
                else if (sym->getType().getQualifier() != EvqGlobal &&
                         sym->getType().getQualifier() != EvqTemporary)
                {
                    // We've hit an empty struct declaration with a qualifier, for example like
                    // this:
                    // const struct a { int i; };
                    // NVIDIA GL driver version 367.27 doesn't accept this kind of declarations, so
                    // we convert the declaration to a regular struct declaration. This is okay,
                    // since ESSL 1.00 spec section 4.1.8 says about structs that "The optional
                    // qualifiers only apply to any declarators, and are not part of the type being
                    // defined for name."

                    if (mInGlobalScope)
                    {
                        sym->getTypePointer()->setQualifier(EvqGlobal);
                    }
                    else
                    {
                        sym->getTypePointer()->setQualifier(EvqTemporary);
                    }
                }
            }
        }
        return false;
    }
    return true;
}

} // namespace

void PruneEmptyDeclarations(TIntermNode *root)
{
    PruneEmptyDeclarationsTraverser::apply(root);
}