/*

 * Copyright (c) 2010, 2016, 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.runtime;

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

import static jdk.nashorn.internal.lookup.Lookup.MH;

import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;

import static jdk.nashorn.internal.runtime.ScriptRuntime.UNDEFINED;

import static jdk.nashorn.internal.runtime.UnwarrantedOptimismException.INVALID_PROGRAM_POINT;

import java.lang.invoke.MethodHandle;

import java.lang.invoke.MethodHandles;

import java.lang.invoke.MethodHandles.Lookup;

import java.lang.invoke.MethodType;

import java.lang.invoke.SwitchPoint;

import java.security.AccessControlContext;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.HashSet;

import java.util.List;

import java.util.concurrent.atomic.LongAdder;

import jdk.dynalink.CallSiteDescriptor;

import jdk.dynalink.SecureLookupSupplier;

import jdk.dynalink.linker.GuardedInvocation;

import jdk.dynalink.linker.LinkRequest;

import jdk.dynalink.linker.support.Guards;

import jdk.nashorn.internal.codegen.ApplySpecialization;

import jdk.nashorn.internal.codegen.Compiler;

import jdk.nashorn.internal.codegen.CompilerConstants.Call;

import jdk.nashorn.internal.ir.FunctionNode;

import jdk.nashorn.internal.objects.Global;

import jdk.nashorn.internal.objects.NativeFunction;

import jdk.nashorn.internal.objects.annotations.SpecializedFunction.LinkLogic;

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

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

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

/**

 * Runtime representation of a JavaScript function. This class has only private

 * and protected constructors. There are no *public* constructors - but only

 * factory methods that follow the naming pattern "createXYZ".

 */

public class ScriptFunction extends ScriptObject {

    /**

     * Method handle for prototype getter for this ScriptFunction

     */

    public static final MethodHandle G$PROTOTYPE = findOwnMH_S("G$prototype", Object.class, Object.class);

    /**

     * Method handle for prototype setter for this ScriptFunction

     */

    public static final MethodHandle S$PROTOTYPE = findOwnMH_S("S$prototype", void.class, Object.class, Object.class);

    /**

     * Method handle for length getter for this ScriptFunction

     */

    public static final MethodHandle G$LENGTH = findOwnMH_S("G$length", int.class, Object.class);

    /**

     * Method handle for name getter for this ScriptFunction

     */

    public static final MethodHandle G$NAME = findOwnMH_S("G$name", Object.class, Object.class);

    /**

     * Method handle used for implementing sync() in mozilla_compat

     */

    public static final MethodHandle INVOKE_SYNC = findOwnMH_S("invokeSync", Object.class, ScriptFunction.class, Object.class, Object.class, Object[].class);

    /**

     * Method handle for allocate function for this ScriptFunction

     */

    static final MethodHandle ALLOCATE = findOwnMH_V("allocate", Object.class);

    private static final MethodHandle WRAPFILTER = findOwnMH_S("wrapFilter", Object.class, Object.class);

    private static final MethodHandle SCRIPTFUNCTION_GLOBALFILTER = findOwnMH_S("globalFilter", Object.class, Object.class);

    /**

     * method handle to scope getter for this ScriptFunction

     */

    public static final Call GET_SCOPE = virtualCallNoLookup(ScriptFunction.class, "getScope", ScriptObject.class);

    private static final MethodHandle IS_FUNCTION_MH = findOwnMH_S("isFunctionMH", boolean.class, Object.class, ScriptFunctionData.class);

    private static final MethodHandle IS_APPLY_FUNCTION = findOwnMH_S("isApplyFunction", boolean.class, boolean.class, Object.class, Object.class);

    private static final MethodHandle IS_NONSTRICT_FUNCTION = findOwnMH_S("isNonStrictFunction", boolean.class, Object.class, Object.class, ScriptFunctionData.class);

    private static final MethodHandle ADD_ZEROTH_ELEMENT = findOwnMH_S("addZerothElement", Object[].class, Object[].class, Object.class);

    private static final MethodHandle WRAP_THIS = MH.findStatic(MethodHandles.lookup(), ScriptFunctionData.class, "wrapThis", MH.type(Object.class, Object.class));

    // various property maps used for different kinds of functions

    // property map for anonymous function that serves as Function.prototype

    private static final PropertyMap anonmap$;

    // property map for strict mode functions

    private static final PropertyMap strictmodemap$;

    // property map for bound functions

    private static final PropertyMap boundfunctionmap$;

    // property map for non-strict, non-bound functions.

    private static final PropertyMap map$;

    // Marker object for lazily initialized prototype object

    private static final Object LAZY_PROTOTYPE = new Object();

    private static final AccessControlContext GET_LOOKUP_PERMISSION_CONTEXT =

            AccessControlContextFactory.createAccessControlContext(SecureLookupSupplier.GET_LOOKUP_PERMISSION_NAME);

    private static PropertyMap createStrictModeMap(final PropertyMap map) {

        final int flags = Property.NOT_ENUMERABLE | Property.NOT_CONFIGURABLE;

        PropertyMap newMap = map;

        // Need to add properties directly to map since slots are assigned speculatively by newUserAccessors.

        newMap = newMap.addPropertyNoHistory(newMap.newUserAccessors("arguments", flags));

        newMap = newMap.addPropertyNoHistory(newMap.newUserAccessors("caller", flags));

        return newMap;

    }

    private static PropertyMap createBoundFunctionMap(final PropertyMap strictModeMap) {

        // Bound function map is same as strict function map, but additionally lacks the "prototype" property, see

        // ECMAScript 5.1 section 15.3.4.5

        return strictModeMap.deleteProperty(strictModeMap.findProperty("prototype"));

    }

    static {

        anonmap$ = PropertyMap.newMap();

        final ArrayList<Property> properties = new ArrayList<>(3);

        properties.add(AccessorProperty.create("prototype", Property.NOT_ENUMERABLE | Property.NOT_CONFIGURABLE, G$PROTOTYPE, S$PROTOTYPE));

        properties.add(AccessorProperty.create("length", Property.NOT_ENUMERABLE | Property.NOT_CONFIGURABLE | Property.NOT_WRITABLE, G$LENGTH, null));

        properties.add(AccessorProperty.create("name", Property.NOT_ENUMERABLE | Property.NOT_CONFIGURABLE | Property.NOT_WRITABLE, G$NAME, null));

        map$ = PropertyMap.newMap(properties);

        strictmodemap$ = createStrictModeMap(map$);

        boundfunctionmap$ = createBoundFunctionMap(strictmodemap$);

    }

    private static boolean isStrict(final int flags) {

        return (flags & ScriptFunctionData.IS_STRICT) != 0;

    }

    // Choose the map based on strict mode!

    private static PropertyMap getMap(final boolean strict) {

        return strict ? strictmodemap$ : map$;

    }

    /**

     * The parent scope.

     */

    private final ScriptObject scope;

    private final ScriptFunctionData data;

    /**

     * The property map used for newly allocated object when function is used as

     * constructor.

     */

    protected PropertyMap allocatorMap;

    /**

     * Reference to constructor prototype.

     */

    protected Object prototype;

    /**

     * Constructor

     *

     * @param data static function data

     * @param map property map

     * @param scope scope

     */

    private ScriptFunction(

            final ScriptFunctionData data,

            final PropertyMap map,

            final ScriptObject scope,

            final Global global) {

        super(map);

        if (Context.DEBUG) {

            constructorCount.increment();

        }

        this.data = data;

        this.scope = scope;

        this.setInitialProto(global.getFunctionPrototype());

        this.prototype = LAZY_PROTOTYPE;

        // We have to fill user accessor functions late as these are stored

        // in this object rather than in the PropertyMap of this object.

        assert objectSpill == null;

        if (isStrict() || isBoundFunction()) {

            final ScriptFunction typeErrorThrower = global.getTypeErrorThrower();

            initUserAccessors("arguments", typeErrorThrower, typeErrorThrower);

            initUserAccessors("caller", typeErrorThrower, typeErrorThrower);

        }

    }

    /**

     * Constructor

     *

     * @param name function name

     * @param methodHandle method handle to function (if specializations are

     * present, assumed to be most generic)

     * @param map property map

     * @param scope scope

     * @param specs specialized version of this function - other method handles

     * @param flags {@link ScriptFunctionData} flags

     */

    private ScriptFunction(

            final String name,

            final MethodHandle methodHandle,

            final PropertyMap map,

            final ScriptObject scope,

            final Specialization[] specs,

            final int flags,

            final Global global) {

        this(new FinalScriptFunctionData(name, methodHandle, specs, flags), map, scope, global);

    }

    /**

     * Constructor

     *

     * @param name name of function

     * @param methodHandle handle for invocation

     * @param scope scope object

     * @param specs specialized versions of this method, if available, null

     * otherwise

     * @param flags {@link ScriptFunctionData} flags

     */

    private ScriptFunction(

            final String name,

            final MethodHandle methodHandle,

            final ScriptObject scope,

            final Specialization[] specs,

            final int flags) {

        this(name, methodHandle, getMap(isStrict(flags)), scope, specs, flags, Global.instance());

    }

    /**

     * Constructor called by Nasgen generated code, zero added members, use the

     * default map. Creates builtin functions only.

     *

     * @param name name of function

     * @param invokeHandle handle for invocation

     * @param specs specialized versions of this method, if available, null

     * otherwise

     */

    protected ScriptFunction(final String name, final MethodHandle invokeHandle, final Specialization[] specs) {

        this(name, invokeHandle, map$, null, specs, ScriptFunctionData.IS_BUILTIN_CONSTRUCTOR, Global.instance());

    }

    /**

     * Constructor called by Nasgen generated code, non zero member count, use

     * the map passed as argument. Creates builtin functions only.

     *

     * @param name name of function

     * @param invokeHandle handle for invocation

     * @param map initial property map

     * @param specs specialized versions of this method, if available, null

     * otherwise

     */

    protected ScriptFunction(final String name, final MethodHandle invokeHandle, final PropertyMap map, final Specialization[] specs) {

        this(name, invokeHandle, map.addAll(map$), null, specs, ScriptFunctionData.IS_BUILTIN_CONSTRUCTOR, Global.instance());

    }

    // Factory methods to create various functions

    /**

     * Factory method called by compiler generated code for functions that need

     * parent scope.

     *

     * @param constants the generated class' constant array

     * @param index the index of the {@code RecompilableScriptFunctionData}

     * object in the constants array.

     * @param scope the parent scope object

     * @return a newly created function object

     */

    public static ScriptFunction create(final Object[] constants, final int index, final ScriptObject scope) {

        final RecompilableScriptFunctionData data = (RecompilableScriptFunctionData) constants[index];

        return new ScriptFunction(data, getMap(data.isStrict()), scope, Global.instance());

    }

    /**

     * Factory method called by compiler generated code for functions that don't

     * need parent scope.

     *

     * @param constants the generated class' constant array

     * @param index the index of the {@code RecompilableScriptFunctionData}

     * object in the constants array.

     * @return a newly created function object

     */

    public static ScriptFunction create(final Object[] constants, final int index) {

        return create(constants, index, null);

    }

    /**

     * Create anonymous function that serves as Function.prototype

     *

     * @return anonymous function object

     */

    public static ScriptFunction createAnonymous() {

        return new ScriptFunction("", GlobalFunctions.ANONYMOUS, anonmap$, null);

    }

    // builtin function create helper factory

    private static ScriptFunction createBuiltin(final String name, final MethodHandle methodHandle, final Specialization[] specs, final int flags) {

        final ScriptFunction func = new ScriptFunction(name, methodHandle, null, specs, flags);

        func.setPrototype(UNDEFINED);

        // Non-constructor built-in functions do not have "prototype" property

        func.deleteOwnProperty(func.getMap().findProperty("prototype"));

        return func;

    }

    /**

     * Factory method for non-constructor built-in functions

     *

     * @param name function name

     * @param methodHandle handle for invocation

     * @param specs specialized versions of function if available, null

     * otherwise

     * @return new ScriptFunction

     */

    public static ScriptFunction createBuiltin(final String name, final MethodHandle methodHandle, final Specialization[] specs) {

        return ScriptFunction.createBuiltin(name, methodHandle, specs, ScriptFunctionData.IS_BUILTIN);

    }

    /**

     * Factory method for non-constructor built-in functions

     *

     * @param name function name

     * @param methodHandle handle for invocation

     * @return new ScriptFunction

     */

    public static ScriptFunction createBuiltin(final String name, final MethodHandle methodHandle) {

        return ScriptFunction.createBuiltin(name, methodHandle, null);

    }

    /**

     * Factory method for non-constructor built-in, strict functions

     *

     * @param name function name

     * @param methodHandle handle for invocation

     * @return new ScriptFunction

     */

    public static ScriptFunction createStrictBuiltin(final String name, final MethodHandle methodHandle) {

        return ScriptFunction.createBuiltin(name, methodHandle, null, ScriptFunctionData.IS_BUILTIN | ScriptFunctionData.IS_STRICT);

    }

    // Subclass to represent bound functions

    private static class Bound extends ScriptFunction {

        private final ScriptFunction target;

        Bound(final ScriptFunctionData boundData, final ScriptFunction target) {

            super(boundData, boundfunctionmap$, null, Global.instance());

            setPrototype(ScriptRuntime.UNDEFINED);

            this.target = target;

        }

        @Override

        protected ScriptFunction getTargetFunction() {

            return target;

        }

    }

    /**

     * Creates a version of this function bound to a specific "self" and other

     * arguments, as per {@code Function.prototype.bind} functionality in

     * ECMAScript 5.1 section 15.3.4.5.

     *

     * @param self the self to bind to this function. Can be null (in which

     * case, null is bound as this).

     * @param args additional arguments to bind to this function. Can be null or

     * empty to not bind additional arguments.

     * @return a function with the specified self and parameters bound.

     */

    public final ScriptFunction createBound(final Object self, final Object[] args) {

        return new Bound(data.makeBoundFunctionData(this, self, args), getTargetFunction());

    }

    /**

     * Create a function that invokes this function synchronized on {@code sync}

     * or the self object of the invocation.

     *

     * @param sync the Object to synchronize on, or undefined

     * @return synchronized function

     */

    public final ScriptFunction createSynchronized(final Object sync) {

        final MethodHandle mh = MH.insertArguments(ScriptFunction.INVOKE_SYNC, 0, this, sync);

        return createBuiltin(getName(), mh);

    }

    @Override

    public String getClassName() {

        return "Function";

    }

    /**

     * ECMA 15.3.5.3 [[HasInstance]] (V) Step 3 if "prototype" value is not an

     * Object, throw TypeError

     */

    @Override

    public boolean isInstance(final ScriptObject instance) {

        final Object basePrototype = getTargetFunction().getPrototype();

        if (!(basePrototype instanceof ScriptObject)) {

            throw typeError("prototype.not.an.object", ScriptRuntime.safeToString(getTargetFunction()), ScriptRuntime.safeToString(basePrototype));

        }

        for (ScriptObject proto = instance.getProto(); proto != null; proto = proto.getProto()) {

            if (proto == basePrototype) {

                return true;

            }

        }

        return false;

    }

    /**

     * Returns the target function for this function. If the function was not

     * created using {@link #createBound(Object, Object[])}, its target

     * function is itself. If it is bound, its target function is the target

     * function of the function it was made from (therefore, the target function

     * is always the final, unbound recipient of the calls).

     *

     * @return the target function for this function.

     */

    protected ScriptFunction getTargetFunction() {

        return this;

    }

    final boolean isBoundFunction() {

        return getTargetFunction() != this;

    }

    /**

     * Set the arity of this ScriptFunction

     *

     * @param arity arity

     */

    public final void setArity(final int arity) {

        data.setArity(arity);

    }

    /**

     * Is this a ECMAScript 'use strict' function?

     *

     * @return true if function is in strict mode

     */

    public final boolean isStrict() {

        return data.isStrict();

    }

    /**

     * Is this is a function with all variables in scope?

     * @return true if function has all

     */

    public boolean hasAllVarsInScope() {

        return data instanceof RecompilableScriptFunctionData &&

                (((RecompilableScriptFunctionData) data).getFunctionFlags() & FunctionNode.HAS_ALL_VARS_IN_SCOPE) != 0;

    }

    /**

     * Returns true if this is a non-strict, non-built-in function that requires

     * non-primitive this argument according to ECMA 10.4.3.

     *

     * @return true if this argument must be an object

     */

    public final boolean needsWrappedThis() {

        return data.needsWrappedThis();

    }