1 /*
   2  * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package jdk.nashorn.internal.runtime;
  27 
  28 import static jdk.nashorn.internal.codegen.CompilerConstants.staticCallNoLookup;
  29 import static jdk.nashorn.internal.codegen.CompilerConstants.virtualCall;
  30 import static jdk.nashorn.internal.codegen.CompilerConstants.virtualCallNoLookup;
  31 import static jdk.nashorn.internal.lookup.Lookup.MH;
  32 import static jdk.nashorn.internal.runtime.ECMAErrors.referenceError;
  33 import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;
  34 import static jdk.nashorn.internal.runtime.JSType.UNDEFINED_DOUBLE;
  35 import static jdk.nashorn.internal.runtime.JSType.UNDEFINED_INT;
  36 import static jdk.nashorn.internal.runtime.JSType.UNDEFINED_LONG;
  37 import static jdk.nashorn.internal.runtime.PropertyDescriptor.CONFIGURABLE;
  38 import static jdk.nashorn.internal.runtime.PropertyDescriptor.ENUMERABLE;
  39 import static jdk.nashorn.internal.runtime.PropertyDescriptor.GET;
  40 import static jdk.nashorn.internal.runtime.PropertyDescriptor.SET;
  41 import static jdk.nashorn.internal.runtime.PropertyDescriptor.VALUE;
  42 import static jdk.nashorn.internal.runtime.PropertyDescriptor.WRITABLE;
  43 import static jdk.nashorn.internal.runtime.ScriptRuntime.UNDEFINED;
  44 import static jdk.nashorn.internal.runtime.UnwarrantedOptimismException.INVALID_PROGRAM_POINT;
  45 import static jdk.nashorn.internal.runtime.UnwarrantedOptimismException.isValid;
  46 import static jdk.nashorn.internal.runtime.arrays.ArrayIndex.getArrayIndex;
  47 import static jdk.nashorn.internal.runtime.arrays.ArrayIndex.isValidArrayIndex;
  48 import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.isScopeFlag;
  49 import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.isStrictFlag;
  50 import static jdk.nashorn.internal.runtime.linker.NashornGuards.explicitInstanceOfCheck;
  51 
  52 import java.lang.invoke.MethodHandle;
  53 import java.lang.invoke.MethodHandles;
  54 import java.lang.invoke.MethodType;
  55 import java.lang.invoke.SwitchPoint;
  56 import java.util.AbstractMap;
  57 import java.util.ArrayList;
  58 import java.util.Arrays;
  59 import java.util.Collection;
  60 import java.util.Collections;
  61 import java.util.HashSet;
  62 import java.util.Iterator;
  63 import java.util.LinkedHashSet;
  64 import java.util.List;
  65 import java.util.Map;
  66 import java.util.Set;
  67 import jdk.internal.dynalink.CallSiteDescriptor;
  68 import jdk.internal.dynalink.linker.GuardedInvocation;
  69 import jdk.internal.dynalink.linker.LinkRequest;
  70 import jdk.internal.dynalink.support.CallSiteDescriptorFactory;
  71 import jdk.nashorn.internal.codegen.CompilerConstants.Call;
  72 import jdk.nashorn.internal.codegen.ObjectClassGenerator;
  73 import jdk.nashorn.internal.codegen.types.Type;
  74 import jdk.nashorn.internal.lookup.Lookup;
  75 import jdk.nashorn.internal.objects.AccessorPropertyDescriptor;
  76 import jdk.nashorn.internal.objects.DataPropertyDescriptor;
  77 import jdk.nashorn.internal.objects.Global;
  78 import jdk.nashorn.internal.objects.NativeArray;
  79 import jdk.nashorn.internal.runtime.arrays.ArrayData;
  80 import jdk.nashorn.internal.runtime.arrays.ArrayIndex;
  81 import jdk.nashorn.internal.runtime.linker.Bootstrap;
  82 import jdk.nashorn.internal.runtime.linker.LinkerCallSite;
  83 import jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor;
  84 import jdk.nashorn.internal.runtime.linker.NashornGuards;
  85 
  86 /**
  87  * Base class for generic JavaScript objects.
  88  * <p>
  89  * Notes:
  90  * <ul>
  91  * <li>The map is used to identify properties in the object.</li>
  92  * <li>If the map is modified then it must be cloned and replaced.  This notifies
  93  *     any code that made assumptions about the object that things have changed.
  94  *     Ex. CallSites that have been validated must check to see if the map has
  95  *     changed (or a map from a different object type) and hence relink the method
  96  *     to call.</li>
  97  * <li>Modifications of the map include adding/deleting attributes or changing a
  98  *     function field value.</li>
  99  * </ul>
 100  */
 101 
 102 public abstract class ScriptObject implements PropertyAccess, Cloneable {
 103     /** __proto__ special property name inside object literals. ES6 draft. */
 104     public static final String PROTO_PROPERTY_NAME   = "__proto__";
 105 
 106     /** Search fall back routine name for "no such method" */
 107     public static final String NO_SUCH_METHOD_NAME   = "__noSuchMethod__";
 108 
 109     /** Search fall back routine name for "no such property" */
 110     public static final String NO_SUCH_PROPERTY_NAME = "__noSuchProperty__";
 111 
 112     /** Per ScriptObject flag - is this a scope object? */
 113     public static final int IS_SCOPE       = 1 << 0;
 114 
 115     /** Per ScriptObject flag - is this an array object? */
 116     public static final int IS_ARRAY       = 1 << 1;
 117 
 118     /** Per ScriptObject flag - is this an arguments object? */
 119     public static final int IS_ARGUMENTS   = 1 << 2;
 120 
 121     /** Is length property not-writable? */
 122     public static final int IS_LENGTH_NOT_WRITABLE = 1 << 3;
 123 
 124     /** Is this a builtin object? */
 125     public static final int IS_BUILTIN = 1 << 4;
 126 
 127     /**
 128      * Spill growth rate - by how many elements does {@link ScriptObject#primitiveSpill} and
 129      * {@link ScriptObject#objectSpill} when full
 130      */
 131     public static final int SPILL_RATE = 8;
 132 
 133     /** Map to property information and accessor functions. Ordered by insertion. */
 134     private PropertyMap map;
 135 
 136     /** objects proto. */
 137     private ScriptObject proto;
 138 
 139     /** Object flags. */
 140     private int flags;
 141 
 142     /** Area for primitive properties added to object after instantiation, see {@link AccessorProperty} */
 143     protected long[]   primitiveSpill;
 144 
 145     /** Area for reference properties added to object after instantiation, see {@link AccessorProperty} */
 146     protected Object[] objectSpill;
 147 
 148     /** Indexed array data. */
 149     private ArrayData arrayData;
 150 
 151     /** Method handle to retrieve prototype of this object */
 152     public static final MethodHandle GETPROTO      = findOwnMH_V("getProto", ScriptObject.class);
 153 
 154     static final MethodHandle MEGAMORPHIC_GET    = findOwnMH_V("megamorphicGet", Object.class, String.class, boolean.class);
 155     static final MethodHandle GLOBALFILTER       = findOwnMH_S("globalFilter", Object.class, Object.class);
 156     static final MethodHandle DECLARE_AND_SET    = findOwnMH_V("declareAndSet", void.class, String.class, Object.class);
 157 
 158     private static final MethodHandle TRUNCATINGFILTER   = findOwnMH_S("truncatingFilter", Object[].class, int.class, Object[].class);
 159     private static final MethodHandle KNOWNFUNCPROPGUARDSELF = findOwnMH_S("knownFunctionPropertyGuardSelf", boolean.class, Object.class, PropertyMap.class, MethodHandle.class, ScriptFunction.class);
 160     private static final MethodHandle KNOWNFUNCPROPGUARDPROTO = findOwnMH_S("knownFunctionPropertyGuardProto", boolean.class, Object.class, PropertyMap.class, MethodHandle.class, int.class, ScriptFunction.class);
 161 
 162     private static final ArrayList<MethodHandle> PROTO_FILTERS = new ArrayList<>();
 163 
 164     /** Method handle for getting the array data */
 165     public static final Call GET_ARRAY          = virtualCall(MethodHandles.lookup(), ScriptObject.class, "getArray", ArrayData.class);
 166 
 167     /** Method handle for getting a function argument at a given index. Used from MapCreator */
 168     public static final Call GET_ARGUMENT       = virtualCall(MethodHandles.lookup(), ScriptObject.class, "getArgument", Object.class, int.class);
 169 
 170     /** Method handle for setting a function argument at a given index. Used from MapCreator */
 171     public static final Call SET_ARGUMENT       = virtualCall(MethodHandles.lookup(), ScriptObject.class, "setArgument", void.class, int.class, Object.class);
 172 
 173     /** Method handle for getting the proto of a ScriptObject */
 174     public static final Call GET_PROTO          = virtualCallNoLookup(ScriptObject.class, "getProto", ScriptObject.class);
 175 
 176     /** Method handle for getting the proto of a ScriptObject */
 177     public static final Call GET_PROTO_DEPTH    = virtualCallNoLookup(ScriptObject.class, "getProto", ScriptObject.class, int.class);
 178 
 179     /** Method handle for setting the proto of a ScriptObject */
 180     public static final Call SET_GLOBAL_OBJECT_PROTO = staticCallNoLookup(ScriptObject.class, "setGlobalObjectProto", void.class, ScriptObject.class);
 181 
 182     /** Method handle for setting the proto of a ScriptObject after checking argument */
 183     public static final Call SET_PROTO_FROM_LITERAL    = virtualCallNoLookup(ScriptObject.class, "setProtoFromLiteral", void.class, Object.class);
 184 
 185     /** Method handle for setting the user accessors of a ScriptObject */
 186     //TODO fastpath this
 187     public static final Call SET_USER_ACCESSORS = virtualCall(MethodHandles.lookup(), ScriptObject.class, "setUserAccessors", void.class, String.class, ScriptFunction.class, ScriptFunction.class);
 188 
 189     static final MethodHandle[] SET_SLOW = new MethodHandle[] {
 190         findOwnMH_V("set", void.class, Object.class, int.class, int.class),
 191         findOwnMH_V("set", void.class, Object.class, long.class, int.class),
 192         findOwnMH_V("set", void.class, Object.class, double.class, int.class),
 193         findOwnMH_V("set", void.class, Object.class, Object.class, int.class)
 194     };
 195 
 196     /** Method handle to reset the map of this ScriptObject */
 197     public static final Call SET_MAP = virtualCallNoLookup(ScriptObject.class, "setMap", void.class, PropertyMap.class);
 198 
 199     static final MethodHandle CAS_MAP           = findOwnMH_V("compareAndSetMap", boolean.class, PropertyMap.class, PropertyMap.class);
 200     static final MethodHandle EXTENSION_CHECK   = findOwnMH_V("extensionCheck", boolean.class, boolean.class, String.class);
 201     static final MethodHandle ENSURE_SPILL_SIZE = findOwnMH_V("ensureSpillSize", Object.class, int.class);
 202 
 203     /**
 204      * Constructor
 205      */
 206     public ScriptObject() {
 207         this(null);
 208     }
 209 
 210     /**
 211     * Constructor
 212     *
 213     * @param map {@link PropertyMap} used to create the initial object
 214     */
 215     public ScriptObject(final PropertyMap map) {
 216         if (Context.DEBUG) {
 217             ScriptObject.count++;
 218         }
 219         this.arrayData = ArrayData.EMPTY_ARRAY;
 220         this.setMap(map == null ? PropertyMap.newMap() : map);
 221     }
 222 
 223     /**
 224      * Constructor that directly sets the prototype to {@code proto} and property map to
 225      * {@code map} without invalidating the map as calling {@link #setProto(ScriptObject)}
 226      * would do. This should only be used for objects that are always constructed with the
 227      * same combination of prototype and property map.
 228      *
 229      * @param proto the prototype object
 230      * @param map intial {@link PropertyMap}
 231      */
 232     protected ScriptObject(final ScriptObject proto, final PropertyMap map) {
 233         this(map);
 234         this.proto = proto;
 235     }
 236 
 237     /**
 238      * Constructor used to instantiate spill properties directly. Used from
 239      * SpillObjectCreator.
 240      *
 241      * @param map            property maps
 242      * @param primitiveSpill primitive spills
 243      * @param objectSpill    reference spills
 244      */
 245     public ScriptObject(final PropertyMap map, final long[] primitiveSpill, final Object[] objectSpill) {
 246         this(map);
 247         this.primitiveSpill = primitiveSpill;
 248         this.objectSpill    = objectSpill;
 249         assert primitiveSpill == null || primitiveSpill.length == objectSpill.length : " primitive spill pool size is not the same length as object spill pool size";
 250     }
 251 
 252     /**
 253      * Check whether this is a global object
 254      * @return true if global
 255      */
 256     protected boolean isGlobal() {
 257         return false;
 258     }
 259 
 260     private static int alignUp(final int size, final int alignment) {
 261         return size + alignment - 1 & ~(alignment - 1);
 262     }
 263 
 264     /**
 265      * Given a number of properties, return the aligned to SPILL_RATE
 266      * buffer size required for the smallest spill pool needed to
 267      * house them
 268      * @param nProperties number of properties
 269      * @return property buffer length, a multiple of SPILL_RATE
 270      */
 271     public static int spillAllocationLength(final int nProperties) {
 272         return alignUp(nProperties, SPILL_RATE);
 273     }
 274 
 275     /**
 276      * Copy all properties from the source object with their receiver bound to the source.
 277      * This function was known as mergeMap
 278      *
 279      * @param source The source object to copy from.
 280      */
 281     public void addBoundProperties(final ScriptObject source) {
 282         addBoundProperties(source, source.getMap().getProperties());
 283     }
 284 
 285     /**
 286      * Copy all properties from the array with their receiver bound to the source.
 287      *
 288      * @param source The source object to copy from.
 289      * @param properties The array of properties to copy.
 290      */
 291     public void addBoundProperties(final ScriptObject source, final Property[] properties) {
 292         PropertyMap newMap = this.getMap();
 293 
 294         for (final Property property : properties) {
 295             newMap = addBoundProperty(newMap, source, property);
 296         }
 297 
 298         this.setMap(newMap);
 299     }
 300 
 301     /**
 302      * Add a bound property from {@code source}, using the interim property map {@code propMap}, and return the
 303      * new interim property map.
 304      *
 305      * @param propMap the property map
 306      * @param source the source object
 307      * @param property the property to be added
 308      * @return the new property map
 309      */
 310     protected PropertyMap addBoundProperty(final PropertyMap propMap, final ScriptObject source, final Property property) {
 311         PropertyMap newMap = propMap;
 312         final String key = property.getKey();
 313         final Property oldProp = newMap.findProperty(key);
 314         if (oldProp == null) {
 315             if (property instanceof UserAccessorProperty) {
 316                 // Note: we copy accessor functions to this object which is semantically different from binding.
 317                 final UserAccessorProperty prop = this.newUserAccessors(key, property.getFlags(), property.getGetterFunction(source), property.getSetterFunction(source));
 318                 newMap = newMap.addPropertyNoHistory(prop);
 319             } else {
 320                 newMap = newMap.addPropertyBind((AccessorProperty)property, source);
 321             }
 322         } else {
 323             // See ECMA section 10.5 Declaration Binding Instantiation
 324             // step 5 processing each function declaration.
 325             if (property.isFunctionDeclaration() && !oldProp.isConfigurable()) {
 326                 if (oldProp instanceof UserAccessorProperty ||
 327                         !(oldProp.isWritable() && oldProp.isEnumerable())) {
 328                     throw typeError("cant.redefine.property", key, ScriptRuntime.safeToString(this));
 329                 }
 330             }
 331         }
 332         return newMap;
 333     }
 334 
 335     /**
 336      * Copy all properties from the array with their receiver bound to the source.
 337      *
 338      * @param source The source object to copy from.
 339      * @param properties The collection of accessor properties to copy.
 340      */
 341     public void addBoundProperties(final Object source, final AccessorProperty[] properties) {
 342         PropertyMap newMap = this.getMap();
 343 
 344         for (final AccessorProperty property : properties) {
 345             final String key = property.getKey();
 346 
 347             if (newMap.findProperty(key) == null) {
 348                 newMap = newMap.addPropertyBind(property, source);
 349             }
 350         }
 351 
 352         this.setMap(newMap);
 353     }
 354 
 355     /**
 356      * Bind the method handle to the specified receiver, while preserving its original type (it will just ignore the
 357      * first argument in lieu of the bound argument).
 358      * @param methodHandle Method handle to bind to.
 359      * @param receiver     Object to bind.
 360      * @return Bound method handle.
 361      */
 362     static MethodHandle bindTo(final MethodHandle methodHandle, final Object receiver) {
 363         return MH.dropArguments(MH.bindTo(methodHandle, receiver), 0, methodHandle.type().parameterType(0));
 364     }
 365 
 366     /**
 367      * Return a property iterator.
 368      * @return Property iterator.
 369      */
 370     public Iterator<String> propertyIterator() {
 371         return new KeyIterator(this);
 372     }
 373 
 374     /**
 375      * Return a property value iterator.
 376      * @return Property value iterator.
 377      */
 378     public Iterator<Object> valueIterator() {
 379         return new ValueIterator(this);
 380     }
 381 
 382     /**
 383      * ECMA 8.10.1 IsAccessorDescriptor ( Desc )
 384      * @return true if this has a {@link AccessorPropertyDescriptor} with a getter or a setter
 385      */
 386     public final boolean isAccessorDescriptor() {
 387         return has(GET) || has(SET);
 388     }
 389 
 390     /**
 391      * ECMA 8.10.2 IsDataDescriptor ( Desc )
 392      * @return true if this has a {@link DataPropertyDescriptor}, i.e. the object has a property value and is writable
 393      */
 394     public final boolean isDataDescriptor() {
 395         return has(VALUE) || has(WRITABLE);
 396     }
 397 
 398     /**








 399       * ECMA 8.10.5 ToPropertyDescriptor ( Obj )
 400       *
 401       * @return property descriptor
 402       */
 403     public final PropertyDescriptor toPropertyDescriptor() {
 404         final Global global = Context.getGlobal();
 405 
 406         final PropertyDescriptor desc;
 407         if (isDataDescriptor()) {
 408             if (has(SET) || has(GET)) {
 409                 throw typeError(global, "inconsistent.property.descriptor");
 410             }
 411 
 412             desc = global.newDataDescriptor(UNDEFINED, false, false, false);
 413         } else if (isAccessorDescriptor()) {
 414             if (has(VALUE) || has(WRITABLE)) {
 415                 throw typeError(global, "inconsistent.property.descriptor");
 416             }
 417 
 418             desc = global.newAccessorDescriptor(UNDEFINED, UNDEFINED, false, false);
 419         } else {
 420             desc = global.newGenericDescriptor(false, false);
 421         }
 422 
 423         return desc.fillFrom(this);
 424     }
 425 
 426     /**
 427      * ECMA 8.10.5 ToPropertyDescriptor ( Obj )
 428      *
 429      * @param global  global scope object
 430      * @param obj object to create property descriptor from
 431      *
 432      * @return property descriptor
 433      */
 434     public static PropertyDescriptor toPropertyDescriptor(final Global global, final Object obj) {
 435         if (obj instanceof ScriptObject) {
 436             return ((ScriptObject)obj).toPropertyDescriptor();
 437         }
 438 
 439         throw typeError(global, "not.an.object", ScriptRuntime.safeToString(obj));
 440     }
 441 
 442     /**
 443      * ECMA 8.12.1 [[GetOwnProperty]] (P)
 444      *
 445      * @param key property key
 446      *
 447      * @return Returns the Property Descriptor of the named own property of this
 448      * object, or undefined if absent.
 449      */
 450     public Object getOwnPropertyDescriptor(final String key) {
 451         final Property property = getMap().findProperty(key);
 452 
 453         final Global global = Context.getGlobal();
 454 
 455         if (property != null) {
 456             final ScriptFunction get   = property.getGetterFunction(this);
 457             final ScriptFunction set   = property.getSetterFunction(this);
 458 
 459             final boolean configurable = property.isConfigurable();
 460             final boolean enumerable   = property.isEnumerable();
 461             final boolean writable     = property.isWritable();
 462 
 463             if (property instanceof UserAccessorProperty) {
 464                 return global.newAccessorDescriptor(
 465                     get != null ?
 466                         get :
 467                         UNDEFINED,
 468                     set != null ?
 469                         set :
 470                         UNDEFINED,
 471                     configurable,
 472                     enumerable);
 473             }
 474 
 475             return global.newDataDescriptor(getWithProperty(property), configurable, enumerable, writable);
 476         }
 477 
 478         final int index = getArrayIndex(key);
 479         final ArrayData array = getArray();
 480 
 481         if (array.has(index)) {
 482             return array.getDescriptor(global, index);
 483         }
 484 
 485         return UNDEFINED;
 486     }
 487 
 488     /**
 489      * ECMA 8.12.2 [[GetProperty]] (P)
 490      *
 491      * @param key property key
 492      *
 493      * @return Returns the fully populated Property Descriptor of the named property
 494      * of this object, or undefined if absent.
 495      */
 496     public Object getPropertyDescriptor(final String key) {
 497         final Object res = getOwnPropertyDescriptor(key);
 498 
 499         if (res != UNDEFINED) {
 500             return res;
 501         } else if (getProto() != null) {
 502             return getProto().getOwnPropertyDescriptor(key);
 503         } else {
 504             return UNDEFINED;
 505         }
 506     }
 507 
 508     /**
 509      * Invalidate any existing global constant method handles that may exist for {@code key}.
 510      * @param key the property name
 511      */
 512     protected void invalidateGlobalConstant(final String key) {
 513         final GlobalConstants globalConstants = getGlobalConstants();
 514         if (globalConstants != null) {
 515             globalConstants.delete(key);
 516         }
 517     }
 518 
 519     /**
 520      * ECMA 8.12.9 [[DefineOwnProperty]] (P, Desc, Throw)
 521      *
 522      * @param key the property key
 523      * @param propertyDesc the property descriptor
 524      * @param reject is the property extensible - true means new definitions are rejected
 525      *
 526      * @return true if property was successfully defined
 527      */
 528     public boolean defineOwnProperty(final String key, final Object propertyDesc, final boolean reject) {
 529         final Global             global  = Context.getGlobal();
 530         final PropertyDescriptor desc    = toPropertyDescriptor(global, propertyDesc);
 531         final Object             current = getOwnPropertyDescriptor(key);
 532         final String             name    = JSType.toString(key);
 533 
 534         invalidateGlobalConstant(key);
 535 
 536         if (current == UNDEFINED) {
 537             if (isExtensible()) {
 538                 // add a new own property
 539                 addOwnProperty(key, desc);
 540                 return true;
 541             }
 542             // new property added to non-extensible object
 543             if (reject) {
 544                 throw typeError(global, "object.non.extensible", name, ScriptRuntime.safeToString(this));
 545             }
 546             return false;
 547         }
 548 
 549         // modifying an existing property
 550         final PropertyDescriptor currentDesc = (PropertyDescriptor)current;
 551         final PropertyDescriptor newDesc     = desc;
 552 
 553         if (newDesc.type() == PropertyDescriptor.GENERIC && !newDesc.has(CONFIGURABLE) && !newDesc.has(ENUMERABLE)) {
 554             // every descriptor field is absent
 555             return true;
 556         }
 557 
 558         if (newDesc.hasAndEquals(currentDesc)) {
 559             // every descriptor field of the new is same as the current
 560             return true;
 561         }
 562 
 563         if (!currentDesc.isConfigurable()) {
 564             if (newDesc.has(CONFIGURABLE) && newDesc.isConfigurable()) {
 565                 // not configurable can not be made configurable
 566                 if (reject) {
 567                     throw typeError(global, "cant.redefine.property", name, ScriptRuntime.safeToString(this));
 568                 }
 569                 return false;
 570             }
 571 
 572             if (newDesc.has(ENUMERABLE) &&
 573                 currentDesc.isEnumerable() != newDesc.isEnumerable()) {
 574                 // cannot make non-enumerable as enumerable or vice-versa
 575                 if (reject) {
 576                     throw typeError(global, "cant.redefine.property", name, ScriptRuntime.safeToString(this));
 577                 }
 578                 return false;
 579             }
 580         }
 581 
 582         int propFlags = Property.mergeFlags(currentDesc, newDesc);
 583         Property property = getMap().findProperty(key);
 584 
 585         if (currentDesc.type() == PropertyDescriptor.DATA &&
 586                 (newDesc.type() == PropertyDescriptor.DATA ||
 587                  newDesc.type() == PropertyDescriptor.GENERIC)) {
 588             if (!currentDesc.isConfigurable() && !currentDesc.isWritable()) {
 589                 if (newDesc.has(WRITABLE) && newDesc.isWritable() ||
 590                     newDesc.has(VALUE) && !ScriptRuntime.sameValue(currentDesc.getValue(), newDesc.getValue())) {
 591                     if (reject) {
 592                         throw typeError(global, "cant.redefine.property", name, ScriptRuntime.safeToString(this));
 593                     }
 594                     return false;
 595                 }
 596             }
 597 
 598             final boolean newValue = newDesc.has(VALUE);
 599             final Object value     = newValue ? newDesc.getValue() : currentDesc.getValue();
 600 
 601             if (newValue && property != null) {
 602                 // Temporarily clear flags.
 603                 property = modifyOwnProperty(property, 0);
 604                 set(key, value, 0);
 605                 //this might change the map if we change types of the property
 606                 //hence we need to read it again. note that we should probably
 607                 //have the setter return the new property throughout and in
 608                 //general respect Property return values from modify and add
 609                 //functions - which we don't seem to do at all here :-(
 610                 //There is already a bug filed to generify PropertyAccess so we
 611                 //can have the setter return e.g. a Property
 612                 property = getMap().findProperty(key);
 613             }
 614 
 615             if (property == null) {
 616                 // promoting an arrayData value to actual property
 617                 addOwnProperty(key, propFlags, value);
 618                 checkIntegerKey(key);
 619             } else {
 620                 // Now set the new flags
 621                 modifyOwnProperty(property, propFlags);
 622             }
 623         } else if (currentDesc.type() == PropertyDescriptor.ACCESSOR &&
 624                    (newDesc.type() == PropertyDescriptor.ACCESSOR ||
 625                     newDesc.type() == PropertyDescriptor.GENERIC)) {
 626             if (!currentDesc.isConfigurable()) {
 627                 if (newDesc.has(PropertyDescriptor.GET) && !ScriptRuntime.sameValue(currentDesc.getGetter(), newDesc.getGetter()) ||
 628                     newDesc.has(PropertyDescriptor.SET) && !ScriptRuntime.sameValue(currentDesc.getSetter(), newDesc.getSetter())) {
 629                     if (reject) {
 630                         throw typeError(global, "cant.redefine.property", name, ScriptRuntime.safeToString(this));
 631                     }
 632                     return false;
 633                 }
 634             }
 635             // New set the new features.
 636             modifyOwnProperty(property, propFlags,
 637                                       newDesc.has(GET) ? newDesc.getGetter() : currentDesc.getGetter(),
 638                                       newDesc.has(SET) ? newDesc.getSetter() : currentDesc.getSetter());
 639         } else {
 640             // changing descriptor type
 641             if (!currentDesc.isConfigurable()) {
 642                 // not configurable can not be made configurable
 643                 if (reject) {
 644                     throw typeError(global, "cant.redefine.property", name, ScriptRuntime.safeToString(this));
 645                 }
 646                 return false;
 647             }
 648 
 649             propFlags = 0;
 650 
 651             // Preserve only configurable and enumerable from current desc
 652             // if those are not overridden in the new property descriptor.
 653             boolean value = newDesc.has(CONFIGURABLE) ? newDesc.isConfigurable() : currentDesc.isConfigurable();
 654             if (!value) {
 655                 propFlags |= Property.NOT_CONFIGURABLE;
 656             }
 657             value = newDesc.has(ENUMERABLE)? newDesc.isEnumerable() : currentDesc.isEnumerable();
 658             if (!value) {
 659                 propFlags |= Property.NOT_ENUMERABLE;
 660             }
 661 
 662             final int type = newDesc.type();
 663             if (type == PropertyDescriptor.DATA) {
 664                 // get writable from the new descriptor
 665                 value = newDesc.has(WRITABLE) && newDesc.isWritable();
 666                 if (!value) {
 667                     propFlags |= Property.NOT_WRITABLE;
 668                 }
 669 
 670                 // delete the old property
 671                 deleteOwnProperty(property);
 672                 // add new data property
 673                 addOwnProperty(key, propFlags, newDesc.getValue());
 674             } else if (type == PropertyDescriptor.ACCESSOR) {
 675                 if (property == null) {
 676                     addOwnProperty(key, propFlags,
 677                                      newDesc.has(GET) ? newDesc.getGetter() : null,
 678                                      newDesc.has(SET) ? newDesc.getSetter() : null);
 679                 } else {
 680                     // Modify old property with the new features.
 681                     modifyOwnProperty(property, propFlags,
 682                                         newDesc.has(GET) ? newDesc.getGetter() : null,
 683                                         newDesc.has(SET) ? newDesc.getSetter() : null);
 684                 }
 685             }
 686         }
 687 
 688         checkIntegerKey(key);
 689 
 690         return true;
 691     }
 692 
 693     /**
 694      * Almost like defineOwnProperty(int,Object) for arrays this one does
 695      * not add 'gap' elements (like the array one does).
 696      *
 697      * @param index key for property
 698      * @param value value to define
 699      */
 700     public void defineOwnProperty(final int index, final Object value) {
 701         assert isValidArrayIndex(index) : "invalid array index";
 702         final long longIndex = ArrayIndex.toLongIndex(index);
 703         final long oldLength = getArray().length();
 704         if (longIndex >= oldLength) {
 705             setArray(getArray().ensure(longIndex));
 706             doesNotHaveEnsureDelete(longIndex, oldLength, false);
 707         }
 708         setArray(getArray().set(index, value, false));
 709     }
 710 
 711     private void checkIntegerKey(final String key) {
 712         final int index = getArrayIndex(key);
 713 
 714         if (isValidArrayIndex(index)) {
 715             final ArrayData data = getArray();
 716 
 717             if (data.has(index)) {
 718                 setArray(data.delete(index));
 719             }
 720         }
 721     }
 722 
 723     /**
 724       * Add a new property to the object.
 725       *
 726       * @param key          property key
 727       * @param propertyDesc property descriptor for property
 728       */
 729     public final void addOwnProperty(final String key, final PropertyDescriptor propertyDesc) {
 730         // Already checked that there is no own property with that key.
 731         PropertyDescriptor pdesc = propertyDesc;
 732 
 733         final int propFlags = Property.toFlags(pdesc);
 734 
 735         if (pdesc.type() == PropertyDescriptor.GENERIC) {
 736             final Global global = Context.getGlobal();
 737             final PropertyDescriptor dDesc = global.newDataDescriptor(UNDEFINED, false, false, false);
 738 
 739             dDesc.fillFrom((ScriptObject)pdesc);
 740             pdesc = dDesc;
 741         }
 742 
 743         final int type = pdesc.type();
 744         if (type == PropertyDescriptor.DATA) {
 745             addOwnProperty(key, propFlags, pdesc.getValue());
 746         } else if (type == PropertyDescriptor.ACCESSOR) {
 747             addOwnProperty(key, propFlags,
 748                     pdesc.has(GET) ? pdesc.getGetter() : null,
 749                     pdesc.has(SET) ? pdesc.getSetter() : null);
 750         }
 751 
 752         checkIntegerKey(key);
 753     }
 754 
 755     /**
 756      * Low level property API (not using property descriptors)
 757      * <p>
 758      * Find a property in the prototype hierarchy. Note: this is final and not
 759      * a good idea to override. If you have to, use
 760      * {jdk.nashorn.internal.objects.NativeArray{@link #getProperty(String)} or
 761      * {jdk.nashorn.internal.objects.NativeArray{@link #getPropertyDescriptor(String)} as the
 762      * overriding way to find array properties
 763      *
 764      * @see jdk.nashorn.internal.objects.NativeArray
 765      *
 766      * @param key  Property key.
 767      * @param deep Whether the search should look up proto chain.
 768      *
 769      * @return FindPropertyData or null if not found.
 770      */
 771     public final FindProperty findProperty(final String key, final boolean deep) {
 772         return findProperty(key, deep, this);
 773     }
 774 
 775     /**
 776      * Low level property API (not using property descriptors)
 777      * <p>
 778      * Find a property in the prototype hierarchy. Note: this is not a good idea
 779      * to override except as it was done in {@link WithObject}.
 780      * If you have to, use
 781      * {jdk.nashorn.internal.objects.NativeArray{@link #getProperty(String)} or
 782      * {jdk.nashorn.internal.objects.NativeArray{@link #getPropertyDescriptor(String)} as the
 783      * overriding way to find array properties
 784      *
 785      * @see jdk.nashorn.internal.objects.NativeArray
 786      *
 787      * @param key  Property key.
 788      * @param deep Whether the search should look up proto chain.
 789      * @param start the object on which the lookup was originally initiated
 790      *
 791      * @return FindPropertyData or null if not found.
 792      */
 793     protected FindProperty findProperty(final String key, final boolean deep, final ScriptObject start) {
 794 
 795         final PropertyMap selfMap  = getMap();
 796         final Property    property = selfMap.findProperty(key);
 797 
 798         if (property != null) {
 799             return new FindProperty(start, this, property);
 800         }
 801 
 802         if (deep) {
 803             final ScriptObject myProto = getProto();
 804             if (myProto != null) {
 805                 return myProto.findProperty(key, deep, start);
 806             }
 807         }
 808 
 809         return null;
 810     }
 811 
 812     /**
 813      * Low level property API. This is similar to {@link #findProperty(String, boolean)} but returns a
 814      * {@code boolean} value instead of a {@link FindProperty} object.
 815      * @param key  Property key.
 816      * @param deep Whether the search should look up proto chain.
 817      * @return true if the property was found.
 818      */
 819     boolean hasProperty(final String key, final boolean deep) {
 820         if (getMap().findProperty(key) != null) {
 821             return true;
 822         }
 823 
 824         if (deep) {
 825             final ScriptObject myProto = getProto();
 826             if (myProto != null) {
 827                 return myProto.hasProperty(key, deep);
 828             }
 829         }
 830 
 831         return false;
 832     }
 833 
 834     private SwitchPoint findBuiltinSwitchPoint(final String key) {
 835         for (ScriptObject myProto = getProto(); myProto != null; myProto = myProto.getProto()) {
 836             final Property prop = myProto.getMap().findProperty(key);
 837             if (prop != null) {
 838                 final SwitchPoint sp = prop.getBuiltinSwitchPoint();
 839                 if (sp != null && !sp.hasBeenInvalidated()) {
 840                     return sp;
 841                 }
 842             }
 843         }
 844         return null;
 845     }
 846 
 847     /**
 848      * Add a new property to the object.
 849      * <p>
 850      * This a more "low level" way that doesn't involve {@link PropertyDescriptor}s
 851      *
 852      * @param key             Property key.
 853      * @param propertyFlags   Property flags.
 854      * @param getter          Property getter, or null if not defined
 855      * @param setter          Property setter, or null if not defined
 856      *
 857      * @return New property.
 858      */
 859     public final Property addOwnProperty(final String key, final int propertyFlags, final ScriptFunction getter, final ScriptFunction setter) {
 860         return addOwnProperty(newUserAccessors(key, propertyFlags, getter, setter));
 861     }
 862 
 863     /**
 864      * Add a new property to the object.
 865      * <p>
 866      * This a more "low level" way that doesn't involve {@link PropertyDescriptor}s
 867      *
 868      * @param key             Property key.
 869      * @param propertyFlags   Property flags.
 870      * @param value           Value of property
 871      *
 872      * @return New property.
 873      */
 874     public final Property addOwnProperty(final String key, final int propertyFlags, final Object value) {
 875         return addSpillProperty(key, propertyFlags, value, true);
 876     }
 877 
 878     /**
 879      * Add a new property to the object.
 880      * <p>
 881      * This a more "low level" way that doesn't involve {@link PropertyDescriptor}s
 882      *
 883      * @param newProperty property to add
 884      *
 885      * @return New property.
 886      */
 887     public final Property addOwnProperty(final Property newProperty) {
 888         PropertyMap oldMap = getMap();
 889         while (true) {
 890             final PropertyMap newMap = oldMap.addProperty(newProperty);
 891             if (!compareAndSetMap(oldMap, newMap)) {
 892                 oldMap = getMap();
 893                 final Property oldProperty = oldMap.findProperty(newProperty.getKey());
 894 
 895                 if (oldProperty != null) {
 896                     return oldProperty;
 897                 }
 898             } else {
 899                 return newProperty;
 900             }
 901         }
 902     }
 903 
 904     private void erasePropertyValue(final Property property) {
 905         // Erase the property field value with undefined. If the property is defined
 906         // by user-defined accessors, we don't want to call the setter!!
 907         if (!(property instanceof UserAccessorProperty)) {
 908             assert property != null;
 909             property.setValue(this, this, UNDEFINED, false);
 910         }
 911     }
 912 
 913     /**
 914      * Delete a property from the object.
 915      *
 916      * @param property Property to delete.
 917      *
 918      * @return true if deleted.
 919      */
 920     public final boolean deleteOwnProperty(final Property property) {
 921         erasePropertyValue(property);
 922         PropertyMap oldMap = getMap();
 923 
 924         while (true) {
 925             final PropertyMap newMap = oldMap.deleteProperty(property);
 926 
 927             if (newMap == null) {
 928                 return false;
 929             }
 930 
 931             if (!compareAndSetMap(oldMap, newMap)) {
 932                 oldMap = getMap();
 933             } else {
 934                 // delete getter and setter function references so that we don't leak
 935                 if (property instanceof UserAccessorProperty) {
 936                     ((UserAccessorProperty)property).setAccessors(this, getMap(), null);
 937                 }
 938 
 939                 invalidateGlobalConstant(property.getKey());
 940                 return true;
 941             }
 942         }
 943 
 944     }
 945 
 946     /**
 947      * Fast initialization functions for ScriptFunctions that are strict, to avoid
 948      * creating setters that probably aren't used. Inject directly into the spill pool
 949      * the defaults for "arguments" and "caller"
 950      *
 951      * @param key           property key
 952      * @param propertyFlags flags
 953      * @param getter        getter for {@link UserAccessorProperty}, null if not present or N/A
 954      * @param setter        setter for {@link UserAccessorProperty}, null if not present or N/A
 955      */
 956     protected final void initUserAccessors(final String key, final int propertyFlags, final ScriptFunction getter, final ScriptFunction setter) {
 957         final PropertyMap oldMap = getMap();
 958         final int slot = oldMap.getFreeSpillSlot();
 959         ensureSpillSize(slot);
 960         objectSpill[slot] = new UserAccessorProperty.Accessors(getter, setter);
 961         Property    newProperty;
 962         PropertyMap newMap;
 963         do {
 964             newProperty = new UserAccessorProperty(key, propertyFlags, slot);
 965             newMap = oldMap.addProperty(newProperty);
 966         } while (!compareAndSetMap(oldMap, newMap));
 967     }
 968 
 969     /**
 970      * Modify a property in the object
 971      *
 972      * @param oldProperty    property to modify
 973      * @param propertyFlags  new property flags
 974      * @param getter         getter for {@link UserAccessorProperty}, null if not present or N/A
 975      * @param setter         setter for {@link UserAccessorProperty}, null if not present or N/A
 976      *
 977      * @return new property
 978      */
 979     public final Property modifyOwnProperty(final Property oldProperty, final int propertyFlags, final ScriptFunction getter, final ScriptFunction setter) {
 980         Property newProperty;
 981 
 982         if (oldProperty instanceof UserAccessorProperty) {
 983             final UserAccessorProperty uc = (UserAccessorProperty)oldProperty;
 984             final int slot = uc.getSlot();
 985 
 986             assert uc.getLocalType() == Object.class;
 987             final UserAccessorProperty.Accessors gs = uc.getAccessors(this); //this crashes
 988             assert gs != null;
 989             //reuse existing getter setter for speed
 990             gs.set(getter, setter);
 991             if (uc.getFlags() == propertyFlags) {
 992                 return oldProperty;
 993             }
 994             newProperty = new UserAccessorProperty(uc.getKey(), propertyFlags, slot);
 995         } else {
 996             // erase old property value and create new user accessor property
 997             erasePropertyValue(oldProperty);
 998             newProperty = newUserAccessors(oldProperty.getKey(), propertyFlags, getter, setter);
 999         }
1000 
1001         return modifyOwnProperty(oldProperty, newProperty);
1002     }
1003 
1004     /**
1005       * Modify a property in the object
1006       *
1007       * @param oldProperty    property to modify
1008       * @param propertyFlags  new property flags
1009       *
1010       * @return new property
1011       */
1012     public final Property modifyOwnProperty(final Property oldProperty, final int propertyFlags) {
1013         return modifyOwnProperty(oldProperty, oldProperty.setFlags(propertyFlags));
1014     }
1015 
1016     /**
1017      * Modify a property in the object, replacing a property with a new one
1018      *
1019      * @param oldProperty   property to replace
1020      * @param newProperty   property to replace it with
1021      *
1022      * @return new property
1023      */
1024     private Property modifyOwnProperty(final Property oldProperty, final Property newProperty) {
1025         if (oldProperty == newProperty) {
1026             return newProperty; //nop
1027         }
1028 
1029         assert newProperty.getKey().equals(oldProperty.getKey()) : "replacing property with different key";
1030 
1031         PropertyMap oldMap = getMap();
1032 
1033         while (true) {
1034             final PropertyMap newMap = oldMap.replaceProperty(oldProperty, newProperty);
1035 
1036             if (!compareAndSetMap(oldMap, newMap)) {
1037                 oldMap = getMap();
1038                 final Property oldPropertyLookup = oldMap.findProperty(oldProperty.getKey());
1039 
1040                 if (oldPropertyLookup != null && oldPropertyLookup.equals(newProperty)) {
1041                     return oldPropertyLookup;
1042                 }
1043             } else {
1044                 return newProperty;
1045             }
1046         }
1047     }
1048 
1049     /**
1050      * Update getter and setter in an object literal.
1051      *
1052      * @param key    Property key.
1053      * @param getter {@link UserAccessorProperty} defined getter, or null if none
1054      * @param setter {@link UserAccessorProperty} defined setter, or null if none
1055      */
1056     public final void setUserAccessors(final String key, final ScriptFunction getter, final ScriptFunction setter) {
1057         final Property oldProperty = getMap().findProperty(key);
1058         if (oldProperty instanceof UserAccessorProperty) {
1059             modifyOwnProperty(oldProperty, oldProperty.getFlags(), getter, setter);
1060         } else {
1061             addOwnProperty(newUserAccessors(key, oldProperty != null ? oldProperty.getFlags() : 0, getter, setter));
1062         }
1063     }
1064 
1065     private static int getIntValue(final FindProperty find, final int programPoint) {
1066         final MethodHandle getter = find.getGetter(int.class, programPoint, null);
1067         if (getter != null) {
1068             try {
1069                 return (int)getter.invokeExact((Object)find.getGetterReceiver());
1070             } catch (final Error|RuntimeException e) {
1071                 throw e;
1072             } catch (final Throwable e) {
1073                 throw new RuntimeException(e);
1074             }
1075         }
1076 
1077         return UNDEFINED_INT;
1078     }
1079 
1080     private static long getLongValue(final FindProperty find, final int programPoint) {
1081         final MethodHandle getter = find.getGetter(long.class, programPoint, null);
1082         if (getter != null) {
1083             try {
1084                 return (long)getter.invokeExact((Object)find.getGetterReceiver());
1085             } catch (final Error|RuntimeException e) {
1086                 throw e;
1087             } catch (final Throwable e) {
1088                 throw new RuntimeException(e);
1089             }
1090         }
1091 
1092         return UNDEFINED_LONG;
1093     }
1094 
1095     private static double getDoubleValue(final FindProperty find, final int programPoint) {
1096         final MethodHandle getter = find.getGetter(double.class, programPoint, null);
1097         if (getter != null) {
1098             try {
1099                 return (double)getter.invokeExact((Object)find.getGetterReceiver());
1100             } catch (final Error|RuntimeException e) {
1101                 throw e;
1102             } catch (final Throwable e) {
1103                 throw new RuntimeException(e);
1104             }
1105         }
1106 
1107         return UNDEFINED_DOUBLE;
1108     }
1109 
1110     /**
1111      * Return methodHandle of value function for call.
1112      *
1113      * @param find      data from find property.
1114      * @param type      method type of function.
1115      * @param bindName  null or name to bind to second argument (property not found method.)
1116      *
1117      * @return value of property as a MethodHandle or null.
1118      */
1119     protected MethodHandle getCallMethodHandle(final FindProperty find, final MethodType type, final String bindName) {
1120         return getCallMethodHandle(find.getObjectValue(), type, bindName);
1121     }
1122 
1123     /**
1124      * Return methodHandle of value function for call.
1125      *
1126      * @param value     value of receiver, it not a {@link ScriptFunction} this will return null.
1127      * @param type      method type of function.
1128      * @param bindName  null or name to bind to second argument (property not found method.)
1129      *
1130      * @return value of property as a MethodHandle or null.
1131      */
1132     protected static MethodHandle getCallMethodHandle(final Object value, final MethodType type, final String bindName) {
1133         return value instanceof ScriptFunction ? ((ScriptFunction)value).getCallMethodHandle(type, bindName) : null;
1134     }
1135 
1136     /**
1137      * Get value using found property.
1138      *
1139      * @param property Found property.
1140      *
1141      * @return Value of property.
1142      */
1143     public final Object getWithProperty(final Property property) {
1144         return new FindProperty(this, this, property).getObjectValue();
1145     }
1146 
1147     /**
1148      * Get a property given a key
1149      *
1150      * @param key property key
1151      *
1152      * @return property for key
1153      */
1154     public final Property getProperty(final String key) {
1155         return getMap().findProperty(key);
1156     }
1157 
1158     /**
1159      * Overridden by {@link jdk.nashorn.internal.objects.NativeArguments} class (internal use.)
1160      * Used for argument access in a vararg function using parameter name.
1161      * Returns the argument at a given key (index)
1162      *
1163      * @param key argument index
1164      *
1165      * @return the argument at the given position, or undefined if not present
1166      */
1167     public Object getArgument(final int key) {
1168         return get(key);
1169     }
1170 
1171     /**
1172      * Overridden by {@link jdk.nashorn.internal.objects.NativeArguments} class (internal use.)
1173      * Used for argument access in a vararg function using parameter name.
1174      * Returns the argument at a given key (index)
1175      *
1176      * @param key   argument index
1177      * @param value the value to write at the given index
1178      */
1179     public void setArgument(final int key, final Object value) {
1180         set(key, value, 0);
1181     }
1182 
1183     /**
1184      * Return the current context from the object's map.
1185      * @return Current context.
1186      */
1187     protected Context getContext() {
1188         return Context.fromClass(getClass());
1189     }
1190 
1191     /**
1192      * Return the map of an object.
1193      * @return PropertyMap object.
1194      */
1195     public final PropertyMap getMap() {
1196         return map;
1197     }
1198 
1199     /**
1200      * Set the initial map.
1201      * @param map Initial map.
1202      */
1203     public final void setMap(final PropertyMap map) {
1204         this.map = map;
1205     }
1206 
1207     /**
1208      * Conditionally set the new map if the old map is the same.
1209      * @param oldMap Map prior to manipulation.
1210      * @param newMap Replacement map.
1211      * @return true if the operation succeeded.
1212      */
1213     protected final boolean compareAndSetMap(final PropertyMap oldMap, final PropertyMap newMap) {
1214         if (oldMap == this.map) {
1215             this.map = newMap;
1216             return true;
1217         }
1218         return false;
1219      }
1220 
1221     /**
1222      * Return the __proto__ of an object.
1223      * @return __proto__ object.
1224      */
1225     public final ScriptObject getProto() {
1226         return proto;
1227     }
1228 
1229     /**
1230      * Get the proto of a specific depth
1231      * @param n depth
1232      * @return proto at given depth
1233      */
1234     public final ScriptObject getProto(final int n) {
1235         assert n > 0;
1236         ScriptObject p = getProto();
1237         for (int i = n; i-- > 0;) {
1238             p = p.getProto();
1239         }
1240         return p;
1241     }
1242 
1243     /**
1244      * Set the __proto__ of an object.
1245      * @param newProto new __proto__ to set.
1246      */
1247     public final void setProto(final ScriptObject newProto) {
1248         final ScriptObject oldProto = proto;
1249 
1250         if (oldProto != newProto) {
1251             proto = newProto;
1252 
1253             // Let current listeners know that the protototype has changed and set our map
1254             final PropertyListeners listeners = getMap().getListeners();
1255             if (listeners != null) {
1256                 listeners.protoChanged();
1257             }
1258             // Replace our current allocator map with one that is associated with the new prototype.
1259             setMap(getMap().changeProto(newProto));
1260         }
1261     }
1262 
1263     /**
1264      * Set the initial __proto__ of this object. This should be used instead of
1265      * {@link #setProto} if it is known that the current property map will not be
1266      * used on a new object with any other parent property map, so we can pass over
1267      * property map invalidation/evolution.
1268      *
1269      * @param initialProto the initial __proto__ to set.
1270      */
1271     public void setInitialProto(final ScriptObject initialProto) {
1272         this.proto = initialProto;
1273     }
1274 
1275     /**
1276      * Invoked from generated bytecode to initialize the prototype of object literals to the global Object prototype.
1277      * @param obj the object literal that needs to have its prototype initialized to the global Object prototype.
1278      */
1279     public static void setGlobalObjectProto(final ScriptObject obj) {
1280         obj.setInitialProto(Global.objectPrototype());
1281     }
1282 
1283     /**
1284      * Set the __proto__ of an object with checks.
1285      * This is the built-in operation [[SetPrototypeOf]]
1286      * See ES6 draft spec: 9.1.2 [[SetPrototypeOf]] (V)
1287      *
1288      * @param newProto Prototype to set.
1289      */
1290     public final void setPrototypeOf(final Object newProto) {
1291         if (newProto == null || newProto instanceof ScriptObject) {
1292             if (! isExtensible()) {
1293                 // okay to set same proto again - even if non-extensible
1294 
1295                 if (newProto == getProto()) {
1296                     return;
1297                 }
1298                 throw typeError("__proto__.set.non.extensible", ScriptRuntime.safeToString(this));
1299             }
1300 
1301             // check for circularity
1302             ScriptObject p = (ScriptObject)newProto;
1303             while (p != null) {
1304                 if (p == this) {
1305                     throw typeError("circular.__proto__.set", ScriptRuntime.safeToString(this));
1306                 }
1307                 p = p.getProto();
1308             }
1309             setProto((ScriptObject)newProto);
1310         } else {
1311             throw typeError("cant.set.proto.to.non.object", ScriptRuntime.safeToString(this), ScriptRuntime.safeToString(newProto));
1312         }
1313     }
1314 
1315     /**
1316      * Set the __proto__ of an object from an object literal.
1317      * See ES6 draft spec: B.3.1 __proto__ Property Names in
1318      * Object Initializers. Step 6 handling of "__proto__".
1319      *
1320      * @param newProto Prototype to set.
1321      */
1322     public final void setProtoFromLiteral(final Object newProto) {
1323         if (newProto == null || newProto instanceof ScriptObject) {
1324             setPrototypeOf(newProto);
1325         } else {
1326             // Some non-object, non-null. Then, we need to set
1327             // Object.prototype as the new __proto__
1328             //
1329             // var obj = { __proto__ : 34 };
1330             // print(obj.__proto__ === Object.prototype); // => true
1331             setPrototypeOf(Global.objectPrototype());
1332         }
1333     }
1334 
1335     /**
1336      * return an array of own property keys associated with the object.
1337      *
1338      * @param all True if to include non-enumerable keys.
1339      * @return Array of keys.
1340      */
1341     public final String[] getOwnKeys(final boolean all) {
1342         return getOwnKeys(all, null);
1343     }
1344 
1345     /**
1346      * return an array of own property keys associated with the object.
1347      *
1348      * @param all True if to include non-enumerable keys.
1349      * @param nonEnumerable set of non-enumerable properties seen already.Used
1350        to filter out shadowed, but enumerable properties from proto children.
1351      * @return Array of keys.
1352      */
1353     protected String[] getOwnKeys(final boolean all, final Set<String> nonEnumerable) {
1354         final List<Object> keys    = new ArrayList<>();
1355         final PropertyMap  selfMap = this.getMap();
1356 
1357         final ArrayData array  = getArray();
1358 
1359         for (final Iterator<Long> iter = array.indexIterator(); iter.hasNext(); ) {
1360             keys.add(JSType.toString(iter.next().longValue()));
1361         }
1362 
1363         for (final Property property : selfMap.getProperties()) {
1364             final boolean enumerable = property.isEnumerable();
1365             final String key = property.getKey();
1366             if (all) {
1367                 keys.add(key);
1368             } else if (enumerable) {
1369                 // either we don't have non-enumerable filter set or filter set
1370                 // does not contain the current property.
1371                 if (nonEnumerable == null || !nonEnumerable.contains(key)) {
1372                     keys.add(key);
1373                 }
1374             } else {
1375                 // store this non-enumerable property for later proto walk
1376                 if (nonEnumerable != null) {
1377                     nonEnumerable.add(key);
1378                 }
1379             }
1380         }
1381 
1382         return keys.toArray(new String[keys.size()]);
1383     }
1384 
1385     /**
1386      * Check if this ScriptObject has array entries. This means that someone has
1387      * set values with numeric keys in the object.
1388      *
1389      * @return true if array entries exists.
1390      */
1391     public boolean hasArrayEntries() {
1392         return getArray().length() > 0 || getMap().containsArrayKeys();
1393     }
1394 
1395     /**
1396      * Return the valid JavaScript type name descriptor
1397      *
1398      * @return "Object"
1399      */
1400     public String getClassName() {
1401         return "Object";
1402     }
1403 
1404     /**
1405      * {@code length} is a well known property. This is its getter.
1406      * Note that this *may* be optimized by other classes
1407      *
1408      * @return length property value for this ScriptObject
1409      */
1410     public Object getLength() {
1411         return get("length");
1412     }
1413 
1414     /**
1415      * Stateless toString for ScriptObjects.
1416      *
1417      * @return string description of this object, e.g. {@code [object Object]}
1418      */
1419     public String safeToString() {
1420         return "[object " + getClassName() + "]";
1421     }
1422 
1423     /**
1424      * Return the default value of the object with a given preferred type hint.
1425      * The preferred type hints are String.class for type String, Number.class
1426      * for type Number. <p>
1427      *
1428      * A <code>hint</code> of null means "no hint".
1429      *
1430      * ECMA 8.12.8 [[DefaultValue]](hint)
1431      *
1432      * @param typeHint the preferred type hint
1433      * @return the default value
1434      */
1435     public Object getDefaultValue(final Class<?> typeHint) {
1436         // We delegate to Global, as the implementation uses dynamic call sites to invoke object's "toString" and
1437         // "valueOf" methods, and in order to avoid those call sites from becoming megamorphic when multiple contexts
1438         // are being executed in a long-running program, we move the code and their associated dynamic call sites
1439         // (Global.TO_STRING and Global.VALUE_OF) into per-context code.
1440         return Context.getGlobal().getDefaultValue(this, typeHint);
1441     }
1442 
1443     /**
1444      * Checking whether a script object is an instance of another. Used
1445      * in {@link ScriptFunction} for hasInstance implementation, walks
1446      * the proto chain
1447      *
1448      * @param instance instace to check
1449      * @return true if 'instance' is an instance of this object
1450      */
1451     public boolean isInstance(final ScriptObject instance) {
1452         return false;
1453     }
1454 
1455     /**
1456      * Flag this ScriptObject as non extensible
1457      *
1458      * @return the object after being made non extensible
1459      */
1460     public ScriptObject preventExtensions() {
1461         PropertyMap oldMap = getMap();
1462         while (!compareAndSetMap(oldMap,  getMap().preventExtensions())) {
1463             oldMap = getMap();
1464         }
1465 
1466         //invalidate any fast array setters
1467         final ArrayData array = getArray();
1468         assert array != null;
1469         setArray(ArrayData.preventExtension(array));
1470         return this;
1471     }
1472 
1473     /**
1474      * Check whether if an Object (not just a ScriptObject) represents JavaScript array
1475      *
1476      * @param obj object to check
1477      *
1478      * @return true if array
1479      */
1480     public static boolean isArray(final Object obj) {
1481         return obj instanceof ScriptObject && ((ScriptObject)obj).isArray();
1482     }
1483 
1484     /**
1485      * Check if this ScriptObject is an array
1486      * @return true if array
1487      */
1488     public final boolean isArray() {
1489         return (flags & IS_ARRAY) != 0;
1490     }
1491 
1492     /**
1493      * Flag this ScriptObject as being an array
1494      */
1495     public final void setIsArray() {
1496         flags |= IS_ARRAY;
1497     }
1498 
1499     /**
1500      * Check if this ScriptObject is an {@code arguments} vector
1501      * @return true if arguments vector
1502      */
1503     public final boolean isArguments() {
1504         return (flags & IS_ARGUMENTS) != 0;
1505     }
1506 
1507     /**
1508      * Flag this ScriptObject as being an {@code arguments} vector
1509      */
1510     public final void setIsArguments() {
1511         flags |= IS_ARGUMENTS;
1512     }
1513 
1514     /**
1515      * Check if this object has non-writable length property
1516      *
1517      * @return {@code true} if 'length' property is non-writable
1518      */
1519     public boolean isLengthNotWritable() {
1520         return (flags & IS_LENGTH_NOT_WRITABLE) != 0;
1521     }
1522 
1523     /**
1524      * Flag this object as having non-writable length property.
1525      */
1526     public void setIsLengthNotWritable() {
1527         flags |= IS_LENGTH_NOT_WRITABLE;
1528     }
1529 
1530     /**
1531      * Get the {@link ArrayData}, for this ScriptObject, ensuring it is of a type
1532      * that can handle elementType
1533      * @param elementType elementType
1534      * @return array data
1535      */
1536     public final ArrayData getArray(final Class<?> elementType) {
1537         if (elementType == null) {
1538             return arrayData;
1539         }
1540         final ArrayData newArrayData = arrayData.convert(elementType);
1541         if (newArrayData != arrayData) {
1542             arrayData = newArrayData;
1543         }
1544         return newArrayData;
1545     }
1546 
1547     /**
1548      * Get the {@link ArrayData} for this ScriptObject if it is an array
1549      * @return array data
1550      */
1551     public final ArrayData getArray() {
1552         return arrayData;
1553     }
1554 
1555     /**
1556      * Set the {@link ArrayData} for this ScriptObject if it is to be an array
1557      * @param arrayData the array data
1558      */
1559     public final void setArray(final ArrayData arrayData) {
1560         this.arrayData = arrayData;
1561     }
1562 
1563     /**
1564      * Check if this ScriptObject is extensible
1565      * @return true if extensible
1566      */
1567     public boolean isExtensible() {
1568         return getMap().isExtensible();
1569     }
1570 
1571     /**
1572      * ECMAScript 15.2.3.8 - seal implementation
1573      * @return the sealed ScriptObject
1574      */
1575     public ScriptObject seal() {
1576         PropertyMap oldMap = getMap();
1577 
1578         while (true) {
1579             final PropertyMap newMap = getMap().seal();
1580 
1581             if (!compareAndSetMap(oldMap, newMap)) {
1582                 oldMap = getMap();
1583             } else {
1584                 setArray(ArrayData.seal(getArray()));
1585                 return this;
1586             }
1587         }
1588     }
1589 
1590     /**
1591      * Check whether this ScriptObject is sealed
1592      * @return true if sealed
1593      */
1594     public boolean isSealed() {
1595         return getMap().isSealed();
1596     }
1597 
1598     /**
1599      * ECMA 15.2.39 - freeze implementation. Freeze this ScriptObject
1600      * @return the frozen ScriptObject
1601      */
1602     public ScriptObject freeze() {
1603         PropertyMap oldMap = getMap();
1604 
1605         while (true) {
1606             final PropertyMap newMap = getMap().freeze();
1607 
1608             if (!compareAndSetMap(oldMap, newMap)) {
1609                 oldMap = getMap();
1610             } else {
1611                 setArray(ArrayData.freeze(getArray()));
1612                 return this;
1613             }
1614         }
1615     }
1616 
1617     /**
1618      * Check whether this ScriptObject is frozen
1619      * @return true if frozen
1620      */
1621     public boolean isFrozen() {
1622         return getMap().isFrozen();
1623     }
1624 
1625 
1626     /**
1627      * Flag this ScriptObject as scope
1628      */
1629     public final void setIsScope() {
1630         if (Context.DEBUG) {
1631             scopeCount++;
1632         }
1633         flags |= IS_SCOPE;
1634     }
1635 
1636     /**
1637      * Check whether this ScriptObject is scope
1638      * @return true if scope
1639      */
1640     public final boolean isScope() {
1641         return (flags & IS_SCOPE) != 0;
1642     }
1643 
1644     /**
1645      * Tag this script object as built in
1646      */
1647     public final void setIsBuiltin() {
1648         flags |= IS_BUILTIN;
1649     }
1650 
1651     /**
1652      * Check if this script object is built in
1653      * @return true if build in
1654      */
1655     public final boolean isBuiltin() {
1656         return (flags & IS_BUILTIN) != 0;
1657     }
1658 
1659     /**
1660      * Clears the properties from a ScriptObject
1661      * (java.util.Map-like method to help ScriptObjectMirror implementation)
1662      *
1663      * @param strict strict mode or not
1664      */
1665     public void clear(final boolean strict) {
1666         final Iterator<String> iter = propertyIterator();
1667         while (iter.hasNext()) {
1668             delete(iter.next(), strict);
1669         }
1670     }
1671 
1672     /**
1673      * Checks if a property with a given key is present in a ScriptObject
1674      * (java.util.Map-like method to help ScriptObjectMirror implementation)
1675      *
1676      * @param key the key to check for
1677      * @return true if a property with the given key exists, false otherwise
1678      */
1679     public boolean containsKey(final Object key) {
1680         return has(key);
1681     }
1682 
1683     /**
1684      * Checks if a property with a given value is present in a ScriptObject
1685      * (java.util.Map-like method to help ScriptObjectMirror implementation)
1686      *
1687      * @param value value to check for
1688      * @return true if a property with the given value exists, false otherwise
1689      */
1690     public boolean containsValue(final Object value) {
1691         final Iterator<Object> iter = valueIterator();
1692         while (iter.hasNext()) {
1693             if (iter.next().equals(value)) {
1694                 return true;
1695             }
1696         }
1697         return false;
1698     }
1699 
1700     /**
1701      * Returns the set of {@literal <property, value>} entries that make up this
1702      * ScriptObject's properties
1703      * (java.util.Map-like method to help ScriptObjectMirror implementation)
1704      *
1705      * @return an entry set of all the properties in this object
1706      */
1707     public Set<Map.Entry<Object, Object>> entrySet() {
1708         final Iterator<String> iter = propertyIterator();
1709         final Set<Map.Entry<Object, Object>> entries = new HashSet<>();
1710         while (iter.hasNext()) {
1711             final Object key = iter.next();
1712             entries.add(new AbstractMap.SimpleImmutableEntry<>(key, get(key)));
1713         }
1714         return Collections.unmodifiableSet(entries);
1715     }
1716 
1717     /**
1718      * Check whether a ScriptObject contains no properties
1719      * (java.util.Map-like method to help ScriptObjectMirror implementation)
1720      *
1721      * @return true if object has no properties
1722      */
1723     public boolean isEmpty() {
1724         return !propertyIterator().hasNext();
1725     }
1726 
1727     /**
1728      * Return the set of keys (property names) for all properties
1729      * in this ScriptObject
1730      * (java.util.Map-like method to help ScriptObjectMirror implementation)
1731      *
1732      * @return keySet of this ScriptObject
1733      */
1734     public Set<Object> keySet() {
1735         final Iterator<String> iter = propertyIterator();
1736         final Set<Object> keySet = new HashSet<>();
1737         while (iter.hasNext()) {
1738             keySet.add(iter.next());
1739         }
1740         return Collections.unmodifiableSet(keySet);
1741     }
1742 
1743     /**
1744      * Put a property in the ScriptObject
1745      * (java.util.Map-like method to help ScriptObjectMirror implementation)
1746      *
1747      * @param key property key
1748      * @param value property value
1749      * @param strict strict mode or not
1750      * @return oldValue if property with same key existed already
1751      */
1752     public Object put(final Object key, final Object value, final boolean strict) {
1753         final Object oldValue = get(key);
1754         final int scriptObjectFlags = strict ? NashornCallSiteDescriptor.CALLSITE_STRICT : 0;
1755         set(key, value, scriptObjectFlags);
1756         return oldValue;
1757     }
1758 
1759     /**
1760      * Put several properties in the ScriptObject given a mapping
1761      * of their keys to their values
1762      * (java.util.Map-like method to help ScriptObjectMirror implementation)
1763      *
1764      * @param otherMap a {@literal <key,value>} map of properties to add
1765      * @param strict strict mode or not
1766      */
1767     public void putAll(final Map<?, ?> otherMap, final boolean strict) {
1768         final int scriptObjectFlags = strict ? NashornCallSiteDescriptor.CALLSITE_STRICT : 0;
1769         for (final Map.Entry<?, ?> entry : otherMap.entrySet()) {
1770             set(entry.getKey(), entry.getValue(), scriptObjectFlags);
1771         }
1772     }
1773 
1774     /**
1775      * Remove a property from the ScriptObject.
1776      * (java.util.Map-like method to help ScriptObjectMirror implementation)
1777      *
1778      * @param key the key of the property
1779      * @param strict strict mode or not
1780      * @return the oldValue of the removed property
1781      */
1782     public Object remove(final Object key, final boolean strict) {
1783         final Object oldValue = get(key);
1784         delete(key, strict);
1785         return oldValue;
1786     }
1787 
1788     /**
1789      * Return the size of the ScriptObject - i.e. the number of properties
1790      * it contains
1791      * (java.util.Map-like method to help ScriptObjectMirror implementation)
1792      *
1793      * @return number of properties in ScriptObject
1794      */
1795     public int size() {
1796         int n = 0;
1797         for (final Iterator<String> iter = propertyIterator(); iter.hasNext(); iter.next()) {
1798             n++;
1799         }
1800         return n;
1801     }
1802 
1803     /**
1804      * Return the values of the properties in the ScriptObject
1805      * (java.util.Map-like method to help ScriptObjectMirror implementation)
1806      *
1807      * @return collection of values for the properties in this ScriptObject
1808      */
1809     public Collection<Object> values() {
1810         final List<Object>     values = new ArrayList<>(size());
1811         final Iterator<Object> iter   = valueIterator();
1812         while (iter.hasNext()) {
1813             values.add(iter.next());
1814         }
1815         return Collections.unmodifiableList(values);
1816     }
1817 
1818     /**
1819      * Lookup method that, given a CallSiteDescriptor, looks up the target
1820      * MethodHandle and creates a GuardedInvocation
1821      * with the appropriate guard(s).
1822      *
1823      * @param desc call site descriptor
1824      * @param request the link request
1825      *
1826      * @return GuardedInvocation for the callsite
1827      */
1828     public GuardedInvocation lookup(final CallSiteDescriptor desc, final LinkRequest request) {
1829         final int c = desc.getNameTokenCount();
1830         // JavaScript is "immune" to all currently defined Dynalink composite operation - getProp is the same as getElem
1831         // is the same as getMethod as JavaScript objects have a single namespace for all three. Therefore, we don't
1832         // care about them, and just link to whatever is the first operation.
1833         final String operator = CallSiteDescriptorFactory.tokenizeOperators(desc).get(0);
1834         // NOTE: we support getElem and setItem as JavaScript doesn't distinguish items from properties. Nashorn itself
1835         // emits "dyn:getProp:identifier" for "<expr>.<identifier>" and "dyn:getElem" for "<expr>[<expr>]", but we are
1836         // more flexible here and dispatch not on operation name (getProp vs. getElem), but rather on whether the
1837         // operation has an associated name or not.
1838         switch (operator) {
1839         case "getProp":
1840         case "getElem":
1841         case "getMethod":
1842             return c > 2 ? findGetMethod(desc, request, operator) : findGetIndexMethod(desc, request);
1843         case "setProp":
1844         case "setElem":
1845             return c > 2 ? findSetMethod(desc, request) : findSetIndexMethod(desc, request);
1846         case "call":
1847             return findCallMethod(desc, request);
1848         case "new":
1849             return findNewMethod(desc, request);
1850         case "callMethod":
1851             return findCallMethodMethod(desc, request);
1852         default:
1853             return null;
1854         }
1855     }
1856 
1857     /**
1858      * Find the appropriate New method for an invoke dynamic call.
1859      *
1860      * @param desc The invoke dynamic call site descriptor.
1861      * @param request The link request
1862      *
1863      * @return GuardedInvocation to be invoked at call site.
1864      */
1865     protected GuardedInvocation findNewMethod(final CallSiteDescriptor desc, final LinkRequest request) {
1866         return notAFunction();
1867     }
1868 
1869     /**
1870      * Find the appropriate CALL method for an invoke dynamic call.
1871      * This generates "not a function" always
1872      *
1873      * @param desc    the call site descriptor.
1874      * @param request the link request
1875      *
1876      * @return GuardedInvocation to be invoed at call site.
1877      */
1878     protected GuardedInvocation findCallMethod(final CallSiteDescriptor desc, final LinkRequest request) {
1879         return notAFunction();
1880     }
1881 
1882     private GuardedInvocation notAFunction() {
1883         throw typeError("not.a.function", ScriptRuntime.safeToString(this));
1884     }
1885 
1886     /**
1887      * Find an implementation for a "dyn:callMethod" operation. Note that Nashorn internally never uses
1888      * "dyn:callMethod", but instead always emits two call sites in bytecode, one for "dyn:getMethod", and then another
1889      * one for "dyn:call". Explicit support for "dyn:callMethod" is provided for the benefit of potential external
1890      * callers. The implementation itself actually folds a "dyn:getMethod" method handle into a "dyn:call" method handle.
1891      *
1892      * @param desc    the call site descriptor.
1893      * @param request the link request
1894      *
1895      * @return GuardedInvocation to be invoked at call site.
1896      */
1897     protected GuardedInvocation findCallMethodMethod(final CallSiteDescriptor desc, final LinkRequest request) {
1898         // R(P0, P1, ...)
1899         final MethodType callType = desc.getMethodType();
1900         // use type Object(P0) for the getter
1901         final CallSiteDescriptor getterType = desc.changeMethodType(MethodType.methodType(Object.class, callType.parameterType(0)));
1902         final GuardedInvocation getter = findGetMethod(getterType, request, "getMethod");
1903 
1904         // Object(P0) => Object(P0, P1, ...)
1905         final MethodHandle argDroppingGetter = MH.dropArguments(getter.getInvocation(), 1, callType.parameterList().subList(1, callType.parameterCount()));
1906         // R(Object, P0, P1, ...)
1907         final MethodHandle invoker = Bootstrap.createDynamicInvoker("dyn:call", callType.insertParameterTypes(0, argDroppingGetter.type().returnType()));
1908         // Fold Object(P0, P1, ...) into R(Object, P0, P1, ...) => R(P0, P1, ...)
1909         return getter.replaceMethods(MH.foldArguments(invoker, argDroppingGetter), getter.getGuard());
1910     }
1911 
1912     /**
1913      * Test whether this object contains in its prototype chain or is itself a with-object.
1914      * @return true if a with-object was found
1915      */
1916     final boolean hasWithScope() {
1917         if (isScope()) {
1918             for (ScriptObject obj = this; obj != null; obj = obj.getProto()) {
1919                 if (obj instanceof WithObject) {
1920                     return true;
1921                 }
1922             }
1923         }
1924         return false;
1925     }
1926 
1927     /**
1928      * Add a filter to the first argument of {@code methodHandle} that calls its {@link #getProto()} method
1929      * {@code depth} times.
1930      * @param methodHandle a method handle
1931      * @param depth        distance to target prototype
1932      * @return the filtered method handle
1933      */
1934     static MethodHandle addProtoFilter(final MethodHandle methodHandle, final int depth) {
1935         if (depth == 0) {
1936             return methodHandle;
1937         }
1938         final int listIndex = depth - 1; // We don't need 0-deep walker
1939         MethodHandle filter = listIndex < PROTO_FILTERS.size() ? PROTO_FILTERS.get(listIndex) : null;
1940 
1941         if (filter == null) {
1942             filter = addProtoFilter(GETPROTO, depth - 1);
1943             PROTO_FILTERS.add(null);
1944             PROTO_FILTERS.set(listIndex, filter);
1945         }
1946 
1947         return MH.filterArguments(methodHandle, 0, filter.asType(filter.type().changeReturnType(methodHandle.type().parameterType(0))));
1948     }
1949 
1950     /**
1951      * Find the appropriate GET method for an invoke dynamic call.
1952      *
1953      * @param desc     the call site descriptor
1954      * @param request  the link request
1955      * @param operator operator for get: getProp, getMethod, getElem etc
1956      *
1957      * @return GuardedInvocation to be invoked at call site.
1958      */
1959     protected GuardedInvocation findGetMethod(final CallSiteDescriptor desc, final LinkRequest request, final String operator) {
1960         final boolean explicitInstanceOfCheck = explicitInstanceOfCheck(desc, request);
1961 
1962         String name;
1963         name = desc.getNameToken(CallSiteDescriptor.NAME_OPERAND);
1964         if (NashornCallSiteDescriptor.isApplyToCall(desc)) {
1965             if (Global.isBuiltinFunctionPrototypeApply()) {
1966                 name = "call";
1967             }
1968         }
1969 
1970         if (request.isCallSiteUnstable() || hasWithScope()) {
1971             return findMegaMorphicGetMethod(desc, name, "getMethod".equals(operator));
1972         }
1973 
1974         final FindProperty find = findProperty(name, true);
1975         MethodHandle mh;
1976 
1977         if (find == null) {
1978             switch (operator) {
1979             case "getElem": // getElem only gets here if element name is constant, so treat it like a property access
1980             case "getProp":
1981                 return noSuchProperty(desc, request);
1982             case "getMethod":
1983                 return noSuchMethod(desc, request);
1984             default:
1985                 throw new AssertionError(operator); // never invoked with any other operation
1986             }
1987         }
1988 
1989         final GlobalConstants globalConstants = getGlobalConstants();
1990         if (globalConstants != null) {
1991             final GuardedInvocation cinv = globalConstants.findGetMethod(find, this, desc);
1992             if (cinv != null) {
1993                 return cinv;
1994             }
1995         }
1996 
1997         final Class<?> returnType = desc.getMethodType().returnType();
1998         final Property property   = find.getProperty();
1999 
2000         final int programPoint = NashornCallSiteDescriptor.isOptimistic(desc) ?
2001                 NashornCallSiteDescriptor.getProgramPoint(desc) :
2002                 UnwarrantedOptimismException.INVALID_PROGRAM_POINT;
2003 
2004         mh = find.getGetter(returnType, programPoint, request);
2005         // Get the appropriate guard for this callsite and property.
2006         final MethodHandle guard = NashornGuards.getGuard(this, property, desc, explicitInstanceOfCheck);
2007         final ScriptObject owner = find.getOwner();
2008         final Class<ClassCastException> exception = explicitInstanceOfCheck ? null : ClassCastException.class;
2009 
2010         final SwitchPoint protoSwitchPoint;
2011 
2012         if (mh == null) {
2013             mh = Lookup.emptyGetter(returnType);
2014             protoSwitchPoint = getProtoSwitchPoint(name, owner);
2015         } else if (!find.isSelf()) {
2016             assert mh.type().returnType().equals(returnType) :
2017                     "return type mismatch for getter " + mh.type().returnType() + " != " + returnType;
2018             if (!(property instanceof UserAccessorProperty)) {
2019                 // Add a filter that replaces the self object with the prototype owning the property.
2020                 mh = addProtoFilter(mh, find.getProtoChainLength());
2021             }
2022             protoSwitchPoint = getProtoSwitchPoint(name, owner);
2023         } else {
2024             protoSwitchPoint = null;
2025         }
2026 
2027         final GuardedInvocation inv = new GuardedInvocation(mh, guard, protoSwitchPoint, exception);
2028         return inv.addSwitchPoint(findBuiltinSwitchPoint(name));
2029     }
2030 
2031     private static GuardedInvocation findMegaMorphicGetMethod(final CallSiteDescriptor desc, final String name, final boolean isMethod) {
2032         Context.getContextTrusted().getLogger(ObjectClassGenerator.class).warning("Megamorphic getter: " + desc + " " + name + " " +isMethod);
2033         final MethodHandle invoker = MH.insertArguments(MEGAMORPHIC_GET, 1, name, isMethod);
2034         final MethodHandle guard   = getScriptObjectGuard(desc.getMethodType(), true);
2035         return new GuardedInvocation(invoker, guard);
2036     }
2037 
2038     @SuppressWarnings("unused")
2039     private Object megamorphicGet(final String key, final boolean isMethod) {
2040         final FindProperty find = findProperty(key, true);
2041         if (find != null) {
2042             return find.getObjectValue();
2043         }
2044 
2045         return isMethod ? getNoSuchMethod(key, INVALID_PROGRAM_POINT) : invokeNoSuchProperty(key, INVALID_PROGRAM_POINT);
2046     }
2047 
2048     // Marks a property as declared and sets its value. Used as slow path for block-scoped LET and CONST
2049     @SuppressWarnings("unused")
2050     private void declareAndSet(final String key, final Object value) {
2051         final PropertyMap oldMap = getMap();
2052         final FindProperty find = findProperty(key, false);
2053         assert find != null;
2054 
2055         final Property property = find.getProperty();
2056         assert property != null;
2057         assert property.needsDeclaration();
2058 
2059         final PropertyMap newMap = oldMap.replaceProperty(property, property.removeFlags(Property.NEEDS_DECLARATION));
2060         setMap(newMap);
2061         set(key, value, 0);
2062     }
2063 
2064     /**
2065      * Find the appropriate GETINDEX method for an invoke dynamic call.
2066      *
2067      * @param desc    the call site descriptor
2068      * @param request the link request
2069      *
2070      * @return GuardedInvocation to be invoked at call site.
2071      */
2072     protected GuardedInvocation findGetIndexMethod(final CallSiteDescriptor desc, final LinkRequest request) {
2073         final MethodType callType                = desc.getMethodType();
2074         final Class<?>   returnType              = callType.returnType();
2075         final Class<?>   returnClass             = returnType.isPrimitive() ? returnType : Object.class;
2076         final Class<?>   keyClass                = callType.parameterType(1);
2077         final boolean    explicitInstanceOfCheck = explicitInstanceOfCheck(desc, request);
2078 
2079         final String name;
2080         if (returnClass.isPrimitive()) {
2081             //turn e.g. get with a double into getDouble
2082             final String returnTypeName = returnClass.getName();
2083             name = "get" + Character.toUpperCase(returnTypeName.charAt(0)) + returnTypeName.substring(1, returnTypeName.length());
2084         } else {
2085             name = "get";
2086         }
2087 
2088         final MethodHandle mh = findGetIndexMethodHandle(returnClass, name, keyClass, desc);
2089         return new GuardedInvocation(mh, getScriptObjectGuard(callType, explicitInstanceOfCheck), (SwitchPoint)null, explicitInstanceOfCheck ? null : ClassCastException.class);
2090     }
2091 
2092     private static MethodHandle getScriptObjectGuard(final MethodType type, final boolean explicitInstanceOfCheck) {
2093         return ScriptObject.class.isAssignableFrom(type.parameterType(0)) ? null : NashornGuards.getScriptObjectGuard(explicitInstanceOfCheck);
2094     }
2095 
2096     /**
2097      * Find a handle for a getIndex method
2098      * @param returnType     return type for getter
2099      * @param name           name
2100      * @param elementType    index type for getter
2101      * @param desc           call site descriptor
2102      * @return method handle for getter
2103      */
2104     protected MethodHandle findGetIndexMethodHandle(final Class<?> returnType, final String name, final Class<?> elementType, final CallSiteDescriptor desc) {
2105         if (!returnType.isPrimitive()) {
2106             return findOwnMH_V(getClass(), name, returnType, elementType);
2107         }
2108 
2109         return MH.insertArguments(
2110                 findOwnMH_V(getClass(), name, returnType, elementType, int.class),
2111                 2,
2112                 NashornCallSiteDescriptor.isOptimistic(desc) ?
2113                         NashornCallSiteDescriptor.getProgramPoint(desc) :
2114                         INVALID_PROGRAM_POINT);
2115     }
2116 
2117     /**
2118      * Get a switch point for a property with the given {@code name} that will be invalidated when
2119      * the property definition is changed in this object's prototype chain. Returns {@code null} if
2120      * the property is defined in this object itself.
2121      *
2122      * @param name the property name
2123      * @param owner the property owner, null if property is not defined
2124      * @return a SwitchPoint or null
2125      */
2126     public final SwitchPoint getProtoSwitchPoint(final String name, final ScriptObject owner) {
2127         if (owner == this || getProto() == null) {
2128             return null;
2129         }
2130 
2131         for (ScriptObject obj = this; obj != owner && obj.getProto() != null; obj = obj.getProto()) {
2132             final ScriptObject parent = obj.getProto();
2133             parent.getMap().addListener(name, obj.getMap());
2134         }
2135 
2136         return getMap().getSwitchPoint(name);
2137     }
2138 
2139     /**
2140      * Find the appropriate SET method for an invoke dynamic call.
2141      *
2142      * @param desc    the call site descriptor
2143      * @param request the link request
2144      *
2145      * @return GuardedInvocation to be invoked at call site.
2146      */
2147     protected GuardedInvocation findSetMethod(final CallSiteDescriptor desc, final LinkRequest request) {
2148         final String name = desc.getNameToken(CallSiteDescriptor.NAME_OPERAND);
2149 
2150         if (request.isCallSiteUnstable() || hasWithScope()) {
2151             return findMegaMorphicSetMethod(desc, name);
2152         }
2153 
2154         final boolean explicitInstanceOfCheck = explicitInstanceOfCheck(desc, request);
2155 
2156         /*
2157          * If doing property set on a scope object, we should stop proto search on the first
2158          * non-scope object. Without this, for example, when assigning "toString" on global scope,
2159          * we'll end up assigning it on it's proto - which is Object.prototype.toString !!
2160          *
2161          * toString = function() { print("global toString"); } // don't affect Object.prototype.toString
2162          */
2163         FindProperty find = findProperty(name, true, this);
2164 
2165         // If it's not a scope search, then we don't want any inherited properties except those with user defined accessors.
2166         if (find != null && find.isInherited() && !(find.getProperty() instanceof UserAccessorProperty)) {
2167             // We should still check if inherited data property is not writable
2168             if (isExtensible() && !find.getProperty().isWritable()) {
2169                 return createEmptySetMethod(desc, explicitInstanceOfCheck, "property.not.writable", true);
2170             }
2171             // Otherwise, forget the found property unless this is a scope callsite and the owner is a scope object as well.
2172             if (!NashornCallSiteDescriptor.isScope(desc) || !find.getOwner().isScope()) {
2173                 find = null;
2174             }
2175         }
2176 
2177         if (find != null) {
2178             if (!find.getProperty().isWritable() && !NashornCallSiteDescriptor.isDeclaration(desc)) {
2179                 if (NashornCallSiteDescriptor.isScope(desc) && find.getProperty().isLexicalBinding()) {
2180                     throw typeError("assign.constant", name); // Overwriting ES6 const should throw also in non-strict mode.
2181                 }
2182                 // Existing, non-writable property
2183                 return createEmptySetMethod(desc, explicitInstanceOfCheck, "property.not.writable", true);
2184             }
2185         } else {
2186             if (!isExtensible()) {
2187                 return createEmptySetMethod(desc, explicitInstanceOfCheck, "object.non.extensible", false);
2188             }
2189         }
2190 
2191         final GuardedInvocation inv = new SetMethodCreator(this, find, desc, request).createGuardedInvocation(findBuiltinSwitchPoint(name));
2192 
2193         final GlobalConstants globalConstants = getGlobalConstants();
2194         if (globalConstants != null) {
2195             final GuardedInvocation cinv = globalConstants.findSetMethod(find, this, inv, desc, request);
2196             if (cinv != null) {
2197                 return cinv;
2198             }
2199         }
2200 
2201         return inv;
2202     }
2203 
2204     private GlobalConstants getGlobalConstants() {
2205         // Avoid hitting getContext() which might be costly for a non-Global unless needed.
2206         return GlobalConstants.GLOBAL_ONLY && !isGlobal() ? null : getContext().getGlobalConstants();
2207     }
2208 
2209     private GuardedInvocation createEmptySetMethod(final CallSiteDescriptor desc, final boolean explicitInstanceOfCheck, final String strictErrorMessage, final boolean canBeFastScope) {
2210         final String  name = desc.getNameToken(CallSiteDescriptor.NAME_OPERAND);
2211         if (NashornCallSiteDescriptor.isStrict(desc)) {
2212             throw typeError(strictErrorMessage, name, ScriptRuntime.safeToString(this));
2213         }
2214         assert canBeFastScope || !NashornCallSiteDescriptor.isFastScope(desc);
2215         return new GuardedInvocation(
2216                 Lookup.EMPTY_SETTER,
2217                 NashornGuards.getMapGuard(getMap(), explicitInstanceOfCheck),
2218                 getProtoSwitchPoint(name, null),
2219                 explicitInstanceOfCheck ? null : ClassCastException.class);
2220     }
2221 
2222     @SuppressWarnings("unused")
2223     private boolean extensionCheck(final boolean isStrict, final String name) {
2224         if (isExtensible()) {
2225             return true; //go on and do the set. this is our guard
2226         } else if (isStrict) {
2227             //throw an error for attempting to do the set in strict mode
2228             throw typeError("object.non.extensible", name, ScriptRuntime.safeToString(this));
2229         } else {
2230             //not extensible, non strict - this is a nop
2231             return false;
2232         }
2233     }
2234 
2235     private GuardedInvocation findMegaMorphicSetMethod(final CallSiteDescriptor desc, final String name) {
2236         final MethodType        type = desc.getMethodType().insertParameterTypes(1, Object.class);
2237         //never bother with ClassCastExceptionGuard for megamorphic callsites
2238         final GuardedInvocation inv = findSetIndexMethod(getClass(), desc, false, type);
2239         return inv.replaceMethods(MH.insertArguments(inv.getInvocation(), 1, name), inv.getGuard());
2240     }
2241 
2242     @SuppressWarnings("unused")
2243     private static Object globalFilter(final Object object) {
2244         ScriptObject sobj = (ScriptObject) object;
2245         while (sobj != null && !(sobj instanceof Global)) {
2246             sobj = sobj.getProto();
2247         }
2248         return sobj;
2249     }
2250 
2251     /**
2252      * Lookup function for the set index method, available for subclasses as well, e.g. {@link NativeArray}
2253      * provides special quick accessor linkage for continuous arrays that are represented as Java arrays
2254      *
2255      * @param desc    call site descriptor
2256      * @param request link request
2257      *
2258      * @return GuardedInvocation to be invoked at call site.
2259      */
2260     protected GuardedInvocation findSetIndexMethod(final CallSiteDescriptor desc, final LinkRequest request) { // array, index, value
2261         return findSetIndexMethod(getClass(), desc, explicitInstanceOfCheck(desc, request), desc.getMethodType());
2262     }
2263 
2264     /**
2265      * Find the appropriate SETINDEX method for an invoke dynamic call.
2266      *
2267      * @param clazz the receiver class
2268      * @param desc  the call site descriptor
2269      * @param explicitInstanceOfCheck add an explicit instanceof check?
2270      * @param callType the method type at the call site
2271      *
2272      * @return GuardedInvocation to be invoked at call site.
2273      */
2274     private static GuardedInvocation findSetIndexMethod(final Class<? extends ScriptObject> clazz, final CallSiteDescriptor desc, final boolean explicitInstanceOfCheck, final MethodType callType) {
2275         assert callType.parameterCount() == 3;
2276         final Class<?> keyClass   = callType.parameterType(1);
2277         final Class<?> valueClass = callType.parameterType(2);
2278 
2279         MethodHandle methodHandle = findOwnMH_V(clazz, "set", void.class, keyClass, valueClass, int.class);
2280         methodHandle = MH.insertArguments(methodHandle, 3, NashornCallSiteDescriptor.getFlags(desc));
2281 
2282         return new GuardedInvocation(methodHandle, getScriptObjectGuard(callType, explicitInstanceOfCheck), (SwitchPoint)null, explicitInstanceOfCheck ? null : ClassCastException.class);
2283     }
2284 
2285     /**
2286      * Fall back if a function property is not found.
2287      * @param desc The call site descriptor
2288      * @param request the link request
2289      * @return GuardedInvocation to be invoked at call site.
2290      */
2291     public GuardedInvocation noSuchMethod(final CallSiteDescriptor desc, final LinkRequest request) {
2292         final String       name      = desc.getNameToken(2);
2293         final FindProperty find      = findProperty(NO_SUCH_METHOD_NAME, true);
2294         final boolean      scopeCall = isScope() && NashornCallSiteDescriptor.isScope(desc);
2295 
2296         if (find == null) {
2297             return noSuchProperty(desc, request);
2298         }
2299 
2300         final boolean explicitInstanceOfCheck = explicitInstanceOfCheck(desc, request);
2301 
2302         final Object value = find.getObjectValue();
2303         if (!(value instanceof ScriptFunction)) {
2304             return createEmptyGetter(desc, explicitInstanceOfCheck, name);
2305         }
2306 
2307         final ScriptFunction func = (ScriptFunction)value;
2308         final Object         thiz = scopeCall && func.isStrict() ? UNDEFINED : this;
2309         // TODO: It'd be awesome if we could bind "name" without binding "this".
2310         // Since we're binding this we must use an identity guard here.
2311         return new GuardedInvocation(
2312                 MH.dropArguments(
2313                         MH.constant(
2314                                 ScriptFunction.class,
2315                                 func.makeBoundFunction(thiz, new Object[] { name })),
2316                         0,
2317                         Object.class),
2318                 NashornGuards.combineGuards(
2319                         NashornGuards.getIdentityGuard(this),
2320                         NashornGuards.getMapGuard(getMap(), true)));
2321     }
2322 
2323     /**
2324      * Fall back if a property is not found.
2325      * @param desc the call site descriptor.
2326      * @param request the link request
2327      * @return GuardedInvocation to be invoked at call site.
2328      */
2329     public GuardedInvocation noSuchProperty(final CallSiteDescriptor desc, final LinkRequest request) {
2330         final String       name        = desc.getNameToken(CallSiteDescriptor.NAME_OPERAND);
2331         final FindProperty find        = findProperty(NO_SUCH_PROPERTY_NAME, true);
2332         final boolean      scopeAccess = isScope() && NashornCallSiteDescriptor.isScope(desc);
2333 
2334         if (find != null) {
2335             final Object   value = find.getObjectValue();
2336             ScriptFunction func  = null;
2337             MethodHandle   mh    = null;
2338 
2339             if (value instanceof ScriptFunction) {
2340                 func = (ScriptFunction)value;
2341                 mh   = getCallMethodHandle(func, desc.getMethodType(), name);
2342             }
2343 
2344             if (mh != null) {
2345                 assert func != null;
2346                 if (scopeAccess && func.isStrict()) {
2347                     mh = bindTo(mh, UNDEFINED);
2348                 }
2349 
2350                 return new GuardedInvocation(
2351                         mh,
2352                         find.isSelf()?
2353                             getKnownFunctionPropertyGuardSelf(
2354                                 getMap(),
2355                                 find.getGetter(Object.class, INVALID_PROGRAM_POINT, request),
2356                                 func)
2357                             :
2358                             //TODO this always does a scriptobject check
2359                             getKnownFunctionPropertyGuardProto(
2360                                 getMap(),
2361                                 find.getGetter(Object.class, INVALID_PROGRAM_POINT, request),
2362                                 find.getProtoChainLength(),
2363                                 func),
2364                         getProtoSwitchPoint(NO_SUCH_PROPERTY_NAME, find.getOwner()),
2365                         //TODO this doesn't need a ClassCastException as guard always checks script object
2366                         null);
2367             }
2368         }
2369 
2370         if (scopeAccess) {
2371             throw referenceError("not.defined", name);
2372         }
2373 
2374         return createEmptyGetter(desc, explicitInstanceOfCheck(desc, request), name);
2375     }
2376 
2377     /**
2378      * Invoke fall back if a property is not found.
2379      * @param name Name of property.
2380      * @param programPoint program point
2381      * @return Result from call.
2382      */
2383     protected Object invokeNoSuchProperty(final String name, final int programPoint) {
2384         final FindProperty find = findProperty(NO_SUCH_PROPERTY_NAME, true);
2385 
2386         Object ret = UNDEFINED;
2387 
2388         if (find != null) {
2389             final Object func = find.getObjectValue();
2390 
2391             if (func instanceof ScriptFunction) {
2392                 ret = ScriptRuntime.apply((ScriptFunction)func, this, name);
2393             }
2394         }
2395 
2396         if (isValid(programPoint)) {
2397             throw new UnwarrantedOptimismException(ret, programPoint);
2398         }
2399 
2400         return ret;
2401     }
2402 
2403 
2404     /**
2405      * Get __noSuchMethod__ as a function bound to this object and {@code name} if it is defined.
2406      * @param name the method name
2407      * @return the bound function, or undefined
2408      */
2409     private Object getNoSuchMethod(final String name, final int programPoint) {
2410         final FindProperty find = findProperty(NO_SUCH_METHOD_NAME, true);
2411 
2412         if (find == null) {
2413             return invokeNoSuchProperty(name, programPoint);
2414         }
2415 
2416         final Object value = find.getObjectValue();
2417         if (!(value instanceof ScriptFunction)) {
2418             return UNDEFINED;
2419         }
2420 
2421         return ((ScriptFunction)value).makeBoundFunction(this, new Object[] {name});
2422     }
2423 
2424     private GuardedInvocation createEmptyGetter(final CallSiteDescriptor desc, final boolean explicitInstanceOfCheck, final String name) {
2425         if (NashornCallSiteDescriptor.isOptimistic(desc)) {
2426             throw new UnwarrantedOptimismException(UNDEFINED, NashornCallSiteDescriptor.getProgramPoint(desc), Type.OBJECT);
2427         }
2428 
2429         return new GuardedInvocation(Lookup.emptyGetter(desc.getMethodType().returnType()),
2430                 NashornGuards.getMapGuard(getMap(), explicitInstanceOfCheck), getProtoSwitchPoint(name, null),
2431                 explicitInstanceOfCheck ? null : ClassCastException.class);
2432     }
2433 
2434     private abstract static class ScriptObjectIterator <T extends Object> implements Iterator<T> {
2435         protected T[] values;
2436         protected final ScriptObject object;
2437         private int index;
2438 
2439         ScriptObjectIterator(final ScriptObject object) {
2440             this.object = object;
2441         }
2442 
2443         protected abstract void init();
2444 
2445         @Override
2446         public boolean hasNext() {
2447             if (values == null) {
2448                 init();
2449             }
2450             return index < values.length;
2451         }
2452 
2453         @Override
2454         public T next() {
2455             if (values == null) {
2456                 init();
2457             }
2458             return values[index++];
2459         }
2460 
2461         @Override
2462         public void remove() {
2463             throw new UnsupportedOperationException("remove");
2464         }
2465     }
2466 
2467     private static class KeyIterator extends ScriptObjectIterator<String> {
2468         KeyIterator(final ScriptObject object) {
2469             super(object);
2470         }
2471 
2472         @Override
2473         protected void init() {
2474             final Set<String> keys = new LinkedHashSet<>();
2475             final Set<String> nonEnumerable = new HashSet<>();
2476             for (ScriptObject self = object; self != null; self = self.getProto()) {
2477                 keys.addAll(Arrays.asList(self.getOwnKeys(false, nonEnumerable)));
2478             }
2479             this.values = keys.toArray(new String[keys.size()]);
2480         }
2481     }
2482 
2483     private static class ValueIterator extends ScriptObjectIterator<Object> {
2484         ValueIterator(final ScriptObject object) {
2485             super(object);
2486         }
2487 
2488         @Override
2489         protected void init() {
2490             final ArrayList<Object> valueList = new ArrayList<>();
2491             final Set<String> nonEnumerable = new HashSet<>();
2492             for (ScriptObject self = object; self != null; self = self.getProto()) {
2493                 for (final String key : self.getOwnKeys(false, nonEnumerable)) {
2494                     valueList.add(self.get(key));
2495                 }
2496             }
2497             this.values = valueList.toArray(new Object[valueList.size()]);
2498         }
2499     }
2500 
2501     /**
2502      * Add a spill property for the given key.
2503      * @param key    Property key.
2504      * @param flags  Property flags.
2505      * @return Added property.
2506      */
2507     private Property addSpillProperty(final String key, final int flags, final Object value, final boolean hasInitialValue) {
2508         final PropertyMap propertyMap = getMap();
2509         final int fieldSlot  = propertyMap.getFreeFieldSlot();
2510         final int propertyFlags = flags | (useDualFields() ? Property.DUAL_FIELDS : 0);
2511 
2512         Property property;
2513         if (fieldSlot > -1) {
2514             property = hasInitialValue ?
2515                 new AccessorProperty(key, propertyFlags, fieldSlot, this, value) :
2516                 new AccessorProperty(key, propertyFlags, getClass(), fieldSlot);
2517             property = addOwnProperty(property);
2518         } else {
2519             final int spillSlot = propertyMap.getFreeSpillSlot();
2520             property = hasInitialValue ?
2521                 new SpillProperty(key, propertyFlags, spillSlot, this, value) :
2522                 new SpillProperty(key, propertyFlags, spillSlot);
2523             property = addOwnProperty(property);
2524             ensureSpillSize(property.getSlot());
2525         }
2526         return property;
2527     }
2528 
2529     /**
2530      * Add a spill entry for the given key.
2531      * @param key Property key.
2532      * @return Setter method handle.
2533      */
2534     MethodHandle addSpill(final Class<?> type, final String key) {
2535         return addSpillProperty(key, 0, null, false).getSetter(type, getMap());
2536     }
2537 
2538     /**
2539      * Make sure arguments are paired correctly, with respect to more parameters than declared,
2540      * fewer parameters than declared and other things that JavaScript allows. This might involve
2541      * creating collectors.
2542      *
2543      * @param methodHandle method handle for invoke
2544      * @param callType     type of the call
2545      *
2546      * @return method handle with adjusted arguments
2547      */
2548     protected static MethodHandle pairArguments(final MethodHandle methodHandle, final MethodType callType) {
2549         return pairArguments(methodHandle, callType, null);
2550     }
2551 
2552     /**
2553      * Make sure arguments are paired correctly, with respect to more parameters than declared,
2554      * fewer parameters than declared and other things that JavaScript allows. This might involve
2555      * creating collectors.
2556      *
2557      * Make sure arguments are paired correctly.
2558      * @param methodHandle MethodHandle to adjust.
2559      * @param callType     MethodType of the call site.
2560      * @param callerVarArg true if the caller is vararg, false otherwise, null if it should be inferred from the
2561      * {@code callType}; basically, if the last parameter type of the call site is an array, it'll be considered a
2562      * variable arity call site. These are ordinarily rare; Nashorn code generator creates variable arity call sites
2563      * when the call has more than {@link LinkerCallSite#ARGLIMIT} parameters.
2564      *
2565      * @return method handle with adjusted arguments
2566      */
2567     public static MethodHandle pairArguments(final MethodHandle methodHandle, final MethodType callType, final Boolean callerVarArg) {
2568         final MethodType methodType = methodHandle.type();
2569         if (methodType.equals(callType.changeReturnType(methodType.returnType()))) {
2570             return methodHandle;
2571         }
2572 
2573         final int parameterCount = methodType.parameterCount();
2574         final int callCount      = callType.parameterCount();
2575 
2576         final boolean isCalleeVarArg = parameterCount > 0 && methodType.parameterType(parameterCount - 1).isArray();
2577         final boolean isCallerVarArg = callerVarArg != null ? callerVarArg : callCount > 0 &&
2578                 callType.parameterType(callCount - 1).isArray();
2579 
2580         if (isCalleeVarArg) {
2581             return isCallerVarArg ?
2582                 methodHandle :
2583                 MH.asCollector(methodHandle, Object[].class, callCount - parameterCount + 1);
2584         }
2585 
2586         if (isCallerVarArg) {
2587             return adaptHandleToVarArgCallSite(methodHandle, callCount);
2588         }
2589 
2590         if (callCount < parameterCount) {
2591             final int      missingArgs = parameterCount - callCount;
2592             final Object[] fillers     = new Object[missingArgs];
2593 
2594             Arrays.fill(fillers, UNDEFINED);
2595 
2596             if (isCalleeVarArg) {
2597                 fillers[missingArgs - 1] = ScriptRuntime.EMPTY_ARRAY;
2598             }
2599 
2600             return MH.insertArguments(
2601                 methodHandle,
2602                 parameterCount - missingArgs,
2603                 fillers);
2604         }
2605 
2606         if (callCount > parameterCount) {
2607             final int discardedArgs = callCount - parameterCount;
2608 
2609             final Class<?>[] discards = new Class<?>[discardedArgs];
2610             Arrays.fill(discards, Object.class);
2611 
2612             return MH.dropArguments(methodHandle, callCount - discardedArgs, discards);
2613         }
2614 
2615         return methodHandle;
2616     }
2617 
2618     static MethodHandle adaptHandleToVarArgCallSite(final MethodHandle mh, final int callSiteParamCount) {
2619         final int spreadArgs = mh.type().parameterCount() - callSiteParamCount + 1;
2620         return MH.filterArguments(
2621             MH.asSpreader(
2622                 mh,
2623                 Object[].class,
2624                 spreadArgs),
2625             callSiteParamCount - 1,
2626             MH.insertArguments(
2627                 TRUNCATINGFILTER,
2628                 0,
2629                 spreadArgs)
2630             );
2631     }
2632 
2633     @SuppressWarnings("unused")
2634     private static Object[] truncatingFilter(final int n, final Object[] array) {
2635         final int length = array == null ? 0 : array.length;
2636         if (n == length) {
2637             return array == null ? ScriptRuntime.EMPTY_ARRAY : array;
2638         }
2639 
2640         final Object[] newArray = new Object[n];
2641 
2642         if (array != null) {
2643             System.arraycopy(array, 0, newArray, 0, Math.min(n, length));
2644         }
2645 
2646         if (length < n) {
2647             final Object fill = UNDEFINED;
2648 
2649             for (int i = length; i < n; i++) {
2650                 newArray[i] = fill;
2651             }
2652         }
2653 
2654         return newArray;
2655     }
2656 
2657     /**
2658       * Numeric length setter for length property
2659       *
2660       * @param newLength new length to set
2661       */
2662     public final void setLength(final long newLength) {
2663         ArrayData data = getArray();
2664         final long arrayLength = data.length();
2665         if (newLength == arrayLength) {
2666             return;
2667         }
2668 
2669         if (newLength > arrayLength) {
2670             data = data.ensure(newLength - 1);
2671             if (data.canDelete(arrayLength, newLength - 1, false)) {
2672                data = data.delete(arrayLength, newLength - 1);
2673             }
2674             setArray(data);
2675             return;
2676         }
2677 
2678         if (newLength < arrayLength) {
2679            long actualLength = newLength;
2680 
2681            // Check for numeric keys in property map and delete them or adjust length, depending on whether
2682            // they're defined as configurable. See ES5 #15.4.5.2
2683            if (getMap().containsArrayKeys()) {
2684 
2685                for (long l = arrayLength - 1; l >= newLength; l--) {
2686                    final FindProperty find = findProperty(JSType.toString(l), false);
2687 
2688                    if (find != null) {
2689 
2690                        if (find.getProperty().isConfigurable()) {
2691                            deleteOwnProperty(find.getProperty());
2692                        } else {
2693                            actualLength = l + 1;
2694                            break;
2695                        }
2696                    }
2697                }
2698            }
2699 
2700            setArray(data.shrink(actualLength));
2701            data.setLength(actualLength);
2702        }
2703     }
2704 
2705     private int getInt(final int index, final String key, final int programPoint) {
2706         if (isValidArrayIndex(index)) {
2707             for (ScriptObject object = this; ; ) {
2708                 if (object.getMap().containsArrayKeys()) {
2709                     final FindProperty find = object.findProperty(key, false, this);
2710 
2711                     if (find != null) {
2712                         return getIntValue(find, programPoint);
2713                     }
2714                 }
2715 
2716                 if ((object = object.getProto()) == null) {
2717                     break;
2718                 }
2719 
2720                 final ArrayData array = object.getArray();
2721 
2722                 if (array.has(index)) {
2723                     return isValid(programPoint) ?
2724                         array.getIntOptimistic(index, programPoint) :
2725                         array.getInt(index);
2726                 }
2727             }
2728         } else {
2729             final FindProperty find = findProperty(key, true);
2730 
2731             if (find != null) {
2732                 return getIntValue(find, programPoint);
2733             }
2734         }
2735 
2736         return JSType.toInt32(invokeNoSuchProperty(key, programPoint));
2737     }
2738 
2739     @Override
2740     public int getInt(final Object key, final int programPoint) {
2741         final Object    primitiveKey = JSType.toPrimitive(key, String.class);
2742         final int       index        = getArrayIndex(primitiveKey);
2743         final ArrayData array        = getArray();
2744 
2745         if (array.has(index)) {
2746             return isValid(programPoint) ? array.getIntOptimistic(index, programPoint) : array.getInt(index);
2747         }
2748 
2749         return getInt(index, JSType.toString(primitiveKey), programPoint);
2750     }
2751 
2752     @Override
2753     public int getInt(final double key, final int programPoint) {
2754         final int       index = getArrayIndex(key);
2755         final ArrayData array = getArray();
2756 
2757         if (array.has(index)) {
2758             return isValid(programPoint) ? array.getIntOptimistic(index, programPoint) : array.getInt(index);
2759         }
2760 
2761         return getInt(index, JSType.toString(key), programPoint);
2762     }
2763 
2764     @Override
2765     public int getInt(final long key, final int programPoint) {
2766         final int       index = getArrayIndex(key);
2767         final ArrayData array = getArray();
2768 
2769         if (array.has(index)) {
2770             return isValid(programPoint) ? array.getIntOptimistic(index, programPoint) : array.getInt(index);
2771         }
2772 
2773         return getInt(index, JSType.toString(key), programPoint);
2774     }
2775 
2776     @Override
2777     public int getInt(final int key, final int programPoint) {
2778         final int       index = getArrayIndex(key);
2779         final ArrayData array = getArray();
2780 
2781         if (array.has(index)) {
2782             return isValid(programPoint) ? array.getIntOptimistic(key, programPoint) : array.getInt(key);
2783         }
2784 
2785         return getInt(index, JSType.toString(key), programPoint);
2786     }
2787 
2788     private long getLong(final int index, final String key, final int programPoint) {
2789         if (isValidArrayIndex(index)) {
2790             for (ScriptObject object = this; ; ) {
2791                 if (object.getMap().containsArrayKeys()) {
2792                     final FindProperty find = object.findProperty(key, false, this);
2793                     if (find != null) {
2794                         return getLongValue(find, programPoint);
2795                     }
2796                 }
2797 
2798                 if ((object = object.getProto()) == null) {
2799                     break;
2800                 }
2801 
2802                 final ArrayData array = object.getArray();
2803 
2804                 if (array.has(index)) {
2805                     return isValid(programPoint) ?
2806                         array.getLongOptimistic(index, programPoint) :
2807                         array.getLong(index);
2808                 }
2809             }
2810         } else {
2811             final FindProperty find = findProperty(key, true);
2812 
2813             if (find != null) {
2814                 return getLongValue(find, programPoint);
2815             }
2816         }
2817 
2818         return JSType.toLong(invokeNoSuchProperty(key, programPoint));
2819     }
2820 
2821     @Override
2822     public long getLong(final Object key, final int programPoint) {
2823         final Object    primitiveKey = JSType.toPrimitive(key, String.class);
2824         final int       index        = getArrayIndex(primitiveKey);
2825         final ArrayData array        = getArray();
2826 
2827         if (array.has(index)) {
2828             return isValid(programPoint) ? array.getLongOptimistic(index, programPoint) : array.getLong(index);
2829         }
2830 
2831         return getLong(index, JSType.toString(primitiveKey), programPoint);
2832     }
2833 
2834     @Override
2835     public long getLong(final double key, final int programPoint) {
2836         final int       index = getArrayIndex(key);
2837         final ArrayData array = getArray();
2838 
2839         if (array.has(index)) {
2840             return isValid(programPoint) ? array.getLongOptimistic(index, programPoint) : array.getLong(index);
2841         }
2842 
2843         return getLong(index, JSType.toString(key), programPoint);
2844     }
2845 
2846     @Override
2847     public long getLong(final long key, final int programPoint) {
2848         final int       index = getArrayIndex(key);
2849         final ArrayData array = getArray();
2850 
2851         if (array.has(index)) {
2852             return isValid(programPoint) ? array.getLongOptimistic(index, programPoint) : array.getLong(index);
2853         }
2854 
2855         return getLong(index, JSType.toString(key), programPoint);
2856     }
2857 
2858     @Override
2859     public long getLong(final int key, final int programPoint) {
2860         final int       index = getArrayIndex(key);
2861         final ArrayData array = getArray();
2862 
2863         if (array.has(index)) {
2864             return isValid(programPoint) ? array.getLongOptimistic(key, programPoint) : array.getLong(key);
2865         }
2866 
2867         return getLong(index, JSType.toString(key), programPoint);
2868     }
2869 
2870     private double getDouble(final int index, final String key, final int programPoint) {
2871         if (isValidArrayIndex(index)) {
2872             for (ScriptObject object = this; ; ) {
2873                 if (object.getMap().containsArrayKeys()) {
2874                     final FindProperty find = object.findProperty(key, false, this);
2875                     if (find != null) {
2876                         return getDoubleValue(find, programPoint);
2877                     }
2878                 }
2879 
2880                 if ((object = object.getProto()) == null) {
2881                     break;
2882                 }
2883 
2884                 final ArrayData array = object.getArray();
2885 
2886                 if (array.has(index)) {
2887                     return isValid(programPoint) ?
2888                         array.getDoubleOptimistic(index, programPoint) :
2889                         array.getDouble(index);
2890                 }
2891             }
2892         } else {
2893             final FindProperty find = findProperty(key, true);
2894 
2895             if (find != null) {
2896                 return getDoubleValue(find, programPoint);
2897             }
2898         }
2899 
2900         return JSType.toNumber(invokeNoSuchProperty(key, INVALID_PROGRAM_POINT));
2901     }
2902 
2903     @Override
2904     public double getDouble(final Object key, final int programPoint) {
2905         final Object    primitiveKey = JSType.toPrimitive(key, String.class);
2906         final int       index        = getArrayIndex(primitiveKey);
2907         final ArrayData array        = getArray();
2908 
2909         if (array.has(index)) {
2910             return isValid(programPoint) ? array.getDoubleOptimistic(index, programPoint) : array.getDouble(index);
2911         }
2912 
2913         return getDouble(index, JSType.toString(primitiveKey), programPoint);
2914     }
2915 
2916     @Override
2917     public double getDouble(final double key, final int programPoint) {
2918         final int       index = getArrayIndex(key);
2919         final ArrayData array = getArray();
2920 
2921         if (array.has(index)) {
2922             return isValid(programPoint) ? array.getDoubleOptimistic(index, programPoint) : array.getDouble(index);
2923         }
2924 
2925         return getDouble(index, JSType.toString(key), programPoint);
2926     }
2927 
2928     @Override
2929     public double getDouble(final long key, final int programPoint) {
2930         final int       index = getArrayIndex(key);
2931         final ArrayData array = getArray();
2932 
2933         if (array.has(index)) {
2934             return isValid(programPoint) ? array.getDoubleOptimistic(index, programPoint) : array.getDouble(index);
2935         }
2936 
2937         return getDouble(index, JSType.toString(key), programPoint);
2938     }
2939 
2940     @Override
2941     public double getDouble(final int key, final int programPoint) {
2942         final int       index = getArrayIndex(key);
2943         final ArrayData array = getArray();
2944 
2945         if (array.has(index)) {
2946             return isValid(programPoint) ? array.getDoubleOptimistic(key, programPoint) : array.getDouble(key);
2947         }
2948 
2949         return getDouble(index, JSType.toString(key), programPoint);
2950     }
2951 
2952     private Object get(final int index, final String key) {
2953         if (isValidArrayIndex(index)) {
2954             for (ScriptObject object = this; ; ) {
2955                 if (object.getMap().containsArrayKeys()) {
2956                     final FindProperty find = object.findProperty(key, false, this);
2957 
2958                     if (find != null) {
2959                         return find.getObjectValue();
2960                     }
2961                 }
2962 
2963                 if ((object = object.getProto()) == null) {
2964                     break;
2965                 }
2966 
2967                 final ArrayData array = object.getArray();
2968 
2969                 if (array.has(index)) {
2970                     return array.getObject(index);
2971                 }
2972             }
2973         } else {
2974             final FindProperty find = findProperty(key, true);
2975 
2976             if (find != null) {
2977                 return find.getObjectValue();
2978             }
2979         }
2980 
2981         return invokeNoSuchProperty(key, INVALID_PROGRAM_POINT);
2982     }
2983 
2984     @Override
2985     public Object get(final Object key) {
2986         final Object    primitiveKey = JSType.toPrimitive(key, String.class);
2987         final int       index        = getArrayIndex(primitiveKey);
2988         final ArrayData array        = getArray();
2989 
2990         if (array.has(index)) {
2991             return array.getObject(index);
2992         }
2993 
2994         return get(index, JSType.toString(primitiveKey));
2995     }
2996 
2997     @Override
2998     public Object get(final double key) {
2999         final int index = getArrayIndex(key);
3000         final ArrayData array = getArray();
3001 
3002         if (array.has(index)) {
3003             return array.getObject(index);
3004         }
3005 
3006         return get(index, JSType.toString(key));
3007     }
3008 
3009     @Override
3010     public Object get(final long key) {
3011         final int index = getArrayIndex(key);
3012         final ArrayData array = getArray();
3013 
3014         if (array.has(index)) {
3015             return array.getObject(index);
3016         }
3017 
3018         return get(index, JSType.toString(key));
3019     }
3020 
3021     @Override
3022     public Object get(final int key) {
3023         final int index = getArrayIndex(key);
3024         final ArrayData array = getArray();
3025 
3026         if (array.has(index)) {
3027             return array.getObject(index);
3028         }
3029 
3030         return get(index, JSType.toString(key));
3031     }
3032 
3033     private boolean doesNotHaveCheckArrayKeys(final long longIndex, final int value, final int callSiteFlags) {
3034         if (getMap().containsArrayKeys()) {
3035             final String       key  = JSType.toString(longIndex);
3036             final FindProperty find = findProperty(key, true);
3037             if (find != null) {
3038                 setObject(find, callSiteFlags, key, value);
3039                 return true;
3040             }
3041         }
3042         return false;
3043     }
3044 
3045     private boolean doesNotHaveCheckArrayKeys(final long longIndex, final long value, final int callSiteFlags) {
3046         if (getMap().containsArrayKeys()) {
3047             final String       key  = JSType.toString(longIndex);
3048             final FindProperty find = findProperty(key, true);
3049             if (find != null) {
3050                 setObject(find, callSiteFlags, key, value);
3051                 return true;
3052             }
3053         }
3054         return false;
3055     }
3056 
3057     private boolean doesNotHaveCheckArrayKeys(final long longIndex, final double value, final int callSiteFlags) {
3058          if (getMap().containsArrayKeys()) {
3059             final String       key  = JSType.toString(longIndex);
3060             final FindProperty find = findProperty(key, true);
3061             if (find != null) {
3062                 setObject(find, callSiteFlags, key, value);
3063                 return true;
3064             }
3065         }
3066         return false;
3067     }
3068 
3069     private boolean doesNotHaveCheckArrayKeys(final long longIndex, final Object value, final int callSiteFlags) {
3070         if (getMap().containsArrayKeys()) {
3071             final String       key  = JSType.toString(longIndex);
3072             final FindProperty find = findProperty(key, true);
3073             if (find != null) {
3074                 setObject(find, callSiteFlags, key, value);
3075                 return true;
3076             }
3077         }
3078         return false;
3079     }
3080 
3081     //value agnostic
3082     private boolean doesNotHaveEnsureLength(final long longIndex, final long oldLength, final int callSiteFlags) {
3083         if (longIndex >= oldLength) {
3084             if (!isExtensible()) {
3085                 if (isStrictFlag(callSiteFlags)) {
3086                     throw typeError("object.non.extensible", JSType.toString(longIndex), ScriptRuntime.safeToString(this));
3087                 }
3088                 return true;
3089             }
3090             setArray(getArray().ensure(longIndex));
3091         }
3092         return false;
3093     }
3094 
3095     private void doesNotHaveEnsureDelete(final long longIndex, final long oldLength, final boolean strict) {
3096         if (longIndex > oldLength) {
3097             ArrayData array = getArray();
3098             if (array.canDelete(oldLength, longIndex - 1, strict)) {
3099                 array = array.delete(oldLength, longIndex - 1);
3100             }
3101             setArray(array);
3102         }
3103     }
3104 
3105     private void doesNotHave(final int index, final int value, final int callSiteFlags) {
3106         final long oldLength = getArray().length();
3107         final long longIndex = ArrayIndex.toLongIndex(index);
3108         if (!doesNotHaveCheckArrayKeys(longIndex, value, callSiteFlags) && !doesNotHaveEnsureLength(longIndex, oldLength, callSiteFlags)) {
3109             final boolean strict = isStrictFlag(callSiteFlags);
3110             setArray(getArray().set(index, value, strict));
3111             doesNotHaveEnsureDelete(longIndex, oldLength, strict);
3112         }
3113     }
3114 
3115     private void doesNotHave(final int index, final long value, final int callSiteFlags) {
3116         final long oldLength = getArray().length();
3117         final long longIndex = ArrayIndex.toLongIndex(index);
3118         if (!doesNotHaveCheckArrayKeys(longIndex, value, callSiteFlags) && !doesNotHaveEnsureLength(longIndex, oldLength, callSiteFlags)) {
3119             final boolean strict = isStrictFlag(callSiteFlags);
3120             setArray(getArray().set(index, value, strict));
3121             doesNotHaveEnsureDelete(longIndex, oldLength, strict);
3122         }
3123     }
3124 
3125     private void doesNotHave(final int index, final double value, final int callSiteFlags) {
3126         final long oldLength = getArray().length();
3127         final long longIndex = ArrayIndex.toLongIndex(index);
3128         if (!doesNotHaveCheckArrayKeys(longIndex, value, callSiteFlags) && !doesNotHaveEnsureLength(longIndex, oldLength, callSiteFlags)) {
3129             final boolean strict = isStrictFlag(callSiteFlags);
3130             setArray(getArray().set(index, value, strict));
3131             doesNotHaveEnsureDelete(longIndex, oldLength, strict);
3132         }
3133     }
3134 
3135     private void doesNotHave(final int index, final Object value, final int callSiteFlags) {
3136         final long oldLength = getArray().length();
3137         final long longIndex = ArrayIndex.toLongIndex(index);
3138         if (!doesNotHaveCheckArrayKeys(longIndex, value, callSiteFlags) && !doesNotHaveEnsureLength(longIndex, oldLength, callSiteFlags)) {
3139             final boolean strict = isStrictFlag(callSiteFlags);
3140             setArray(getArray().set(index, value, strict));
3141             doesNotHaveEnsureDelete(longIndex, oldLength, strict);
3142         }
3143     }
3144 
3145     /**
3146      * This is the most generic of all Object setters. Most of the others use this in some form.
3147      * TODO: should be further specialized
3148      *
3149      * @param find          found property
3150      * @param callSiteFlags callsite flags
3151      * @param key           property key
3152      * @param value         property value
3153      */
3154     public final void setObject(final FindProperty find, final int callSiteFlags, final String key, final Object value) {
3155         FindProperty f = find;
3156 
3157         invalidateGlobalConstant(key);
3158 
3159         if (f != null && f.isInherited() && !(f.getProperty() instanceof UserAccessorProperty)) {
3160             final boolean isScope = isScopeFlag(callSiteFlags);
3161             // If the start object of the find is not this object it means the property was found inside a
3162             // 'with' statement expression (see WithObject.findProperty()). In this case we forward the 'set'
3163             // to the 'with' object.
3164             // Note that although a 'set' operation involving a with statement follows scope rules outside
3165             // the 'with' expression (the 'set' operation is performed on the owning prototype if it exists),
3166             // it follows non-scope rules inside the 'with' expression (set is performed on the top level object).
3167             // This is why we clear the callsite flags and FindProperty in the forward call to the 'with' object.
3168             if (isScope && f.getSelf() != this) {
3169                 f.getSelf().setObject(null, 0, key, value);
3170                 return;
3171             }
3172             // Setting a property should not modify the property in prototype unless this is a scope callsite
3173             // and the owner is a scope object as well (with the exception of 'with' statement handled above).
3174             if (!isScope || !f.getOwner().isScope()) {
3175                 f = null;
3176             }
3177         }
3178 
3179         if (f != null) {
3180             if (!f.getProperty().isWritable()) {
3181                 if (isScopeFlag(callSiteFlags) && f.getProperty().isLexicalBinding()) {
3182                     throw typeError("assign.constant", key); // Overwriting ES6 const should throw also in non-strict mode.
3183                 }
3184                 if (isStrictFlag(callSiteFlags)) {
3185                     throw typeError("property.not.writable", key, ScriptRuntime.safeToString(this));
3186                 }
3187                 return;
3188             }
3189 
3190             f.setValue(value, isStrictFlag(callSiteFlags));
3191 
3192         } else if (!isExtensible()) {
3193             if (isStrictFlag(callSiteFlags)) {
3194                 throw typeError("object.non.extensible", key, ScriptRuntime.safeToString(this));
3195             }
3196         } else {
3197             ScriptObject sobj = this;
3198             // undefined scope properties are set in the global object.
3199             if (isScope()) {
3200                 while (sobj != null && !(sobj instanceof Global)) {
3201                     sobj = sobj.getProto();
3202                 }
3203                 assert sobj != null : "no parent global object in scope";
3204             }
3205             //this will unbox any Number object to its primitive type in case the
3206             //property supports primitive types, so it doesn't matter that it comes
3207             //in as an Object.
3208             sobj.addSpillProperty(key, 0, value, true);
3209         }
3210     }
3211 
3212     @Override
3213     public void set(final Object key, final int value, final int callSiteFlags) {
3214         final Object primitiveKey = JSType.toPrimitive(key, String.class);
3215         final int    index        = getArrayIndex(primitiveKey);
3216 
3217         if (isValidArrayIndex(index)) {
3218             final ArrayData data = getArray();
3219             if (data.has(index)) {
3220                 setArray(data.set(index, value, isStrictFlag(callSiteFlags)));
3221             } else {
3222                 doesNotHave(index, value, callSiteFlags);
3223             }
3224 
3225             return;
3226         }
3227 
3228         final String propName = JSType.toString(primitiveKey);
3229         setObject(findProperty(propName, true), callSiteFlags, propName, JSType.toObject(value));
3230     }
3231 
3232     @Override
3233     public void set(final Object key, final long value, final int callSiteFlags) {
3234         final Object primitiveKey = JSType.toPrimitive(key, String.class);
3235         final int    index        = getArrayIndex(primitiveKey);
3236 
3237         if (isValidArrayIndex(index)) {
3238             final ArrayData data = getArray();
3239             if (data.has(index)) {
3240                 setArray(data.set(index, value, isStrictFlag(callSiteFlags)));
3241             } else {
3242                 doesNotHave(index, value, callSiteFlags);
3243             }
3244 
3245             return;
3246         }
3247 
3248         final String propName = JSType.toString(primitiveKey);
3249         setObject(findProperty(propName, true), callSiteFlags, propName, JSType.toObject(value));
3250     }
3251 
3252     @Override
3253     public void set(final Object key, final double value, final int callSiteFlags) {
3254         final Object primitiveKey = JSType.toPrimitive(key, String.class);
3255         final int    index        = getArrayIndex(primitiveKey);
3256 
3257         if (isValidArrayIndex(index)) {
3258             final ArrayData data = getArray();
3259             if (data.has(index)) {
3260                 setArray(data.set(index, value, isStrictFlag(callSiteFlags)));
3261             } else {
3262                 doesNotHave(index, value, callSiteFlags);
3263             }
3264 
3265             return;
3266         }
3267 
3268         final String propName = JSType.toString(primitiveKey);
3269         setObject(findProperty(propName, true), callSiteFlags, propName, JSType.toObject(value));
3270     }
3271 
3272     @Override
3273     public void set(final Object key, final Object value, final int callSiteFlags) {
3274         final Object primitiveKey = JSType.toPrimitive(key, String.class);
3275         final int    index        = getArrayIndex(primitiveKey);
3276 
3277         if (isValidArrayIndex(index)) {
3278             final ArrayData data = getArray();
3279             if (data.has(index)) {
3280                 setArray(data.set(index, value, isStrictFlag(callSiteFlags)));
3281             } else {
3282                 doesNotHave(index, value, callSiteFlags);
3283             }
3284 
3285             return;
3286         }
3287 
3288         final String propName = JSType.toString(primitiveKey);
3289         setObject(findProperty(propName, true), callSiteFlags, propName, value);
3290     }
3291 
3292     @Override
3293     public void set(final double key, final int value, final int callSiteFlags) {
3294         final int index = getArrayIndex(key);
3295 
3296         if (isValidArrayIndex(index)) {
3297             final ArrayData data = getArray();
3298             if (data.has(index)) {
3299                 setArray(data.set(index, value, isStrictFlag(callSiteFlags)));
3300             } else {
3301                 doesNotHave(index, value, callSiteFlags);
3302             }
3303 
3304             return;
3305         }
3306 
3307         final String propName = JSType.toString(key);
3308         setObject(findProperty(propName, true), callSiteFlags, propName, JSType.toObject(value));
3309     }
3310 
3311     @Override
3312     public void set(final double key, final long value, final int callSiteFlags) {
3313         final int index = getArrayIndex(key);
3314 
3315         if (isValidArrayIndex(index)) {
3316             final ArrayData data = getArray();
3317             if (data.has(index)) {
3318                 setArray(data.set(index, value, isStrictFlag(callSiteFlags)));
3319             } else {
3320                 doesNotHave(index, value, callSiteFlags);
3321             }
3322 
3323             return;
3324         }
3325 
3326         final String propName = JSType.toString(key);
3327         setObject(findProperty(propName, true), callSiteFlags, propName, JSType.toObject(value));
3328     }
3329 
3330     @Override
3331     public void set(final double key, final double value, final int callSiteFlags) {
3332         final int index = getArrayIndex(key);
3333 
3334         if (isValidArrayIndex(index)) {
3335             final ArrayData data = getArray();
3336             if (data.has(index)) {
3337                 setArray(data.set(index, value, isStrictFlag(callSiteFlags)));
3338             } else {
3339                 doesNotHave(index, value, callSiteFlags);
3340             }
3341 
3342             return;
3343         }
3344 
3345         final String propName = JSType.toString(key);
3346         setObject(findProperty(propName, true), callSiteFlags, propName, JSType.toObject(value));
3347     }
3348 
3349     @Override
3350     public void set(final double key, final Object value, final int callSiteFlags) {
3351         final int index = getArrayIndex(key);
3352 
3353         if (isValidArrayIndex(index)) {
3354             final ArrayData data = getArray();
3355             if (data.has(index)) {
3356                 setArray(data.set(index, value, isStrictFlag(callSiteFlags)));
3357             } else {
3358                 doesNotHave(index, value, callSiteFlags);
3359             }
3360 
3361             return;
3362         }
3363 
3364         final String propName = JSType.toString(key);
3365         setObject(findProperty(propName, true), callSiteFlags, propName, value);
3366     }
3367 
3368     @Override
3369     public void set(final long key, final int value, final int callSiteFlags) {
3370         final int index = getArrayIndex(key);
3371 
3372         if (isValidArrayIndex(index)) {
3373             final ArrayData data = getArray();
3374             if (data.has(index)) {
3375                 setArray(data.set(index, value, isStrictFlag(callSiteFlags)));
3376             } else {
3377                 doesNotHave(index, value, callSiteFlags);
3378             }
3379 
3380             return;
3381         }
3382 
3383         final String propName = JSType.toString(key);
3384         setObject(findProperty(propName, true), callSiteFlags, propName, JSType.toObject(value));
3385     }
3386 
3387     @Override
3388     public void set(final long key, final long value, final int callSiteFlags) {
3389         final int index = getArrayIndex(key);
3390 
3391         if (isValidArrayIndex(index)) {
3392             final ArrayData data = getArray();
3393             if (data.has(index)) {
3394                 setArray(data.set(index, value, isStrictFlag(callSiteFlags)));
3395             } else {
3396                 doesNotHave(index, value, callSiteFlags);
3397             }
3398 
3399             return;
3400         }
3401 
3402         final String propName = JSType.toString(key);
3403         setObject(findProperty(propName, true), callSiteFlags, propName, JSType.toObject(value));
3404     }
3405 
3406     @Override
3407     public void set(final long key, final double value, final int callSiteFlags) {
3408         final int index = getArrayIndex(key);
3409 
3410         if (isValidArrayIndex(index)) {
3411             final ArrayData data = getArray();
3412             if (data.has(index)) {
3413                 setArray(data.set(index, value, isStrictFlag(callSiteFlags)));
3414             } else {
3415                 doesNotHave(index, value, callSiteFlags);
3416             }
3417 
3418             return;
3419         }
3420 
3421         final String propName = JSType.toString(key);
3422         setObject(findProperty(propName, true), callSiteFlags, propName, JSType.toObject(value));
3423     }
3424 
3425     @Override
3426     public void set(final long key, final Object value, final int callSiteFlags) {
3427         final int index = getArrayIndex(key);
3428 
3429         if (isValidArrayIndex(index)) {
3430             final ArrayData data = getArray();
3431             if (data.has(index)) {
3432                 setArray(data.set(index, value, isStrictFlag(callSiteFlags)));
3433             } else {
3434                 doesNotHave(index, value, callSiteFlags);
3435             }
3436 
3437             return;
3438         }
3439 
3440         final String propName = JSType.toString(key);
3441         setObject(findProperty(propName, true), callSiteFlags, propName, value);
3442     }
3443 
3444     @Override
3445     public void set(final int key, final int value, final int callSiteFlags) {
3446         final int index = getArrayIndex(key);
3447         if (isValidArrayIndex(index)) {
3448             if (getArray().has(index)) {
3449                 final ArrayData data = getArray();
3450                 setArray(data.set(index, value, isStrictFlag(callSiteFlags)));
3451             } else {
3452                 doesNotHave(index, value, callSiteFlags);
3453             }
3454             return;
3455         }
3456 
3457         final String propName = JSType.toString(key);
3458         setObject(findProperty(propName, true), callSiteFlags, propName, JSType.toObject(value));
3459     }
3460 
3461     @Override
3462     public void set(final int key, final long value, final int callSiteFlags) {
3463         final int index = getArrayIndex(key);
3464 
3465         if (isValidArrayIndex(index)) {
3466             final ArrayData data = getArray();
3467             if (data.has(index)) {
3468                 setArray(data.set(index, value, isStrictFlag(callSiteFlags)));
3469             } else {
3470                 doesNotHave(index, value, callSiteFlags);
3471             }
3472 
3473             return;
3474         }
3475 
3476         final String propName = JSType.toString(key);
3477         setObject(findProperty(propName, true), callSiteFlags, propName, JSType.toObject(value));
3478     }
3479 
3480     @Override
3481     public void set(final int key, final double value, final int callSiteFlags) {
3482         final int index = getArrayIndex(key);
3483 
3484         if (isValidArrayIndex(index)) {
3485             final ArrayData data = getArray();
3486             if (data.has(index)) {
3487                 setArray(data.set(index, value, isStrictFlag(callSiteFlags)));
3488             } else {
3489                 doesNotHave(index, value, callSiteFlags);
3490             }
3491 
3492             return;
3493         }
3494 
3495         final String propName = JSType.toString(key);
3496         setObject(findProperty(propName, true), callSiteFlags, propName, JSType.toObject(value));
3497     }
3498 
3499     @Override
3500     public void set(final int key, final Object value, final int callSiteFlags) {
3501         final int index = getArrayIndex(key);
3502 
3503         if (isValidArrayIndex(index)) {
3504             final ArrayData data = getArray();
3505             if (data.has(index)) {
3506                 setArray(data.set(index, value, isStrictFlag(callSiteFlags)));
3507             } else {
3508                 doesNotHave(index, value, callSiteFlags);
3509             }
3510 
3511             return;
3512         }
3513 
3514         final String propName = JSType.toString(key);
3515         setObject(findProperty(propName, true), callSiteFlags, propName, value);
3516     }
3517 
3518     @Override
3519     public boolean has(final Object key) {
3520         final Object primitiveKey = JSType.toPrimitive(key);
3521         final int    index        = getArrayIndex(primitiveKey);
3522         return isValidArrayIndex(index) ? hasArrayProperty(index) : hasProperty(JSType.toString(primitiveKey), true);
3523     }
3524 
3525     @Override
3526     public boolean has(final double key) {
3527         final int index = getArrayIndex(key);
3528         return isValidArrayIndex(index) ? hasArrayProperty(index) : hasProperty(JSType.toString(key), true);
3529     }
3530 
3531     @Override
3532     public boolean has(final long key) {
3533         final int index = getArrayIndex(key);
3534         return isValidArrayIndex(index) ? hasArrayProperty(index) : hasProperty(JSType.toString(key), true);
3535     }
3536 
3537     @Override
3538     public boolean has(final int key) {
3539         final int index = getArrayIndex(key);
3540         return isValidArrayIndex(index) ? hasArrayProperty(index) : hasProperty(JSType.toString(key), true);
3541     }
3542 
3543     private boolean hasArrayProperty(final int index) {
3544         boolean hasArrayKeys = false;
3545 
3546         for (ScriptObject self = this; self != null; self = self.getProto()) {
3547             if (self.getArray().has(index)) {
3548                 return true;
3549             }
3550             hasArrayKeys = hasArrayKeys || self.getMap().containsArrayKeys();
3551         }
3552 
3553         return hasArrayKeys && hasProperty(ArrayIndex.toKey(index), true);
3554     }
3555 
3556     @Override
3557     public boolean hasOwnProperty(final Object key) {
3558         final Object primitiveKey = JSType.toPrimitive(key, String.class);
3559         final int    index        = getArrayIndex(primitiveKey);
3560         return isValidArrayIndex(index) ? hasOwnArrayProperty(index) : hasProperty(JSType.toString(primitiveKey), false);
3561     }
3562 
3563     @Override
3564     public boolean hasOwnProperty(final int key) {
3565         final int index = getArrayIndex(key);
3566         return isValidArrayIndex(index) ? hasOwnArrayProperty(index) : hasProperty(JSType.toString(key), false);
3567     }
3568 
3569     @Override
3570     public boolean hasOwnProperty(final long key) {
3571         final int index = getArrayIndex(key);
3572         return isValidArrayIndex(index) ? hasOwnArrayProperty(index) : hasProperty(JSType.toString(key), false);
3573     }
3574 
3575     @Override
3576     public boolean hasOwnProperty(final double key) {
3577         final int index = getArrayIndex(key);
3578         return isValidArrayIndex(index) ? hasOwnArrayProperty(index) : hasProperty(JSType.toString(key), false);
3579     }
3580 
3581     private boolean hasOwnArrayProperty(final int index) {
3582         return getArray().has(index) || getMap().containsArrayKeys() && hasProperty(ArrayIndex.toKey(index), false);
3583     }
3584 
3585     @Override
3586     public boolean delete(final int key, final boolean strict) {
3587         final int index = getArrayIndex(key);
3588         final ArrayData array = getArray();
3589 
3590         if (array.has(index)) {
3591             if (array.canDelete(index, strict)) {
3592                 setArray(array.delete(index));
3593                 return true;
3594             }
3595             return false;
3596         }
3597         return deleteObject(JSType.toObject(key), strict);
3598     }
3599 
3600     @Override
3601     public boolean delete(final long key, final boolean strict) {
3602         final int index = getArrayIndex(key);
3603         final ArrayData array = getArray();
3604 
3605         if (array.has(index)) {
3606             if (array.canDelete(index, strict)) {
3607                 setArray(array.delete(index));
3608                 return true;
3609             }
3610             return false;
3611         }
3612 
3613         return deleteObject(JSType.toObject(key), strict);
3614     }
3615 
3616     @Override
3617     public boolean delete(final double key, final boolean strict) {
3618         final int index = getArrayIndex(key);
3619         final ArrayData array = getArray();
3620 
3621         if (array.has(index)) {
3622             if (array.canDelete(index, strict)) {
3623                 setArray(array.delete(index));
3624                 return true;
3625             }
3626             return false;
3627         }
3628 
3629         return deleteObject(JSType.toObject(key), strict);
3630     }
3631 
3632     @Override
3633     public boolean delete(final Object key, final boolean strict) {
3634         final Object    primitiveKey = JSType.toPrimitive(key, String.class);
3635         final int       index        = getArrayIndex(primitiveKey);
3636         final ArrayData array        = getArray();
3637 
3638         if (array.has(index)) {
3639             if (array.canDelete(index, strict)) {
3640                 setArray(array.delete(index));
3641                 return true;
3642             }
3643             return false;
3644         }
3645 
3646         return deleteObject(primitiveKey, strict);
3647     }
3648 
3649     private boolean deleteObject(final Object key, final boolean strict) {
3650         final String propName = JSType.toString(key);
3651         final FindProperty find = findProperty(propName, false);
3652 
3653         if (find == null) {
3654             return true;
3655         }
3656 
3657         if (!find.getProperty().isConfigurable()) {
3658             if (strict) {
3659                 throw typeError("cant.delete.property", propName, ScriptRuntime.safeToString(this));
3660             }
3661             return false;
3662         }
3663 
3664         final Property prop = find.getProperty();
3665         deleteOwnProperty(prop);
3666 
3667         return true;
3668     }
3669 
3670     /**
3671      * Return a shallow copy of this ScriptObject.
3672      * @return a shallow copy.
3673      */
3674     public final ScriptObject copy() {
3675         try {
3676             return clone();
3677         } catch (final CloneNotSupportedException e) {
3678             throw new RuntimeException(e);
3679         }
3680     }
3681 
3682     @Override
3683     protected ScriptObject clone() throws CloneNotSupportedException {
3684         final ScriptObject clone = (ScriptObject) super.clone();
3685         if (objectSpill != null) {
3686             clone.objectSpill = objectSpill.clone();
3687             if (primitiveSpill != null) {
3688                 clone.primitiveSpill = primitiveSpill.clone();
3689             }
3690         }
3691         clone.arrayData = arrayData.copy();
3692         return clone;
3693     }
3694 
3695     /**
3696      * Make a new UserAccessorProperty property. getter and setter functions are stored in
3697      * this ScriptObject and slot values are used in property object.
3698      *
3699      * @param key the property name
3700      * @param propertyFlags attribute flags of the property
3701      * @param getter getter function for the property
3702      * @param setter setter function for the property
3703      * @return the newly created UserAccessorProperty
3704      */
3705     protected final UserAccessorProperty newUserAccessors(final String key, final int propertyFlags, final ScriptFunction getter, final ScriptFunction setter) {
3706         final UserAccessorProperty uc = getMap().newUserAccessors(key, propertyFlags);
3707         //property.getSetter(Object.class, getMap());
3708         uc.setAccessors(this, getMap(), new UserAccessorProperty.Accessors(getter, setter));
3709         return uc;
3710     }
3711 
3712     /**
3713      * Returns {@code true} if properties for this object should use dual field mode, {@code false} otherwise.
3714      * @return {@code true} if dual fields should be used.
3715      */
3716     protected boolean useDualFields() {
3717         return !StructureLoader.isSingleFieldStructure(getClass().getName());
3718     }
3719 
3720     Object ensureSpillSize(final int slot) {
3721         final int oldLength = objectSpill == null ? 0 : objectSpill.length;
3722         if (slot < oldLength) {
3723             return this;
3724         }
3725         final int newLength = alignUp(slot + 1, SPILL_RATE);
3726         final Object[] newObjectSpill    = new Object[newLength];
3727         final long[]   newPrimitiveSpill = useDualFields() ? new long[newLength] : null;
3728 
3729         if (objectSpill != null) {
3730             System.arraycopy(objectSpill, 0, newObjectSpill, 0, oldLength);
3731             if (primitiveSpill != null && newPrimitiveSpill != null) {
3732                 System.arraycopy(primitiveSpill, 0, newPrimitiveSpill, 0, oldLength);
3733             }
3734         }
3735 
3736         this.primitiveSpill = newPrimitiveSpill;
3737         this.objectSpill    = newObjectSpill;
3738 
3739         return this;
3740     }
3741 
3742     private static MethodHandle findOwnMH_V(final Class<? extends ScriptObject> clazz, final String name, final Class<?> rtype, final Class<?>... types) {
3743         // TODO: figure out how can it work for NativeArray$Prototype etc.
3744         return MH.findVirtual(MethodHandles.lookup(), ScriptObject.class, name, MH.type(rtype, types));
3745     }
3746 
3747     private static MethodHandle findOwnMH_V(final String name, final Class<?> rtype, final Class<?>... types) {
3748         return findOwnMH_V(ScriptObject.class, name, rtype, types);
3749     }
3750 
3751     private static MethodHandle findOwnMH_S(final String name, final Class<?> rtype, final Class<?>... types) {
3752         return MH.findStatic(MethodHandles.lookup(), ScriptObject.class, name, MH.type(rtype, types));
3753     }
3754 
3755     private static MethodHandle getKnownFunctionPropertyGuardSelf(final PropertyMap map, final MethodHandle getter, final ScriptFunction func) {
3756         return MH.insertArguments(KNOWNFUNCPROPGUARDSELF, 1, map, getter, func);
3757     }
3758 
3759     @SuppressWarnings("unused")
3760     private static boolean knownFunctionPropertyGuardSelf(final Object self, final PropertyMap map, final MethodHandle getter, final ScriptFunction func) {
3761         if (self instanceof ScriptObject && ((ScriptObject)self).getMap() == map) {
3762             try {
3763                 return getter.invokeExact(self) == func;
3764             } catch (final RuntimeException | Error e) {
3765                 throw e;
3766             } catch (final Throwable t) {
3767                 throw new RuntimeException(t);
3768             }
3769         }
3770 
3771         return false;
3772     }
3773 
3774     private static MethodHandle getKnownFunctionPropertyGuardProto(final PropertyMap map, final MethodHandle getter, final int depth, final ScriptFunction func) {
3775         return MH.insertArguments(KNOWNFUNCPROPGUARDPROTO, 1, map, getter, depth, func);
3776     }
3777 
3778     private static ScriptObject getProto(final ScriptObject self, final int depth) {
3779         ScriptObject proto = self;
3780         for (int d = 0; d < depth; d++) {
3781             proto = proto.getProto();
3782             if (proto == null) {
3783                 return null;
3784             }
3785         }
3786 
3787         return proto;
3788     }
3789 
3790     @SuppressWarnings("unused")
3791     private static boolean knownFunctionPropertyGuardProto(final Object self, final PropertyMap map, final MethodHandle getter, final int depth, final ScriptFunction func) {
3792         if (self instanceof ScriptObject && ((ScriptObject)self).getMap() == map) {
3793             final ScriptObject proto = getProto((ScriptObject)self, depth);
3794             if (proto == null) {
3795                 return false;
3796             }
3797             try {
3798                 return getter.invokeExact((Object)proto) == func;
3799             } catch (final RuntimeException | Error e) {
3800                 throw e;
3801             } catch (final Throwable t) {
3802                 throw new RuntimeException(t);
3803             }
3804         }
3805 
3806         return false;
3807     }
3808 
3809     /** This is updated only in debug mode - counts number of {@code ScriptObject} instances created */
3810     private static int count;
3811 
3812     /** This is updated only in debug mode - counts number of {@code ScriptObject} instances created that are scope */
3813     private static int scopeCount;
3814 
3815     /**
3816      * Get number of {@code ScriptObject} instances created. If not running in debug
3817      * mode this is always 0
3818      *
3819      * @return number of ScriptObjects created
3820      */
3821     public static int getCount() {
3822         return count;
3823     }
3824 
3825     /**
3826      * Get number of scope {@code ScriptObject} instances created. If not running in debug
3827      * mode this is always 0
3828      *
3829      * @return number of scope ScriptObjects created
3830      */
3831     public static int getScopeCount() {
3832         return scopeCount;
3833     }
3834 
3835 }
--- EOF ---