/*

 * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package jdk.nashorn.internal.codegen;

import static jdk.nashorn.internal.codegen.CompilerConstants.CALLEE;

import static jdk.nashorn.internal.codegen.CompilerConstants.EXCEPTION_PREFIX;

import static jdk.nashorn.internal.codegen.CompilerConstants.ITERATOR_PREFIX;

import static jdk.nashorn.internal.codegen.CompilerConstants.SCOPE;

import static jdk.nashorn.internal.codegen.CompilerConstants.SCRIPT_RETURN;

import static jdk.nashorn.internal.codegen.CompilerConstants.SWITCH_TAG_PREFIX;

import static jdk.nashorn.internal.codegen.CompilerConstants.THIS;

import static jdk.nashorn.internal.codegen.CompilerConstants.VARARGS;

import static jdk.nashorn.internal.ir.Symbol.IS_GLOBAL;

import static jdk.nashorn.internal.ir.Symbol.IS_INTERNAL;

import static jdk.nashorn.internal.ir.Symbol.IS_LET;

import static jdk.nashorn.internal.ir.Symbol.IS_PARAM;

import static jdk.nashorn.internal.ir.Symbol.IS_THIS;

import static jdk.nashorn.internal.ir.Symbol.IS_VAR;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.LinkedList;

import java.util.List;

import java.util.Set;

import jdk.nashorn.internal.codegen.types.Type;

import jdk.nashorn.internal.ir.AccessNode;

import jdk.nashorn.internal.ir.BinaryNode;

import jdk.nashorn.internal.ir.Block;

import jdk.nashorn.internal.ir.CallNode;

import jdk.nashorn.internal.ir.CallNode.EvalArgs;

import jdk.nashorn.internal.ir.CaseNode;

import jdk.nashorn.internal.ir.CatchNode;

import jdk.nashorn.internal.ir.ForNode;

import jdk.nashorn.internal.ir.FunctionNode;

import jdk.nashorn.internal.ir.IdentNode;

import jdk.nashorn.internal.ir.IndexNode;

import jdk.nashorn.internal.ir.LiteralNode;

import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode;

import jdk.nashorn.internal.ir.Node;

import jdk.nashorn.internal.ir.ObjectNode;

import jdk.nashorn.internal.ir.PropertyNode;

import jdk.nashorn.internal.ir.ReferenceNode;

import jdk.nashorn.internal.ir.ReturnNode;

import jdk.nashorn.internal.ir.RuntimeNode;

import jdk.nashorn.internal.ir.RuntimeNode.Request;

import jdk.nashorn.internal.ir.SwitchNode;

import jdk.nashorn.internal.ir.Symbol;

import jdk.nashorn.internal.ir.TernaryNode;

import jdk.nashorn.internal.ir.TryNode;

import jdk.nashorn.internal.ir.UnaryNode;

import jdk.nashorn.internal.ir.VarNode;

import jdk.nashorn.internal.ir.visitor.NodeOperatorVisitor;

import jdk.nashorn.internal.ir.visitor.NodeVisitor;

import jdk.nashorn.internal.parser.TokenType;

import jdk.nashorn.internal.runtime.Context;

import jdk.nashorn.internal.runtime.Debug;

import jdk.nashorn.internal.runtime.DebugLogger;

import jdk.nashorn.internal.runtime.ECMAException;

import jdk.nashorn.internal.runtime.JSType;

import jdk.nashorn.internal.runtime.Property;

import jdk.nashorn.internal.runtime.PropertyMap;

import jdk.nashorn.internal.runtime.ScriptFunction;

import jdk.nashorn.internal.runtime.ScriptObject;

import jdk.nashorn.internal.runtime.Source;

/**

 * This is the attribution pass of the code generator. Attr takes Lowered IR,

 * that is, IR where control flow has been computed and high level to low level

 * substitions for operations have been performed.

 *

 * After Attr, every symbol will have a conservative correct type.

 *

 * Any expression that requires temporary storage as part of computation will

 * also be detected here and give a temporary symbol

 *

 * Types can be narrowed after Attr by Access Specialization in FinalizeTypes,

 * but in general, this is where the main symbol type information is

 * computed.

 */

final class Attr extends NodeOperatorVisitor {

    /** Current compiler. */

    private final Compiler compiler;

    /** Current source. */

    private final Source source;

    /**

     * Local definitions in current block (to discriminate from function

     * declarations always defined in the function scope. This is for

     * "can be undefined" analysis.

     */

    private Set<String> localDefs;

    /**

     * Local definitions in current block to guard against cases like

     * NASHORN-467 when things can be undefined as they are used before

     * their local var definition. *sigh* JavaScript...

     */

    private Set<String> localUses;

    private static final DebugLogger LOG = new DebugLogger("attr");

    /**

     * Constructor.

     *

     * @param compiler the compiler

     */

    Attr(final Compiler compiler) {

        this.compiler = compiler;

        this.source   = compiler.getSource();

    }

    @Override

    protected Node enterDefault(final Node node) {

        return start(node);

    }

    @Override

    protected Node leaveDefault(final Node node) {

        return end(node);

    }

    @Override

    public Node leave(final AccessNode accessNode) {

        newTemporary(Type.OBJECT, accessNode);  //While Object type is assigned here, Access Specialization in FinalizeTypes may narrow this

        end(accessNode);

        return accessNode;

    }

    @Override

    public Node enter(final Block block) {

        start(block);

        final Set<String> savedLocalDefs = localDefs;

        final Set<String> savedLocalUses = localUses;

        block.setFrame(getCurrentFunctionNode().pushFrame());

        try {

            // a block starts out by copying the local defs and local uses

            // from the outer level. But we need the copies, as when we

            // leave the block the def and use sets given upon entry must

            // be restored

            localDefs = new HashSet<>(savedLocalDefs);

            localUses = new HashSet<>(savedLocalUses);

            for (final Node statement : block.getStatements()) {

                statement.accept(this);

            }

        } finally {

            localDefs = savedLocalDefs;

            localUses = savedLocalUses;

            getCurrentFunctionNode().popFrame();

        }

        end(block);

        return null;

    }

    @Override

    public Node enter(final CallNode callNode) {

        start(callNode);

        callNode.getFunction().accept(this);

        final List<Node> acceptedArgs = new ArrayList<>(callNode.getArgs().size());

        for (final Node arg : callNode.getArgs()) {

            LOG.info("Doing call arg " + arg);

            acceptedArgs.add(arg.accept(this));

        }

        callNode.setArgs(acceptedArgs);

        final EvalArgs evalArgs = callNode.getEvalArgs();

        if (evalArgs != null) {

            evalArgs.setCode(evalArgs.getCode().accept(this));

            final IdentNode thisNode = new IdentNode(getCurrentFunctionNode().getThisNode());

            assert thisNode.getSymbol() != null; //should copy attributed symbol and that's it

            evalArgs.setThis(thisNode);

        }

        newTemporary(Type.OBJECT, callNode); // object type here, access specialization in FinalizeTypes may narrow it later

        newType(callNode.getFunction().getSymbol(), Type.OBJECT);

        end(callNode);

        return null;

    }

    @Override

    public Node enter(final CatchNode catchNode) {

        final IdentNode exception = catchNode.getException();

        final Block     block     = getCurrentBlock();

        start(catchNode);

        // define block-local exception variable

        final Symbol def = block.defineSymbol(exception.getName(), IS_VAR | IS_LET, exception);

        newType(def, Type.OBJECT);

        addLocalDef(exception.getName());

        return catchNode;

    }

    @Override

    public Node enter(final FunctionNode functionNode) {

        start(functionNode, false);

        clearLocalDefs();

        clearLocalUses();

        functionNode.setFrame(functionNode.pushFrame());

        initCallee(functionNode);

        initThis(functionNode);

        if (functionNode.isVarArg()) {

            initVarArg(functionNode);

        }

        initParameters(functionNode);

        initScope(functionNode);

        initReturn(functionNode);

        // Add all nested functions as symbols in this function

        for (final FunctionNode nestedFunction : functionNode.getFunctions()) {

            final IdentNode ident = nestedFunction.getIdent();

            if (ident != null && nestedFunction.isStatement()) {

                final Symbol functionSymbol = functionNode.defineSymbol(ident.getName(), IS_VAR, nestedFunction);

                newType(functionSymbol, Type.typeFor(ScriptFunction.class));

            }

        }

        if (functionNode.isScript()) {

            initFromPropertyMap(compiler.getContext(), functionNode);

        }

        // Add function name as local symbol

        if (!functionNode.isStatement() && !functionNode.isAnonymous() && !functionNode.isScript()) {

            final Symbol selfSymbol = functionNode.defineSymbol(functionNode.getIdent().getName(), IS_VAR, functionNode);

            newType(selfSymbol, Type.OBJECT);

            selfSymbol.setNode(functionNode);

        }

        /*

         * This pushes all declarations (except for non-statements, i.e. for

         * node temporaries) to the top of the function scope. This way we can

         * get around problems like

         *

         * while (true) {

         *   break;

         *   if (true) {

         *     var s;

         *   }

         * }

         *

         * to an arbitrary nesting depth.

         *

         * @see NASHORN-73

         */

        final List<Symbol> declaredSymbols = new ArrayList<>();

        for (final VarNode decl : functionNode.getDeclarations()) {

            final IdentNode ident = decl.getName();

            // any declared symbols that aren't visited need to be typed as well, hence the list

            declaredSymbols.add(functionNode.defineSymbol(ident.getName(), IS_VAR, new IdentNode(ident)));

        }

        // Every nested function needs a definition in the outer function with its name. Add these.

        for (final FunctionNode nestedFunction : functionNode.getFunctions()) {

            final VarNode varNode = nestedFunction.getFunctionVarNode();

            if (varNode != null) {

                varNode.accept(this);

                assert varNode.isFunctionVarNode() : varNode + " should be function var node";

            }

        }

        for (final Node statement : functionNode.getStatements()) {

            if (statement instanceof VarNode && ((VarNode)statement).isFunctionVarNode()) {

                continue; //var nodes have already been processed, skip or they will generate additional defs/uses and false "can be undefined"

            }

            statement.accept(this);

        }

        for (final FunctionNode nestedFunction : functionNode.getFunctions()) {

            LOG.info("Going into nested function " + functionNode.getName() + " -> " + nestedFunction.getName());

            nestedFunction.accept(this);

        }

        //unknown parameters are promoted to object type.

        finalizeParameters(functionNode);

        finalizeTypes(functionNode);

        for (final Symbol symbol : declaredSymbols) {

            if (symbol.getSymbolType().isUnknown()) {

                symbol.setType(Type.OBJECT);

                symbol.setCanBeUndefined();

            }

        }

        if (functionNode.getReturnType().isUnknown()) {

            LOG.info("Unknown return type promoted to object");

            functionNode.setReturnType(Type.OBJECT);

        }

        if (functionNode.getSelfSymbolInit() != null) {

            LOG.info("Accepting self symbol init " + functionNode.getSelfSymbolInit() + " for " + functionNode.getName());

            final Node init = functionNode.getSelfSymbolInit();

            final List<Node> newStatements = new ArrayList<>();

            newStatements.add(init);

            newStatements.addAll(functionNode.getStatements());

            functionNode.setStatements(newStatements);

            functionNode.setNeedsSelfSymbol(functionNode.getSelfSymbolInit().accept(this));

        }

        functionNode.popFrame();

        end(functionNode, false);

        return null;

    }

    @Override

    public Node leaveCONVERT(final UnaryNode unaryNode) {

        assert false : "There should be no convert operators in IR during Attribution";

        end(unaryNode);

        return unaryNode;

    }

    @Override

    public Node enter(final IdentNode identNode) {

        final String name = identNode.getName();

        start(identNode);

        if (identNode.isPropertyName()) {

            // assign a pseudo symbol to property name

            final Symbol pseudoSymbol = pseudoSymbol(name);

            LOG.info("IdentNode is property name -> assigning pseudo symbol " + pseudoSymbol);

            LOG.unindent();

            identNode.setSymbol(pseudoSymbol);

            return null;

        }

        final Block  block     = getCurrentBlock();

        final Symbol oldSymbol = identNode.getSymbol();

        Symbol symbol = block.findSymbol(name);

        //If an existing symbol with the name is found, use that otherwise, declare a new one

        if (symbol != null) {

            LOG.info("Existing symbol = " + symbol);

            if (isFunctionExpressionSelfReference(symbol)) {

                final FunctionNode functionNode = (FunctionNode)symbol.getNode();

                assert functionNode.getCalleeNode() != null;

                final VarNode var = new VarNode(source, functionNode.getToken(), functionNode.getFinish(), functionNode.getIdent(), functionNode.getCalleeNode());

                //newTemporary(Type.OBJECT, var); //ScriptFunction? TODO

                functionNode.setNeedsSelfSymbol(var);

            }

            if (!identNode.isInitializedHere()) { // NASHORN-448

                // here is a use outside the local def scope

                if (!isLocalDef(name)) {

                    newType(symbol, Type.OBJECT);

                    symbol.setCanBeUndefined();

                }

            }

            identNode.setSymbol(symbol);

            if (!getCurrentFunctionNode().isLocal(symbol)) {

                // non-local: we need to put symbol in scope (if it isn't already)

                if (!symbol.isScope()) {

                    final List<Block> lookupBlocks = findLookupBlocksHelper(getCurrentFunctionNode(), symbol.findFunction());

                    for (final Block lookupBlock : lookupBlocks) {

                        final Symbol refSymbol = lookupBlock.findSymbol(name);

                        if (refSymbol != null) { // See NASHORN-837, function declaration in lexical scope: try {} catch (x){ function f() { use(x) } } f()

                            LOG.finest("Found a ref symbol that must be scope " + refSymbol);

                            refSymbol.setIsScope();

                        }

                    }

                }

            }

        } else {

            LOG.info("No symbol exists. Declare undefined: " + symbol);

            symbol = block.useSymbol(name, identNode);

            // we have never seen this before, it can be undefined

            newType(symbol, Type.OBJECT); // TODO unknown -we have explicit casts anyway?

            symbol.setCanBeUndefined();

            symbol.setIsScope();

        }

        if(symbol.isGlobal()) {

            getCurrentFunctionNode().setUsesGlobalSymbol();

        } else if(symbol.isScope()) {

            getCurrentFunctionNode().setUsesScopeSymbol(symbol);

        }

        if (symbol != oldSymbol && !identNode.isInitializedHere()) {

            symbol.increaseUseCount();

        }

        addLocalUse(identNode.getName());

        end(identNode);

        return null;

    }

    @Override

    public Node leave(final IndexNode indexNode) {

        newTemporary(Type.OBJECT, indexNode); //TORO

        return indexNode;

    }

    @SuppressWarnings("rawtypes")

    @Override

    public Node enter(final LiteralNode literalNode) {

        try {

            start(literalNode);

            assert !literalNode.isTokenType(TokenType.THIS) : "tokentype for " + literalNode + " is this"; //guard against old dead code case. literal nodes should never inherit tokens

            if (literalNode instanceof ArrayLiteralNode) {

                final ArrayLiteralNode arrayLiteralNode = (ArrayLiteralNode)literalNode;

                final Node[]           array            = arrayLiteralNode.getValue();

                for (int i = 0; i < array.length; i++) {

                    final Node element = array[i];

                    if (element != null) {

                        array[i] = element.accept(this);

                    }

                }

                arrayLiteralNode.analyze();

                //array literal node now has an element type and all elements are attributed

            } else {

                assert !(literalNode.getValue() instanceof Node) : "literals with Node values not supported";

            }

            getCurrentFunctionNode().newLiteral(literalNode);

        } finally {

            end(literalNode);

        }

        return null;

    }

    @Override

    public Node leave(final ObjectNode objectNode) {

        newTemporary(Type.OBJECT, objectNode);

        end(objectNode);

        return objectNode;

    }

    @Override

    public Node enter(final PropertyNode propertyNode) {

        // assign a pseudo symbol to property name, see NASHORN-710

        propertyNode.setSymbol(new Symbol(propertyNode.getKeyName(), 0, Type.OBJECT));

        end(propertyNode);

        return propertyNode;

    }

    @Override

    public Node enter(final ReferenceNode referenceNode) {

        final FunctionNode functionNode = referenceNode.getReference();

        if (functionNode != null) {

            functionNode.addReferencingParentBlock(getCurrentBlock());

        }

        end(referenceNode);

        return referenceNode;

    }

    @Override

    public Node leave(final ReferenceNode referenceNode) {

        newTemporary(Type.OBJECT, referenceNode); //reference node type is always an object, i.e. the scriptFunction. the function return type varies though

        end(referenceNode);

        return referenceNode;

    }

    @Override

    public Node leave(final ReturnNode returnNode) {

        final Node expr = returnNode.getExpression();

        if (expr != null) {

            //we can't do parameter specialization if we return something that hasn't been typed yet

            final Symbol symbol = expr.getSymbol();

            if (expr.getType().isUnknown() && symbol.isParam()) {

                symbol.setType(Type.OBJECT);

            }

            getCurrentFunctionNode().setReturnType(Type.widest(getCurrentFunctionNode().getReturnType(), symbol.getSymbolType()));

            LOG.info("Returntype is now " + getCurrentFunctionNode().getReturnType());

        }

        end(returnNode);

        return returnNode;

    }

    @Override

    public Node leave(final SwitchNode switchNode) {

        Type type = Type.UNKNOWN;

        for (final CaseNode caseNode : switchNode.getCases()) {