/*

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

import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.CALLSITE_PROFILE;

import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.CALLSITE_STRICT;

import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.CALLSITE_TRACE;

import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.CALLSITE_TRACE_ENTEREXIT;

import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.CALLSITE_TRACE_MISSES;

import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.CALLSITE_TRACE_VALUES;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import jdk.nashorn.internal.codegen.CompileUnit;

import jdk.nashorn.internal.codegen.Compiler;

import jdk.nashorn.internal.codegen.CompilerConstants;

import jdk.nashorn.internal.codegen.Namespace;

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

import jdk.nashorn.internal.ir.annotations.Ignore;

import jdk.nashorn.internal.ir.annotations.Immutable;

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

import jdk.nashorn.internal.parser.Token;

import jdk.nashorn.internal.runtime.RecompilableScriptFunctionData;

import jdk.nashorn.internal.runtime.ScriptFunction;

import jdk.nashorn.internal.runtime.Source;

import jdk.nashorn.internal.runtime.UserAccessorProperty;

import jdk.nashorn.internal.runtime.linker.LinkerCallSite;

/**

 * IR representation for function (or script.)

 */

@Immutable

public final class FunctionNode extends LexicalContextExpression implements Flags<FunctionNode>, CompileUnitHolder {

    private static final long serialVersionUID = 1L;

    /** Type used for all FunctionNodes */

    public static final Type FUNCTION_TYPE = Type.typeFor(ScriptFunction.class);

    /** Function kinds */

    public enum Kind {

        /** a normal function - nothing special */

        NORMAL,

        /** a script function */

        SCRIPT,

        /** a getter, @see {@link UserAccessorProperty} */

        GETTER,

        /** a setter, @see {@link UserAccessorProperty} */

        SETTER,

        /** an arrow function */

        ARROW,

        /** a generator function */

        GENERATOR,

        /** a module function */

        MODULE

    }

    /** Source of entity. */

    private transient final Source source;

    /**

     * Opaque object representing parser state at the end of the function. Used when reparsing outer functions

     * to skip parsing inner functions.

     */

    private final Object endParserState;

    /** External function identifier. */

    @Ignore

    private final IdentNode ident;

    /** The body of the function node */

    private final Block body;

    /** Internal function name. */

    private final String name;

    /** Compilation unit. */

    private final CompileUnit compileUnit;

    /** Function kind. */

    private final Kind kind;

    /** List of parameters. */

    private final List<IdentNode> parameters;

    /** First token of function. **/

    private final long firstToken;

    /** Last token of function. **/

    private final long lastToken;

    /** Method's namespace. */

    private transient final Namespace namespace;

    /** Number of properties of "this" object assigned in this function */

    @Ignore

    private final int thisProperties;

    /** Function flags. */

    private final int flags;

    /** Line number of function start */

    private final int lineNumber;

    /** Root class for function */

    private final Class<?> rootClass;

    /** The ES6 module */

    private final Module module;

    /** The debug flags */

    private final int debugFlags;

    /** Is anonymous function flag. */

    public static final int IS_ANONYMOUS                = 1 << 0;

    /** Is the function created in a function declaration (as opposed to a function expression) */

    public static final int IS_DECLARED                 = 1 << 1;

    /** is this a strict mode function? */

    public static final int IS_STRICT                   = 1 << 2;

    /** Does the function use the "arguments" identifier ? */

    public static final int USES_ARGUMENTS              = 1 << 3;

    /** Has this function been split because it was too large? */

    public static final int IS_SPLIT                    = 1 << 4;

    /** Does the function call eval? If it does, then all variables in this function might be get/set by it and it can

     * introduce new variables into this function's scope too.*/

    public static final int HAS_EVAL                    = 1 << 5;

    /** Does a nested function contain eval? If it does, then all variables in this function might be get/set by it. */

    public static final int HAS_NESTED_EVAL             = 1 << 6;

    /** Does this function have any blocks that create a scope? This is used to determine if the function needs to

     * have a local variable slot for the scope symbol. */

    public static final int HAS_SCOPE_BLOCK             = 1 << 7;

    /**

     * Flag this function as one that defines the identifier "arguments" as a function parameter or nested function

     * name. This precludes it from needing to have an Arguments object defined as "arguments" local variable. Note that

     * defining a local variable named "arguments" still requires construction of the Arguments object (see

     * ECMAScript 5.1 Chapter 10.5).

     * @see #needsArguments()

     */

    public static final int DEFINES_ARGUMENTS           = 1 << 8;

    /** Does this function or any of its descendants use variables from an ancestor function's scope (incl. globals)? */

    public static final int USES_ANCESTOR_SCOPE         = 1 << 9;

    /** Does this function have nested declarations? */

    public static final int HAS_FUNCTION_DECLARATIONS   = 1 << 10;

    /** Does this function have optimistic expressions? (If it does, it can undergo deoptimizing recompilation.) */

    public static final int IS_DEOPTIMIZABLE            = 1 << 11;

    /** Are we vararg, but do we just pass the arguments along to apply or call */

    public static final int HAS_APPLY_TO_CALL_SPECIALIZATION = 1 << 12;

    /**

     * Is this function the top-level program?

     */

    public static final int IS_PROGRAM                  = 1 << 13;

    /**

     * Flag indicating whether this function uses the local variable symbol for itself. Only named function expressions

     * can have this flag set if they reference themselves (e.g. "(function f() { return f })". Declared functions will

     * use the symbol in their parent scope instead when they reference themselves by name.

     */

    public static final int USES_SELF_SYMBOL            = 1 << 14;

    /** Does this function use the "this" keyword? */

    public static final int USES_THIS                   = 1 << 15;

    /** Is this declared in a dynamic context */

    public static final int IN_DYNAMIC_CONTEXT          = 1 << 16;

    /**

     * Whether this function needs the callee {@link ScriptFunction} instance passed to its code as a

     * parameter on invocation. Note that we aren't, in fact using this flag in function nodes.

     * Rather, it is always calculated (see {@link #needsCallee()}). {@link RecompilableScriptFunctionData}

     * will, however, cache the value of this flag.

     */

    public static final int NEEDS_CALLEE                = 1 << 17;

    /**

     * Is the function node cached?

     */

    public static final int IS_CACHED                   = 1 << 18;

    /**

     * Does this function contain a super call? (cf. ES6 14.3.5 Static Semantics: HasDirectSuper)

     */

    public static final int ES6_HAS_DIRECT_SUPER        = 1 << 19;

    /**

     * Does this function use the super binding?

     */

    public static final int ES6_USES_SUPER              = 1 << 20;

    /**

     * Is this function a (class or object) method?

     */

    public static final int ES6_IS_METHOD               = 1 << 21;

    /**

     * Is this the constructor method?

     */

    public static final int ES6_IS_CLASS_CONSTRUCTOR    = 1 << 22;

    /** Is this the constructor of a subclass (i.e., a class with an extends declaration)? */

    public static final int ES6_IS_SUBCLASS_CONSTRUCTOR = 1 << 23;

    /** is this a strong mode function? */

    public static final int ES6_IS_STRONG               = 1 << 24;

    /** Does this function use new.target? */

    public static final int ES6_USES_NEW_TARGET         = 1 << 25;

    /** Does this function or any nested functions contain an eval? */

    private static final int HAS_DEEP_EVAL = HAS_EVAL | HAS_NESTED_EVAL;

    /** Does this function need to store all its variables in scope? */

    public static final int HAS_ALL_VARS_IN_SCOPE = HAS_DEEP_EVAL;

    /** Does this function potentially need "arguments"? Note that this is not a full test, as further negative check of REDEFINES_ARGS is needed. */

    private static final int MAYBE_NEEDS_ARGUMENTS = USES_ARGUMENTS | HAS_EVAL;

    /** Does this function need the parent scope? It needs it if either it or its descendants use variables from it, or have a deep eval, or it's the program. */

    public static final int NEEDS_PARENT_SCOPE = USES_ANCESTOR_SCOPE | HAS_DEEP_EVAL | IS_PROGRAM;

    /**

     * The following flags are derived from directive comments within this function.

     * Note that even IS_STRICT is one such flag but that requires special handling.

     */

    /** parser, print parse tree */

    public static final int DEBUG_PRINT_PARSE       = 1 << 0;

    /** parser, print lower parse tree */

    public static final int DEBUG_PRINT_LOWER_PARSE = 1 << 1;

    /** parser, print AST */

    public static final int DEBUG_PRINT_AST         = 1 << 2;

    /** parser, print lower AST */

    public static final int DEBUG_PRINT_LOWER_AST   = 1 << 3;

    /** parser, print symbols */

    public static final int DEBUG_PRINT_SYMBOLS     = 1 << 4;

    // callsite tracing, profiling within this function

    /** profile callsites in this function? */

    public static final int DEBUG_PROFILE           = 1 << 5;

    /** trace callsite enterexit in this function? */

    public static final int DEBUG_TRACE_ENTEREXIT   = 1 << 6;

    /** trace callsite misses in this function? */

    public static final int DEBUG_TRACE_MISSES      = 1 << 7;

    /** trace callsite values in this function? */

    public static final int DEBUG_TRACE_VALUES      = 1 << 8;

    /** extension callsite flags mask */

    public static final int DEBUG_CALLSITE_FLAGS = DEBUG_PRINT_PARSE |

            DEBUG_PRINT_LOWER_PARSE | DEBUG_PRINT_AST | DEBUG_PRINT_LOWER_AST |

            DEBUG_PRINT_SYMBOLS | DEBUG_PROFILE | DEBUG_TRACE_ENTEREXIT |

            DEBUG_TRACE_MISSES | DEBUG_TRACE_VALUES;

    /** What is the return type of this function? */

    public Type returnType = Type.UNKNOWN;

    /**

     * Constructor

     *

     * @param source     the source

     * @param lineNumber line number

     * @param token      token

     * @param finish     finish

     * @param firstToken first token of the function node (including the function declaration)

     * @param lastToken  lastToken

     * @param namespace  the namespace

     * @param ident      the identifier

     * @param name       the name of the function

     * @param parameters parameter list

     * @param kind       kind of function as in {@link FunctionNode.Kind}

     * @param flags      initial flags

     * @param body       body of the function

     * @param endParserState The parser state at the end of the parsing.

     * @param module     the module

     * @param debugFlags the debug flags

     */

    public FunctionNode(

        final Source source,

        final int lineNumber,

        final long token,

        final int finish,

        final long firstToken,

        final long lastToken,

        final Namespace namespace,

        final IdentNode ident,

        final String name,

        final List<IdentNode> parameters,

        final FunctionNode.Kind kind,

        final int flags,

        final Block body,

        final Object endParserState,

        final Module module,

        final int debugFlags) {

        super(token, finish);

        this.source           = source;

        this.lineNumber       = lineNumber;

        this.ident            = ident;

        this.name             = name;

        this.kind             = kind;

        this.parameters       = parameters;

        this.firstToken       = firstToken;

        this.lastToken        = lastToken;

        this.namespace        = namespace;

        this.flags            = flags;

        this.compileUnit      = null;

        this.body             = body;

        this.thisProperties   = 0;

        this.rootClass        = null;

        this.endParserState   = endParserState;

        this.module           = module;

        this.debugFlags       = debugFlags;

    }

    private FunctionNode(

        final FunctionNode functionNode,

        final long lastToken,

        final Object endParserState,

        final int flags,

        final String name,

        final Type returnType,

        final CompileUnit compileUnit,

        final Block body,

        final List<IdentNode> parameters,

        final int thisProperties,

        final Class<?> rootClass,

        final Source source, final Namespace namespace) {

        super(functionNode);

        this.endParserState    = endParserState;

        this.lineNumber       = functionNode.lineNumber;

        this.flags            = flags;

        this.name             = name;

        this.returnType       = returnType;

        this.compileUnit      = compileUnit;

        this.lastToken        = lastToken;

        this.body             = body;

        this.parameters       = parameters;

        this.thisProperties   = thisProperties;

        this.rootClass        = rootClass;

        this.source           = source;

        this.namespace        = namespace;

        // the fields below never change - they are final and assigned in constructor

        this.ident           = functionNode.ident;

        this.kind            = functionNode.kind;

        this.firstToken      = functionNode.firstToken;

        this.module          = functionNode.module;

        this.debugFlags      = functionNode.debugFlags;

    }

    @Override

    public Node accept(final LexicalContext lc, final NodeVisitor<? extends LexicalContext> visitor) {

        if (visitor.enterFunctionNode(this)) {

            return visitor.leaveFunctionNode(setBody(lc, (Block)body.accept(visitor)));

        }

        return this;

    }

    /**

     * Visits the parameter nodes of this function. Parameters are normally not visited automatically.

     * @param visitor the visitor to apply to the nodes.

     * @return a list of parameter nodes, potentially modified from original ones by the visitor.

     */

    public List<IdentNode> visitParameters(final NodeVisitor<? extends LexicalContext> visitor) {

        return Node.accept(visitor, parameters);

    }

    /**

     * Get additional callsite flags to be used specific to this function.

     *

     * @return callsite flags

     */

    public int getCallSiteFlags() {

        int callsiteFlags = 0;

        if (getFlag(IS_STRICT)) {

            callsiteFlags |= CALLSITE_STRICT;

        }

        // quick check for extension callsite flags turned on by directives.

        if ((debugFlags & DEBUG_CALLSITE_FLAGS) == 0) {

            return callsiteFlags;

        }

        if (getDebugFlag(DEBUG_PROFILE)) {

            callsiteFlags |= CALLSITE_PROFILE;

        }

        if (getDebugFlag(DEBUG_TRACE_MISSES)) {

            callsiteFlags |= CALLSITE_TRACE | CALLSITE_TRACE_MISSES;

        }

        if (getDebugFlag(DEBUG_TRACE_VALUES)) {

            callsiteFlags |= CALLSITE_TRACE | CALLSITE_TRACE_ENTEREXIT | CALLSITE_TRACE_VALUES;

        }

        if (getDebugFlag(DEBUG_TRACE_ENTEREXIT)) {

            callsiteFlags |= CALLSITE_TRACE | CALLSITE_TRACE_ENTEREXIT;

        }

        return callsiteFlags;

    }

    /**

     * Get the source for this function

     * @return the source

     */

    public Source getSource() {

        return source;

    }

    /**

     * Sets the source and namespace for this function. It can only set a non-null source and namespace for a function

     * that currently has both a null source and a null namespace. This is used to re-set the source and namespace for

     * a deserialized function node.

     * @param source the source for the function.

     * @param namespace the namespace for the function

     * @return a new function node with the set source and namespace

     * @throws IllegalArgumentException if the specified source or namespace is null

     * @throws IllegalStateException if the function already has either a source or namespace set.

     */

    public FunctionNode initializeDeserialized(final Source source, final Namespace namespace) {

        if (source == null || namespace == null) {

            throw new IllegalArgumentException();

        } else if (this.source == source && this.namespace == namespace) {

            return this;

        } else if (this.source != null || this.namespace != null) {

            throw new IllegalStateException();

        }

        return new FunctionNode(

            this,

            lastToken,

            endParserState,

            flags,

            name,

            returnType,

            compileUnit,

            body,

            parameters,