/*

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

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

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

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

import static jdk.nashorn.internal.codegen.ObjectClassGenerator.OBJECT_FIELDS_ONLY;

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

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

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

import static jdk.nashorn.internal.runtime.JSType.UNDEFINED_DOUBLE;

import static jdk.nashorn.internal.runtime.JSType.UNDEFINED_INT;

import static jdk.nashorn.internal.runtime.JSType.UNDEFINED_LONG;

import static jdk.nashorn.internal.runtime.PropertyDescriptor.CONFIGURABLE;

import static jdk.nashorn.internal.runtime.PropertyDescriptor.ENUMERABLE;

import static jdk.nashorn.internal.runtime.PropertyDescriptor.GET;

import static jdk.nashorn.internal.runtime.PropertyDescriptor.SET;

import static jdk.nashorn.internal.runtime.PropertyDescriptor.VALUE;

import static jdk.nashorn.internal.runtime.PropertyDescriptor.WRITABLE;

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

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

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

import static jdk.nashorn.internal.runtime.arrays.ArrayIndex.getArrayIndex;

import static jdk.nashorn.internal.runtime.arrays.ArrayIndex.isValidArrayIndex;

import static jdk.nashorn.internal.runtime.linker.NashornGuards.explicitInstanceOfCheck;

import java.lang.invoke.MethodHandle;

import java.lang.invoke.MethodHandles;

import java.lang.invoke.MethodType;

import java.lang.invoke.SwitchPoint;

import java.util.AbstractMap;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.HashSet;

import java.util.Iterator;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import jdk.internal.dynalink.CallSiteDescriptor;

import jdk.internal.dynalink.linker.GuardedInvocation;

import jdk.internal.dynalink.linker.LinkRequest;

import jdk.internal.dynalink.support.CallSiteDescriptorFactory;

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

import jdk.nashorn.internal.codegen.ObjectClassGenerator;

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

import jdk.nashorn.internal.lookup.Lookup;

import jdk.nashorn.internal.objects.AccessorPropertyDescriptor;

import jdk.nashorn.internal.objects.DataPropertyDescriptor;

import jdk.nashorn.internal.objects.Global;

import jdk.nashorn.internal.objects.NativeArray;

import jdk.nashorn.internal.runtime.arrays.ArrayData;

import jdk.nashorn.internal.runtime.arrays.ArrayIndex;

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

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

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

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

/**

 * Base class for generic JavaScript objects.

 * <p>

 * Notes:

 * <ul>

 * <li>The map is used to identify properties in the object.</li>

 * <li>If the map is modified then it must be cloned and replaced.  This notifies

 *     any code that made assumptions about the object that things have changed.

 *     Ex. CallSites that have been validated must check to see if the map has

 *     changed (or a map from a different object type) and hence relink the method

 *     to call.</li>

 * <li>Modifications of the map include adding/deleting attributes or changing a

 *     function field value.</li>

 * </ul>

 */

public abstract class ScriptObject implements PropertyAccess {

    /** __proto__ special property name inside object literals. ES6 draft. */

    public static final String PROTO_PROPERTY_NAME   = "__proto__";

    /** Search fall back routine name for "no such method" */

    public static final String NO_SUCH_METHOD_NAME   = "__noSuchMethod__";

    /** Search fall back routine name for "no such property" */

    public static final String NO_SUCH_PROPERTY_NAME = "__noSuchProperty__";

    /** Per ScriptObject flag - is this a scope object? */

    public static final int IS_SCOPE       = 1 << 0;

    /** Per ScriptObject flag - is this an array object? */

    public static final int IS_ARRAY       = 1 << 1;

    /** Per ScriptObject flag - is this an arguments object? */

    public static final int IS_ARGUMENTS   = 1 << 2;

    /** Is length property not-writable? */

    public static final int IS_LENGTH_NOT_WRITABLE = 1 << 3;

    /** Is this a builtin object? */

    public static final int IS_BUILTIN = 1 << 4;

    /**

     * Spill growth rate - by how many elements does {@link ScriptObject#primitiveSpill} and

     * {@link ScriptObject#objectSpill} when full

     */

    public static final int SPILL_RATE = 8;

    /** Map to property information and accessor functions. Ordered by insertion. */

    private PropertyMap map;

    /** objects proto. */

    private ScriptObject proto;

    /** Object flags. */

    private int flags;

    /** Area for primitive properties added to object after instantiation, see {@link AccessorProperty} */

    protected long[]   primitiveSpill;

    /** Area for reference properties added to object after instantiation, see {@link AccessorProperty} */

    protected Object[] objectSpill;

    /**

     * Number of elements in the spill. This may be less than the spill array lengths, if not all of

     * the allocated memory is in use

     */

    private int spillLength;

    /** Indexed array data. */

    private ArrayData arrayData;

    /** Method handle to retrieve prototype of this object */

    public static final MethodHandle GETPROTO      = findOwnMH_V("getProto", ScriptObject.class);

    static final MethodHandle MEGAMORPHIC_GET    = findOwnMH_V("megamorphicGet", Object.class, String.class, boolean.class);

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

    static final MethodHandle DECLARE_AND_SET    = findOwnMH_V("declareAndSet", void.class, String.class, Object.class);

    private static final MethodHandle TRUNCATINGFILTER   = findOwnMH_S("truncatingFilter", Object[].class, int.class, Object[].class);

    private static final MethodHandle KNOWNFUNCPROPGUARDSELF = findOwnMH_S("knownFunctionPropertyGuardSelf", boolean.class, Object.class, PropertyMap.class, MethodHandle.class, ScriptFunction.class);

    private static final MethodHandle KNOWNFUNCPROPGUARDPROTO = findOwnMH_S("knownFunctionPropertyGuardProto", boolean.class, Object.class, PropertyMap.class, MethodHandle.class, int.class, ScriptFunction.class);

    private static final ArrayList<MethodHandle> PROTO_FILTERS = new ArrayList<>();

    /** Method handle for getting the array data */

    public static final Call GET_ARRAY          = virtualCall(MethodHandles.lookup(), ScriptObject.class, "getArray", ArrayData.class);

    /** Method handle for getting the property map - debugging purposes */

    public static final Call GET_MAP            = virtualCall(MethodHandles.lookup(), ScriptObject.class, "getMap", PropertyMap.class);

    /** Method handle for setting the array data */

    public static final Call SET_ARRAY          = virtualCall(MethodHandles.lookup(), ScriptObject.class, "setArray", void.class, ArrayData.class);

    /** Method handle for getting a function argument at a given index. Used from MapCreator */

    public static final Call GET_ARGUMENT       = virtualCall(MethodHandles.lookup(), ScriptObject.class, "getArgument", Object.class, int.class);

    /** Method handle for setting a function argument at a given index. Used from MapCreator */

    public static final Call SET_ARGUMENT       = virtualCall(MethodHandles.lookup(), ScriptObject.class, "setArgument", void.class, int.class, Object.class);

    /** Method handle for getting the proto of a ScriptObject */

    public static final Call GET_PROTO          = virtualCallNoLookup(ScriptObject.class, "getProto", ScriptObject.class);

    /** Method handle for getting the proto of a ScriptObject */

    public static final Call GET_PROTO_DEPTH    = virtualCallNoLookup(ScriptObject.class, "getProto", ScriptObject.class, int.class);

    /** Method handle for setting the proto of a ScriptObject */

    public static final Call SET_GLOBAL_OBJECT_PROTO = staticCallNoLookup(ScriptObject.class, "setGlobalObjectProto", void.class, ScriptObject.class);

    /** Method handle for setting the proto of a ScriptObject after checking argument */

    public static final Call SET_PROTO_FROM_LITERAL    = virtualCallNoLookup(ScriptObject.class, "setProtoFromLiteral", void.class, Object.class);

    /** Method handle for setting the user accessors of a ScriptObject */

    //TODO fastpath this

    public static final Call SET_USER_ACCESSORS = virtualCall(MethodHandles.lookup(), ScriptObject.class, "setUserAccessors", void.class, String.class, ScriptFunction.class, ScriptFunction.class);

    static final MethodHandle[] SET_SLOW = new MethodHandle[] {

        findOwnMH_V("set", void.class, Object.class, int.class, int.class),

        findOwnMH_V("set", void.class, Object.class, long.class, int.class),

        findOwnMH_V("set", void.class, Object.class, double.class, int.class),

        findOwnMH_V("set", void.class, Object.class, Object.class, int.class)

    };

    /** Method handle to reset the map of this ScriptObject */

    public static final Call SET_MAP = virtualCallNoLookup(ScriptObject.class, "setMap", void.class, PropertyMap.class);

    static final MethodHandle CAS_MAP           = findOwnMH_V("compareAndSetMap", boolean.class, PropertyMap.class, PropertyMap.class);

    static final MethodHandle EXTENSION_CHECK   = findOwnMH_V("extensionCheck", boolean.class, boolean.class, String.class);

    static final MethodHandle ENSURE_SPILL_SIZE = findOwnMH_V("ensureSpillSize", Object.class, int.class);

    /**

     * Constructor

     */

    public ScriptObject() {

        this(null);

    }

    /**

    * Constructor

    *

    * @param map {@link PropertyMap} used to create the initial object

    */

    public ScriptObject(final PropertyMap map) {

        if (Context.DEBUG) {

            ScriptObject.count++;

        }

        this.arrayData = ArrayData.EMPTY_ARRAY;

        this.setMap(map == null ? PropertyMap.newMap() : map);

    }

    /**

     * Constructor that directly sets the prototype to {@code proto} and property map to

     * {@code map} without invalidating the map as calling {@link #setProto(ScriptObject)}

     * would do. This should only be used for objects that are always constructed with the

     * same combination of prototype and property map.

     *

     * @param proto the prototype object

     * @param map intial {@link PropertyMap}

     */

    protected ScriptObject(final ScriptObject proto, final PropertyMap map) {

        this(map);

        this.proto = proto;

    }

    /**

     * Constructor used to instantiate spill properties directly. Used from

     * SpillObjectCreator.

     *

     * @param map            property maps

     * @param primitiveSpill primitive spills

     * @param objectSpill    reference spills

     */

    public ScriptObject(final PropertyMap map, final long[] primitiveSpill, final Object[] objectSpill) {

        this(map);

        this.primitiveSpill = primitiveSpill;

        this.objectSpill    = objectSpill;

        assert primitiveSpill.length == objectSpill.length : " primitive spill pool size is not the same length as object spill pool size";

        this.spillLength = spillAllocationLength(primitiveSpill.length);

    }

    /**

     * Check whether this is a global object

     * @return true if global

     */

    protected boolean isGlobal() {

        return false;

    }

    private static int alignUp(final int size, final int alignment) {

        return size + alignment - 1 & ~(alignment - 1);

    }

    /**

     * Given a number of properties, return the aligned to SPILL_RATE

     * buffer size required for the smallest spill pool needed to

     * house them

     * @param nProperties number of properties

     * @return property buffer length, a multiple of SPILL_RATE

     */

    public static int spillAllocationLength(final int nProperties) {

        return alignUp(nProperties, SPILL_RATE);

    }

    /**

     * Copy all properties from the source object with their receiver bound to the source.

     * This function was known as mergeMap

     *

     * @param source The source object to copy from.

     */

    public void addBoundProperties(final ScriptObject source) {

        addBoundProperties(source, source.getMap().getProperties());

    }

    /**

     * Copy all properties from the array with their receiver bound to the source.

     *

     * @param source The source object to copy from.

     * @param properties The array of properties to copy.

     */

    public void addBoundProperties(final ScriptObject source, final Property[] properties) {

        PropertyMap newMap = this.getMap();

        for (final Property property : properties) {

            final String key = property.getKey();

            final Property oldProp = newMap.findProperty(key);

            if (oldProp == null) {

                if (property instanceof UserAccessorProperty) {

                    // Note: we copy accessor functions to this object which is semantically different from binding.

                    final UserAccessorProperty prop = this.newUserAccessors(key, property.getFlags(), property.getGetterFunction(source), property.getSetterFunction(source));

                    newMap = newMap.addPropertyNoHistory(prop);

                } else {

                    newMap = newMap.addPropertyBind((AccessorProperty)property, source);

                }

            } else {

                // See ECMA section 10.5 Declaration Binding Instantiation

                // step 5 processing each function declaration.

                if (property.isFunctionDeclaration() && !oldProp.isConfigurable()) {

                     if (oldProp instanceof UserAccessorProperty ||

                         !(oldProp.isWritable() && oldProp.isEnumerable())) {

                         throw typeError("cant.redefine.property", key, ScriptRuntime.safeToString(this));

                     }

                }

            }

        }

        this.setMap(newMap);

    }

    /**

     * Copy all properties from the array with their receiver bound to the source.

     *

     * @param source The source object to copy from.

     * @param properties The collection of accessor properties to copy.

     */

    public void addBoundProperties(final Object source, final AccessorProperty[] properties) {

        PropertyMap newMap = this.getMap();

        for (final AccessorProperty property : properties) {

            final String key = property.getKey();

            if (newMap.findProperty(key) == null) {

                newMap = newMap.addPropertyBind(property, source);

            }

        }

        this.setMap(newMap);

    }

    /**

     * Bind the method handle to the specified receiver, while preserving its original type (it will just ignore the

     * first argument in lieu of the bound argument).

     * @param methodHandle Method handle to bind to.

     * @param receiver     Object to bind.

     * @return Bound method handle.

     */

    static MethodHandle bindTo(final MethodHandle methodHandle, final Object receiver) {

        return MH.dropArguments(MH.bindTo(methodHandle, receiver), 0, methodHandle.type().parameterType(0));

    }

    /**

     * Return a property iterator.

     * @return Property iterator.

     */

    public Iterator<String> propertyIterator() {

        return new KeyIterator(this);

    }

    /**

     * Return a property value iterator.

     * @return Property value iterator.

     */

    public Iterator<Object> valueIterator() {

        return new ValueIterator(this);

    }

    /**

     * ECMA 8.10.1 IsAccessorDescriptor ( Desc )

     * @return true if this has a {@link AccessorPropertyDescriptor} with a getter or a setter

     */

    public final boolean isAccessorDescriptor() {

        return has(GET) || has(SET);

    }

    /**

     * ECMA 8.10.2 IsDataDescriptor ( Desc )

     * @return true if this has a {@link DataPropertyDescriptor}, i.e. the object has a property value and is writable

     */

    public final boolean isDataDescriptor() {

        return has(VALUE) || has(WRITABLE);

    }

    /**

     * ECMA 8.10.3 IsGenericDescriptor ( Desc )

     * @return true if this has a descriptor describing an {@link AccessorPropertyDescriptor} or {@link DataPropertyDescriptor}

     */

    public final boolean isGenericDescriptor() {

        return isAccessorDescriptor() || isDataDescriptor();

    }

    /**

      * ECMA 8.10.5 ToPropertyDescriptor ( Obj )

      *

      * @return property descriptor

      */

    public final PropertyDescriptor toPropertyDescriptor() {

        final Global global = Context.getGlobal();

        final PropertyDescriptor desc;

        if (isDataDescriptor()) {

            if (has(SET) || has(GET)) {

                throw typeError(global, "inconsistent.property.descriptor");

            }

            desc = global.newDataDescriptor(UNDEFINED, false, false, false);

        } else if (isAccessorDescriptor()) {

            if (has(VALUE) || has(WRITABLE)) {

                throw typeError(global, "inconsistent.property.descriptor");

            }

            desc = global.newAccessorDescriptor(UNDEFINED, UNDEFINED, false, false);

        } else {

            desc = global.newGenericDescriptor(false, false);

        }

        return desc.fillFrom(this);

    }

    /**

     * ECMA 8.10.5 ToPropertyDescriptor ( Obj )

     *

     * @param global  global scope object

     * @param obj object to create property descriptor from

     *

     * @return property descriptor

     */

    public static PropertyDescriptor toPropertyDescriptor(final Global global, final Object obj) {

        if (obj instanceof ScriptObject) {

            return ((ScriptObject)obj).toPropertyDescriptor();

        }

        throw typeError(global, "not.an.object", ScriptRuntime.safeToString(obj));

    }

    /**

     * ECMA 8.12.1 [[GetOwnProperty]] (P)

     *

     * @param key property key

     *

     * @return Returns the Property Descriptor of the named own property of this

     * object, or undefined if absent.

     */

    public Object getOwnPropertyDescriptor(final String key) {

        final Property property = getMap().findProperty(key);

        final Global global = Context.getGlobal();

        if (property != null) {

            final ScriptFunction get   = property.getGetterFunction(this);

            final ScriptFunction set   = property.getSetterFunction(this);

            final boolean configurable = property.isConfigurable();

            final boolean enumerable   = property.isEnumerable();

            final boolean writable     = property.isWritable();

            if (property instanceof UserAccessorProperty) {

                return global.newAccessorDescriptor(

                    get != null ?

                        get :

                        UNDEFINED,

                    set != null ?

                        set :

                        UNDEFINED,

                    configurable,

                    enumerable);

            }

            return global.newDataDescriptor(getWithProperty(property), configurable, enumerable, writable);

        }

        final int index = getArrayIndex(key);

        final ArrayData array = getArray();

        if (array.has(index)) {

            return array.getDescriptor(global, index);

        }

        return UNDEFINED;

    }

    /**

     * ECMA 8.12.2 [[GetProperty]] (P)

     *

     * @param key property key

     *

     * @return Returns the fully populated Property Descriptor of the named property

     * of this object, or undefined if absent.

     */

    public Object getPropertyDescriptor(final String key) {

        final Object res = getOwnPropertyDescriptor(key);

        if (res != UNDEFINED) {

            return res;

        } else if (getProto() != null) {