/*

 * 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.ARGUMENTS;

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

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.RETURN;

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

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.HAS_OBJECT_VALUE;

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

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

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_PROGRAM_LEVEL;

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

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

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

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

import java.util.ArrayDeque;

import java.util.ArrayList;

import java.util.Deque;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;

import java.util.Map;

import java.util.Set;

import jdk.nashorn.internal.ir.AccessNode;

import jdk.nashorn.internal.ir.BinaryNode;

import jdk.nashorn.internal.ir.Block;

import jdk.nashorn.internal.ir.CatchNode;

import jdk.nashorn.internal.ir.Expression;

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.LexicalContext;

import jdk.nashorn.internal.ir.LexicalContextNode;

import jdk.nashorn.internal.ir.LiteralNode;

import jdk.nashorn.internal.ir.Node;

import jdk.nashorn.internal.ir.RuntimeNode;

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

import jdk.nashorn.internal.ir.Statement;

import jdk.nashorn.internal.ir.SwitchNode;

import jdk.nashorn.internal.ir.Symbol;

import jdk.nashorn.internal.ir.TryNode;

import jdk.nashorn.internal.ir.UnaryNode;

import jdk.nashorn.internal.ir.VarNode;

import jdk.nashorn.internal.ir.WithNode;

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

import jdk.nashorn.internal.parser.TokenType;

import jdk.nashorn.internal.runtime.Context;

import jdk.nashorn.internal.runtime.ECMAErrors;

import jdk.nashorn.internal.runtime.ErrorManager;

import jdk.nashorn.internal.runtime.JSErrorType;

import jdk.nashorn.internal.runtime.ParserException;

import jdk.nashorn.internal.runtime.Source;

import jdk.nashorn.internal.runtime.logging.DebugLogger;

import jdk.nashorn.internal.runtime.logging.Loggable;

import jdk.nashorn.internal.runtime.logging.Logger;

/**

 * This visitor assigns symbols to identifiers denoting variables. It does few more minor calculations that are only

 * possible after symbols have been assigned; such is the transformation of "delete" and "typeof" operators into runtime

 * nodes and counting of number of properties assigned to "this" in constructor functions. This visitor is also notable

 * for what it doesn't do, most significantly it does no type calculations as in JavaScript variables can change types

 * during runtime and as such symbols don't have types. Calculation of expression types is performed by a separate

 * visitor.

 */

@Logger(name="symbols")

final class AssignSymbols extends NodeVisitor<LexicalContext> implements Loggable {

    private final DebugLogger log;

    private final boolean     debug;

    private static boolean isParamOrVar(final IdentNode identNode) {

        final Symbol symbol = identNode.getSymbol();

        return symbol.isParam() || symbol.isVar();

    }

    private static String name(final Node node) {

        final String cn = node.getClass().getName();

        final int lastDot = cn.lastIndexOf('.');

        if (lastDot == -1) {

            return cn;

        }

        return cn.substring(lastDot + 1);

    }

    /**

     * Checks if various symbols that were provisionally marked as needing a slot ended up unused, and marks them as not

     * needing a slot after all.

     * @param functionNode the function node

     * @return the passed in node, for easy chaining

     */

    private static FunctionNode removeUnusedSlots(final FunctionNode functionNode) {

        if (!functionNode.needsCallee()) {

            functionNode.compilerConstant(CALLEE).setNeedsSlot(false);

        }

        if (!(functionNode.hasScopeBlock() || functionNode.needsParentScope())) {

            functionNode.compilerConstant(SCOPE).setNeedsSlot(false);

        }

        // Named function expressions that end up not referencing themselves won't need a local slot for the self symbol.

        if(functionNode.isNamedFunctionExpression() && !functionNode.usesSelfSymbol()) {

            final Symbol selfSymbol = functionNode.getBody().getExistingSymbol(functionNode.getIdent().getName());

            if(selfSymbol != null && selfSymbol.isFunctionSelf()) {

                selfSymbol.setNeedsSlot(false);

                selfSymbol.clearFlag(Symbol.IS_VAR);

            }

        }

        return functionNode;

    }

    private final Deque<Set<String>> thisProperties = new ArrayDeque<>();

    private final Map<String, Symbol> globalSymbols = new HashMap<>(); //reuse the same global symbol

    private final Compiler compiler;

    private final boolean isOnDemand;

    public AssignSymbols(final Compiler compiler) {

        super(new LexicalContext());

        this.compiler = compiler;

        this.log   = initLogger(compiler.getContext());

        this.debug = log.isEnabled();

        this.isOnDemand = compiler.isOnDemandCompilation();

    }

    @Override

    public DebugLogger getLogger() {

        return log;

    }

    @Override

    public DebugLogger initLogger(final Context context) {

        return context.getLogger(this.getClass());

    }

    /**

     * Define symbols for all variable declarations at 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

     *

     * @param functionNode the FunctionNode we are entering

     * @param body the body of the FunctionNode we are entering

     */

    private void acceptDeclarations(final FunctionNode functionNode, final Block body) {

        // This visitor will assign symbol to all declared variables.

        body.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {

            @Override

            protected boolean enterDefault(final Node node) {

                // Don't bother visiting expressions; var is a statement, it can't be inside an expression.

                // This will also prevent visiting nested functions (as FunctionNode is an expression).

                return !(node instanceof Expression);

            }

            @Override

            public Node leaveVarNode(final VarNode varNode) {

                final IdentNode ident  = varNode.getName();

                final boolean blockScoped = varNode.isBlockScoped();

                if (blockScoped && lc.inUnprotectedSwitchContext()) {

                    throwUnprotectedSwitchError(varNode);

                }

                final Block block = blockScoped ? lc.getCurrentBlock() : body;

                final Symbol symbol = defineSymbol(block, ident.getName(), ident, varNode.getSymbolFlags());

                if (varNode.isFunctionDeclaration()) {

                    symbol.setIsFunctionDeclaration();

                }

                return varNode.setName(ident.setSymbol(symbol));

            }

        });

    }

    private IdentNode compilerConstantIdentifier(final CompilerConstants cc) {

        return createImplicitIdentifier(cc.symbolName()).setSymbol(lc.getCurrentFunction().compilerConstant(cc));

    }

    /**

     * Creates an ident node for an implicit identifier within the function (one not declared in the script source

     * code). These identifiers are defined with function's token and finish.

     * @param name the name of the identifier

     * @return an ident node representing the implicit identifier.

     */

    private IdentNode createImplicitIdentifier(final String name) {

        final FunctionNode fn = lc.getCurrentFunction();

        return new IdentNode(fn.getToken(), fn.getFinish(), name);

    }

    private Symbol createSymbol(final String name, final int flags) {

        if ((flags & Symbol.KINDMASK) == IS_GLOBAL) {

            //reuse global symbols so they can be hashed

            Symbol global = globalSymbols.get(name);

            if (global == null) {

                global = new Symbol(name, flags);

                globalSymbols.put(name, global);

            }

            return global;

        }

        return new Symbol(name, flags);

    }

    /**

     * Creates a synthetic initializer for a variable (a var statement that doesn't occur in the source code). Typically

     * used to create assignment of {@code :callee} to the function name symbol in self-referential function

     * expressions as well as for assignment of {@code :arguments} to {@code arguments}.

     *

     * @param name the ident node identifying the variable to initialize

     * @param initConstant the compiler constant it is initialized to

     * @param fn the function node the assignment is for

     * @return a var node with the appropriate assignment

     */

    private VarNode createSyntheticInitializer(final IdentNode name, final CompilerConstants initConstant, final FunctionNode fn) {

        final IdentNode init = compilerConstantIdentifier(initConstant);

        assert init.getSymbol() != null && init.getSymbol().isBytecodeLocal();

        final VarNode synthVar = new VarNode(fn.getLineNumber(), fn.getToken(), fn.getFinish(), name, init);

        final Symbol nameSymbol = fn.getBody().getExistingSymbol(name.getName());

        assert nameSymbol != null;

        return (VarNode)synthVar.setName(name.setSymbol(nameSymbol)).accept(this);

    }

    private FunctionNode createSyntheticInitializers(final FunctionNode functionNode) {

        final List<VarNode> syntheticInitializers = new ArrayList<>(2);

        // Must visit the new var nodes in the context of the body. We could also just set the new statements into the

        // block and then revisit the entire block, but that seems to be too much double work.

        final Block body = functionNode.getBody();

        lc.push(body);

        try {

            if (functionNode.usesSelfSymbol()) {

                // "var fn = :callee"

                syntheticInitializers.add(createSyntheticInitializer(functionNode.getIdent(), CALLEE, functionNode));

            }

            if (functionNode.needsArguments()) {

                // "var arguments = :arguments"

                syntheticInitializers.add(createSyntheticInitializer(createImplicitIdentifier(ARGUMENTS_VAR.symbolName()),

                        ARGUMENTS, functionNode));

            }

            if (syntheticInitializers.isEmpty()) {

                return functionNode;

            }

            for(final ListIterator<VarNode> it = syntheticInitializers.listIterator(); it.hasNext();) {

                it.set((VarNode)it.next().accept(this));

            }

        } finally {

            lc.pop(body);

        }

        final List<Statement> stmts = body.getStatements();

        final List<Statement> newStatements = new ArrayList<>(stmts.size() + syntheticInitializers.size());

        newStatements.addAll(syntheticInitializers);

        newStatements.addAll(stmts);

        return functionNode.setBody(lc, body.setStatements(lc, newStatements));

    }

    /**

     * Defines a new symbol in the given block.

     *

     * @param block        the block in which to define the symbol

     * @param name         name of symbol.

     * @param origin       origin node

     * @param symbolFlags  Symbol flags.

     *

     * @return Symbol for given name or null for redefinition.

     */

    private Symbol defineSymbol(final Block block, final String name, final Node origin, final int symbolFlags) {

        int    flags  = symbolFlags;

        final boolean isBlockScope = (flags & IS_LET) != 0 || (flags & IS_CONST) != 0;

        final boolean isGlobal     = (flags & KINDMASK) == IS_GLOBAL;

        Symbol symbol;

        final FunctionNode function;

        if (isBlockScope) {

            // block scoped variables always live in current block, no need to look for existing symbols in parent blocks.

            symbol = block.getExistingSymbol(name);

            function = lc.getCurrentFunction();

        } else {

            symbol = findSymbol(block, name);

            function = lc.getFunction(block);

        }

        // Global variables are implicitly always scope variables too.

        if (isGlobal) {

            flags |= IS_SCOPE;

        }

        if (lc.getCurrentFunction().isProgram()) {

            flags |= IS_PROGRAM_LEVEL;

        }

        final boolean isParam = (flags & KINDMASK) == IS_PARAM;

        final boolean isVar =   (flags & KINDMASK) == IS_VAR;

        if (symbol != null) {

            // Symbol was already defined. Check if it needs to be redefined.

            if (isParam) {

                if (!isLocal(function, symbol)) {

                    // Not defined in this function. Create a new definition.

                    symbol = null;

                } else if (symbol.isParam()) {

                    // Duplicate parameter. Null return will force an error.

                    throw new AssertionError("duplicate parameter");

                }

            } else if (isVar) {

                if (isBlockScope) {

                    // Check redeclaration in same block

                    if (symbol.hasBeenDeclared()) {

                        throwParserException(ECMAErrors.getMessage("syntax.error.redeclare.variable", name), origin);

                    } else {

                        symbol.setHasBeenDeclared();

                        // Set scope flag on top-level block scoped symbols

                        if (function.isProgram() && function.getBody() == block) {

                            symbol.setIsScope();

                        }

                    }

                } else if ((flags & IS_INTERNAL) != 0) {

                    // Always create a new definition.

                    symbol = null;

                } else {

                    // Found LET or CONST in parent scope of same function - s SyntaxError

                    if (symbol.isBlockScoped() && isLocal(lc.getCurrentFunction(), symbol)) {

                        throwParserException(ECMAErrors.getMessage("syntax.error.redeclare.variable", name), origin);

                    }

                    // Not defined in this function. Create a new definition.

                    if (!isLocal(function, symbol) || symbol.less(IS_VAR)) {

                        symbol = null;

                    }

                }

            }

        }

        if (symbol == null) {

            // If not found, then create a new one.

            final Block symbolBlock;

            // Determine where to create it.

            if (isVar && ((flags & IS_INTERNAL) != 0 || isBlockScope)) {

                symbolBlock = block; //internal vars are always defined in the block closest to them

            } else if (isGlobal) {

                symbolBlock = lc.getOutermostFunction().getBody();

            } else {

                symbolBlock = lc.getFunctionBody(function);

            }

            // Create and add to appropriate block.

            symbol = createSymbol(name, flags);

            symbolBlock.putSymbol(symbol);

            if ((flags & IS_SCOPE) == 0) {

                // Initial assumption; symbol can lose its slot later

                symbol.setNeedsSlot(true);

            }

        } else if (symbol.less(flags)) {

            symbol.setFlags(flags);

        }

        return symbol;

    }

    private <T extends Node> T end(final T node) {

        return end(node, true);

    }

    private <T extends Node> T end(final T node, final boolean printNode) {

        if (debug) {

            final StringBuilder sb = new StringBuilder();

            sb.append("[LEAVE ").

                append(name(node)).

                append("] ").

                append(printNode ? node.toString() : "").

                append(" in '").

                append(lc.getCurrentFunction().getName()).

                append('\'');

            if (node instanceof IdentNode) {

                final Symbol symbol = ((IdentNode)node).getSymbol();

                if (symbol == null) {

                    sb.append(" <NO SYMBOL>");

                } else {

                    sb.append(" <symbol=").append(symbol).append('>');

                }

            }

            log.unindent();

            log.info(sb);

        }

        return node;

    }

    @Override

    public boolean enterBlock(final Block block) {

        start(block);

        if (lc.isFunctionBody()) {

            assert !block.hasSymbols();

            final FunctionNode fn = lc.getCurrentFunction();

            if (isUnparsedFunction(fn)) {

                // It's a skipped nested function. Just mark the symbols being used by it as being in use.

                for(final String name: compiler.getScriptFunctionData(fn.getId()).getExternalSymbolNames()) {

                    nameIsUsed(name, null);

                }

                // Don't bother descending into it, it must be empty anyway.

                assert block.getStatements().isEmpty();

                return false;

            }

            enterFunctionBody();

        }

        return true;

    }

    private boolean isUnparsedFunction(final FunctionNode fn) {

        return isOnDemand && fn != lc.getOutermostFunction();

    }

    @Override

    public boolean enterCatchNode(final CatchNode catchNode) {

        final IdentNode exception = catchNode.getException();

        final Block     block     = lc.getCurrentBlock();

        start(catchNode);

        // define block-local exception variable

        final String exname = exception.getName();

        // If the name of the exception starts with ":e", this is a synthetic catch block, likely a catch-all. Its

        // symbol is naturally internal, and should be treated as such.

        final boolean isInternal = exname.startsWith(EXCEPTION_PREFIX.symbolName());

        // IS_LET flag is required to make sure symbol is not visible outside catch block. However, we need to

        // clear the IS_LET flag after creation to allow redefinition of symbol inside the catch block.

        final Symbol symbol = defineSymbol(block, exname, catchNode, IS_VAR | IS_LET | (isInternal ? IS_INTERNAL : 0) | HAS_OBJECT_VALUE);

        symbol.clearFlag(IS_LET);

        return true;

    }

    private void enterFunctionBody() {

        final FunctionNode functionNode = lc.getCurrentFunction();

        final Block body = lc.getCurrentBlock();

        initFunctionWideVariables(functionNode, body);

        acceptDeclarations(functionNode, body);

        defineFunctionSelfSymbol(functionNode, body);

    }

    private void defineFunctionSelfSymbol(final FunctionNode functionNode, final Block body) {

        // Function self-symbol is only declared as a local variable for named function expressions. Declared functions

        // don't need it as they are local variables in their declaring scope.

        if (!functionNode.isNamedFunctionExpression()) {

            return;

        }

        final String name = functionNode.getIdent().getName();

        assert name != null; // As it's a named function expression.

        if (body.getExistingSymbol(name) != null) {

            // Body already has a declaration for the name. It's either a parameter "function x(x)" or a

            // top-level variable "function x() { ... var x; ... }".

            return;

        }

        defineSymbol(body, name, functionNode, IS_VAR | IS_FUNCTION_SELF | HAS_OBJECT_VALUE);

        if(functionNode.allVarsInScope()) { // basically, has deep eval

            // We must conservatively presume that eval'd code can dynamically use the function symbol.

            lc.setFlag(functionNode, FunctionNode.USES_SELF_SYMBOL);

        }

    }