//
// Copyright 2002 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 SeparateDeclarations function processes declarations, so that in the end each declaration
// contains only one declarator.
// This is useful as an intermediate step when initialization needs to be separated from
// declaration, or when things need to be unfolded out of the initializer.
// Example:
//     int a[1] = int[1](1), b[1] = int[1](2);
// gets transformed when run through this class into the AST equivalent of:
//     int a[1] = int[1](1);
//     int b[1] = int[1](2);

#include "compiler/translator/tree_ops/SeparateDeclarations.h"

#include "compiler/translator/SymbolTable.h"
#include "compiler/translator/tree_util/IntermTraverse.h"
#include "compiler/translator/tree_util/ReplaceVariable.h"

namespace sh
{

namespace
{

class SeparateDeclarationsTraverser : private TIntermTraverser
{
  public:
    [[nodiscard]] static bool apply(TCompiler *compiler,
                                    TIntermNode *root,
                                    TSymbolTable *symbolTable);

  private:
    SeparateDeclarationsTraverser(TSymbolTable *symbolTable);
    bool visitDeclaration(Visit, TIntermDeclaration *node) override;
    void visitSymbol(TIntermSymbol *symbol) override;

    void separateDeclarator(TIntermSequence *sequence,
                            size_t index,
                            TIntermSequence *replacementDeclarations,
                            const TStructure **replacementStructure);

    VariableReplacementMap mVariableMap;
};

bool SeparateDeclarationsTraverser::apply(TCompiler *compiler,
                                          TIntermNode *root,
                                          TSymbolTable *symbolTable)
{
    SeparateDeclarationsTraverser separateDecl(symbolTable);
    root->traverse(&separateDecl);
    return separateDecl.updateTree(compiler, root);
}

SeparateDeclarationsTraverser::SeparateDeclarationsTraverser(TSymbolTable *symbolTable)
    : TIntermTraverser(true, false, false, symbolTable)
{}

bool SeparateDeclarationsTraverser::visitDeclaration(Visit, TIntermDeclaration *node)
{
    TIntermSequence *sequence = node->getSequence();
    if (sequence->size() <= 1)
    {
        return true;
    }

    TIntermBlock *parentBlock = getParentNode()->getAsBlock();
    ASSERT(parentBlock != nullptr);

    TIntermSequence replacementDeclarations;
    const TStructure *replacementStructure = nullptr;
    for (size_t ii = 0; ii < sequence->size(); ++ii)
    {
        separateDeclarator(sequence, ii, &replacementDeclarations, &replacementStructure);
    }

    mMultiReplacements.emplace_back(parentBlock, node, std::move(replacementDeclarations));
    return false;
}

void SeparateDeclarationsTraverser::visitSymbol(TIntermSymbol *symbol)
{
    const TVariable *variable = &symbol->variable();
    if (mVariableMap.count(variable) > 0)
    {
        queueAccessChainReplacement(mVariableMap[variable]->deepCopy());
    }
}

void SeparateDeclarationsTraverser::separateDeclarator(TIntermSequence *sequence,
                                                       size_t index,
                                                       TIntermSequence *replacementDeclarations,
                                                       const TStructure **replacementStructure)
{
    TIntermTyped *declarator    = sequence->at(index)->getAsTyped();
    const TType &declaratorType = declarator->getType();

    // If the declaration is not simultaneously declaring a struct, can use the same declarator.
    // Otherwise, the first declarator is taken as-is if the struct has a name.
    const TStructure *structure  = declaratorType.getStruct();
    const bool isStructSpecifier = declaratorType.isStructSpecifier();
    if (!isStructSpecifier || (index == 0 && structure->symbolType() != SymbolType::Empty))
    {
        TIntermDeclaration *replacementDeclaration = new TIntermDeclaration;

        // Make sure to update the declarator's initializers if any.
        declarator->traverse(this);

        replacementDeclaration->appendDeclarator(declarator);
        replacementDeclaration->setLine(declarator->getLine());
        replacementDeclarations->push_back(replacementDeclaration);
        return;
    }

    // If the struct is nameless, split it out first.
    if (structure->symbolType() == SymbolType::Empty)
    {
        if (*replacementStructure == nullptr)
        {
            TStructure *newStructure =
                new TStructure(mSymbolTable, kEmptyImmutableString, &structure->fields(),
                               SymbolType::AngleInternal);
            newStructure->setAtGlobalScope(structure->atGlobalScope());
            *replacementStructure = structure = newStructure;

            TType *namedType = new TType(structure, true);
            namedType->setQualifier(EvqGlobal);

            TVariable *structVariable =
                new TVariable(mSymbolTable, kEmptyImmutableString, namedType, SymbolType::Empty);

            TIntermDeclaration *structDeclaration = new TIntermDeclaration;
            structDeclaration->appendDeclarator(new TIntermSymbol(structVariable));
            structDeclaration->setLine(declarator->getLine());
            replacementDeclarations->push_back(structDeclaration);
        }
        else
        {
            structure = *replacementStructure;
        }
    }

    // Redeclare the declarator but not as a struct specifier.
    TIntermSymbol *asSymbol   = declarator->getAsSymbolNode();
    TIntermTyped *initializer = nullptr;
    if (asSymbol == nullptr)
    {
        TIntermBinary *asBinary = declarator->getAsBinaryNode();
        ASSERT(asBinary->getOp() == EOpInitialize);
        asSymbol    = asBinary->getLeft()->getAsSymbolNode();
        initializer = asBinary->getRight();

        // Make sure the initializer itself has its variables replaced if necessary.
        if (initializer->getAsSymbolNode())
        {
            const TVariable *initializerVariable = &initializer->getAsSymbolNode()->variable();
            if (mVariableMap.count(initializerVariable) > 0)
            {
                initializer = mVariableMap[initializerVariable]->deepCopy();
            }
        }
        else
        {
            initializer->traverse(this);
        }
    }

    ASSERT(asSymbol && asSymbol->variable().symbolType() != SymbolType::Empty);

    TType *newType = new TType(structure, false);
    newType->setQualifier(asSymbol->getType().getQualifier());
    newType->makeArrays(asSymbol->getType().getArraySizes());

    TVariable *replacementVar        = new TVariable(mSymbolTable, asSymbol->getName(), newType,
                                                     asSymbol->variable().symbolType());
    TIntermSymbol *replacementSymbol = new TIntermSymbol(replacementVar);
    TIntermTyped *replacement        = replacementSymbol;
    if (initializer)
    {
        replacement = new TIntermBinary(EOpInitialize, replacement, initializer);
    }

    TIntermDeclaration *replacementDeclaration = new TIntermDeclaration;
    replacementDeclaration->appendDeclarator(replacement);
    replacementDeclaration->setLine(declarator->getLine());
    replacementDeclarations->push_back(replacementDeclaration);

    mVariableMap[&asSymbol->variable()] = replacementSymbol;
}
}  // namespace

bool SeparateDeclarations(TCompiler *compiler, TIntermNode *root, TSymbolTable *symbolTable)
{
    return SeparateDeclarationsTraverser::apply(compiler, root, symbolTable);
}

}  // namespace sh