prepack/lib/values/ObjectValue.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _index = require("../domains/index.js");

var _errors = require("../errors.js");

var _index2 = require("./index.js");

var _utils = require("../react/utils.js");

var _builder = _interopRequireDefault(require("../utils/builder.js"));

var _index3 = require("../methods/index.js");

var _singletons = require("../singletons.js");

var _invariant = _interopRequireDefault(require("../invariant.js"));

var _generator = require("../utils/generator.js");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function isWidenedValue(v) {
  if (!(v instanceof _index2.AbstractValue)) return false;
  if (v.kind === "widened" || v.kind === "widened property") return true;

  for (let a of v.args) {
    if (isWidenedValue(a)) return true;
  }

  return false;
}

const lengthTemplateSrc = "(A).length";
const lengthTemplate = (0, _builder.default)(lengthTemplateSrc);

class ObjectValue extends _index2.ConcreteValue {
  constructor(realm, proto, intrinsicName, refuseSerialization = false) {
    super(realm, intrinsicName);
    realm.recordNewObject(this);
    if (realm.useAbstractInterpretation) this.setupBindings(this.getTrackedPropertyNames());
    this.$Prototype = proto || realm.intrinsics.null;
    this.$Extensible = realm.intrinsics.true;
    this._isPartial = realm.intrinsics.false;
    this._isHavoced = realm.intrinsics.false;
    this._isSimple = realm.intrinsics.false;
    this._simplicityIsTransitive = realm.intrinsics.false;
    this._isFinal = realm.intrinsics.false;
    this.properties = new Map();
    this.symbols = new Map();
    this.refuseSerialization = refuseSerialization; // this.$IsClassPrototype should be the last thing that gets initialized,
    // as other code checks whether this.$IsClassPrototype === undefined
    // as a proxy for whether initialization is still ongoing.

    this.$IsClassPrototype = false;
  }

  getTrackedPropertyNames() {
    return ObjectValue.trackedPropertyNames;
  }

  setupBindings(propertyNames) {
    for (let propName of propertyNames) {
      let propBindingName = ObjectValue.trackedPropertyBindingNames.get(propName);
      (0, _invariant.default)(propBindingName !== undefined);
      this[propBindingName] = undefined;
    }
  }

  static setupTrackedPropertyAccessors(propertyNames) {
    for (let propName of propertyNames) {
      let propBindingName = ObjectValue.trackedPropertyBindingNames.get(propName);
      if (propBindingName === undefined) ObjectValue.trackedPropertyBindingNames.set(propName, propBindingName = propName + "_binding");
      Object.defineProperty(ObjectValue.prototype, propName, {
        configurable: true,
        get: function () {
          let binding = this[propBindingName];
          return binding === undefined ? undefined : binding.descriptor.value;
        },
        set: function (v) {
          // Let's make sure that the object is not havoced.
          // To that end, we'd like to call this.isHavocedObject().
          // However, while the object is still being initialized,
          // properties may be set, but this.isHavocedObject() may not be called yet.
          // To check if we are still initializing, guard the call by looking at
          // whether this.$IsClassPrototype has been initialized as a proxy for
          // object initialization in general.
          (0, _invariant.default)( // We're still initializing so we can set a property.
          this.$IsClassPrototype === undefined || // It's not havoced so we can set a property.
          this.mightNotBeHavocedObject() || // Object.assign() implementation needs to temporarily
          // make potentially havoced objects non-partial and back.
          // We don't gain anything from checking whether it's havoced
          // before calling makePartial() so we'll whitelist this property.
          propBindingName === "_isPartial_binding", "cannot mutate a havoced object");
          let binding = this[propBindingName];

          if (binding === undefined) {
            let desc = {
              writeable: true,
              value: undefined
            };
            this[propBindingName] = binding = {
              descriptor: desc,
              object: this,
              key: propName,
              internalSlot: true
            };
          }

          this.$Realm.recordModifiedProperty(binding);
          binding.descriptor.value = v;
        }
      });
    }
  }

  equals(x) {
    return this === x;
  }

  getHash() {
    if (!this.hashValue) {
      this.hashValue = ++this.$Realm.objectCount;
    }

    return this.hashValue;
  }

  get temporalAlias() {
    return this._temporalAlias;
  }

  set temporalAlias(value) {
    this._temporalAlias = value;
  }

  hasStringOrSymbolProperties() {
    for (let prop of this.properties.values()) {
      if (prop.descriptor === undefined) continue;
      return true;
    }

    for (let prop of this.symbols.values()) {
      if (prop.descriptor === undefined) continue;
      return true;
    }

    return false;
  }

  mightBeFalse() {
    return false;
  }

  mightNotBeObject() {
    return false;
  }

  throwIfNotObject() {
    return this;
  }

  makeNotPartial() {
    this._isPartial = this.$Realm.intrinsics.false;
  }

  makePartial() {
    this._isPartial = this.$Realm.intrinsics.true;
  }

  makeSimple(option) {
    this._isSimple = this.$Realm.intrinsics.true;
    this._simplicityIsTransitive = new _index2.BooleanValue(this.$Realm, option === "transitive" || option instanceof _index2.StringValue && option.value === "transitive");
  }

  makeFinal() {
    this._isFinal = this.$Realm.intrinsics.true;
  }

  makeNotFinal() {
    this._isFinal = this.$Realm.intrinsics.false;
  }

  isPartialObject() {
    return this._isPartial.mightBeTrue();
  }

  mightBeFinalObject() {
    return this._isFinal.mightBeTrue();
  }

  mightNotBeFinalObject() {
    return this._isFinal.mightNotBeTrue();
  }

  havoc() {
    this._isHavoced = this.$Realm.intrinsics.true;
  }

  mightBeHavocedObject() {
    return this._isHavoced.mightBeTrue();
  }

  mightNotBeHavocedObject() {
    return this._isHavoced.mightNotBeTrue();
  }

  isSimpleObject() {
    if (!this._isSimple.mightNotBeTrue()) return true;
    if (this.isPartialObject()) return false;
    if (this.symbols.size > 0) return false;

    for (let propertyBinding of this.properties.values()) {
      let desc = propertyBinding.descriptor;
      if (desc === undefined) continue; // deleted

      if (!(0, _index3.IsDataDescriptor)(this.$Realm, desc)) return false;
      if (!desc.writable) return false;
    }

    if (this.$Prototype instanceof _index2.NullValue) return true;
    if (this.$Prototype === this.$Realm.intrinsics.ObjectPrototype) return true;
    (0, _invariant.default)(this.$Prototype);
    return this.$Prototype.isSimpleObject();
  }

  isTransitivelySimple() {
    return !this._simplicityIsTransitive.mightNotBeTrue();
  }

  getExtensible() {
    return this.$Extensible.throwIfNotConcreteBoolean().value;
  }

  setExtensible(v) {
    this.$Extensible = v ? this.$Realm.intrinsics.true : this.$Realm.intrinsics.false;
  }

  getKind() {
    // we can deduce the natural prototype by checking whether the following internal slots are present
    if (this.$SymbolData !== undefined) return "Symbol";
    if (this.$StringData !== undefined) return "String";
    if (this.$NumberData !== undefined) return "Number";
    if (this.$BooleanData !== undefined) return "Boolean";
    if (this.$DateValue !== undefined) return "Date";
    if (this.$RegExpMatcher !== undefined) return "RegExp";
    if (this.$SetData !== undefined) return "Set";
    if (this.$MapData !== undefined) return "Map";
    if (this.$DataView !== undefined) return "DataView";
    if (this.$ArrayBufferData !== undefined) return "ArrayBuffer";
    if (this.$WeakMapData !== undefined) return "WeakMap";
    if (this.$WeakSetData !== undefined) return "WeakSet";
    if ((0, _utils.isReactElement)(this) && this.$Realm.react.enabled) return "ReactElement";
    if (this.$TypedArrayName !== undefined) return this.$TypedArrayName; // TODO #26 #712: Promises. All kinds of iterators. Generators.

    return "Object";
  }

  defineNativeMethod(name, length, callback, desc = {}) {
    let intrinsicName;

    if (typeof name === "string") {
      if (this.intrinsicName) intrinsicName = `${this.intrinsicName}.${name}`;
    } else if (name instanceof _index2.SymbolValue) {
      if (this.intrinsicName && name.intrinsicName) intrinsicName = `${this.intrinsicName}[${name.intrinsicName}]`;
    } else {
      (0, _invariant.default)(false);
    }

    let fnValue = new _index2.NativeFunctionValue(this.$Realm, intrinsicName, name, length, callback, false);
    this.defineNativeProperty(name, fnValue, desc);
    return fnValue;
  }

  defineNativeProperty(name, value, desc = {}) {
    (0, _invariant.default)(!value || value instanceof _index2.Value);
    this.$DefineOwnProperty(name, _objectSpread({
      value,
      writable: true,
      enumerable: false,
      configurable: true
    }, desc));
  }

  defineNativeGetter(name, callback, desc = {}) {
    let intrinsicName, funcName;

    if (typeof name === "string") {
      funcName = `get ${name}`;
      if (this.intrinsicName) intrinsicName = `${this.intrinsicName}.${name}`;
    } else if (name instanceof _index2.SymbolValue) {
      funcName = name.$Description instanceof _index2.Value ? `get [${name.$Description.throwIfNotConcreteString().value}]` : `get [${"?"}]`;
      if (this.intrinsicName && name.intrinsicName) intrinsicName = `${this.intrinsicName}[${name.intrinsicName}]`;
    } else {
      (0, _invariant.default)(false);
    }

    let func = new _index2.NativeFunctionValue(this.$Realm, intrinsicName, funcName, 0, callback);
    this.$DefineOwnProperty(name, _objectSpread({
      get: func,
      set: this.$Realm.intrinsics.undefined,
      enumerable: false,
      configurable: true
    }, desc));
  }

  defineNativeConstant(name, value, desc = {}) {
    (0, _invariant.default)(!value || value instanceof _index2.Value);
    this.$DefineOwnProperty(name, _objectSpread({
      value,
      writable: false,
      enumerable: false,
      configurable: false
    }, desc));
  }

  getOwnPropertyKeysArray(allowAbstractKeys = false) {
    if (this.isPartialObject() || this.mightBeHavocedObject() || this.unknownProperty !== undefined) {
      _index2.AbstractValue.reportIntrospectionError(this);

      throw new _errors.FatalError();
    }

    let keyArray = Array.from(this.properties.keys());
    keyArray = keyArray.filter(x => {
      let pb = this.properties.get(x);
      if (!pb || pb.descriptor === undefined) return false;
      let pv = pb.descriptor.value;
      if (pv === undefined) return true;
      (0, _invariant.default)(pv instanceof _index2.Value);
      if (!pv.mightHaveBeenDeleted()) return true; // The property may or may not be there at runtime.
      // We can at best return an abstract keys array.
      // For now, unless the caller has told us that is okay,
      // just terminate.

      (0, _invariant.default)(pv instanceof _index2.AbstractValue);
      if (allowAbstractKeys) return true;

      _index2.AbstractValue.reportIntrospectionError(pv);

      throw new _errors.FatalError();
    });
    this.$Realm.callReportObjectGetOwnProperties(this);
    return keyArray;
  } // Note that internal properties will not be copied to the snapshot, nor will they be removed.


  getSnapshot(options) {
    try {
      if (this.temporalAlias !== undefined) return this.temporalAlias;
      (0, _invariant.default)(!this.isPartialObject());
      let template = new ObjectValue(this.$Realm, this.$Realm.intrinsics.ObjectPrototype);
      this.copyKeys(this.$OwnPropertyKeys(), this, template);
      let realm = this.$Realm; // The snapshot is an immutable object snapshot

      template.makeFinal(); // The original object might be a React props object, thus
      // if it is, we need to ensure we mark it with the same rules

      if (realm.react.enabled && realm.react.reactProps.has(this)) {
        realm.react.reactProps.add(template);
      }

      let operationDescriptor = (0, _generator.createOperationDescriptor)("SINGLE_ARG");

      let result = _index2.AbstractValue.createTemporalFromBuildFunction(this.$Realm, ObjectValue, [template], operationDescriptor, {
        skipInvariant: true,
        isPure: true
      });

      (0, _invariant.default)(result instanceof _index2.AbstractObjectValue);
      result.values = new _index.ValuesDomain(template);
      return result;
    } finally {
      if (options && options.removeProperties) {
        this.properties = new Map();
        this.symbols = new Map();
        this.unknownProperty = undefined;
      }
    }
  }

  copyKeys(keys, from, to) {
    // c. Repeat for each element nextKey of keys in List order,
    for (let nextKey of keys) {
      // i. Let desc be ? from.[[GetOwnProperty]](nextKey).
      let desc = from.$GetOwnProperty(nextKey); // ii. If desc is not undefined and desc.[[Enumerable]] is true, then

      if (desc && desc.enumerable) {
        _singletons.Properties.ThrowIfMightHaveBeenDeleted(desc.value); // 1. Let propValue be ? Get(from, nextKey).


        let propValue = (0, _index3.Get)(this.$Realm, from, nextKey); // 2. Perform ? Set(to, nextKey, propValue, true).

        _singletons.Properties.Set(this.$Realm, to, nextKey, propValue, true);
      }
    }
  }

  _serialize(set, stack) {
    let obj = set({});

    for (let [key, propertyBinding] of this.properties) {
      let desc = propertyBinding.descriptor;
      if (desc === undefined) continue; // deleted

      _singletons.Properties.ThrowIfMightHaveBeenDeleted(desc.value);

      let serializedDesc = {
        enumerable: desc.enumerable,
        configurable: desc.configurable
      };

      if (desc.value) {
        serializedDesc.writable = desc.writable;
        (0, _invariant.default)(desc.value instanceof _index2.Value);
        serializedDesc.value = desc.value.serialize(stack);
      } else {
        (0, _invariant.default)(desc.get !== undefined);
        serializedDesc.get = desc.get.serialize(stack);
        (0, _invariant.default)(desc.set !== undefined);
        serializedDesc.set = desc.set.serialize(stack);
      }

      Object.defineProperty(obj, key, serializedDesc);
    }

    return obj;
  } // Whether [[{Get,Set}PrototypeOf]] delegate to Ordinary{Get,Set}PrototypeOf.
  // E.g. ProxyValue overrides this to return false.
  // See ECMA262 9.1.2.1 for an algorithm where this is relevant


  usesOrdinaryObjectInternalPrototypeMethods() {
    return true;
  } // ECMA262 9.1.1


  $GetPrototypeOf() {
    return this.$Prototype;
  } // ECMA262 9.1.2


  $SetPrototypeOf(V) {
    // 1. Return ! OrdinarySetPrototypeOf(O, V).
    return _singletons.Properties.OrdinarySetPrototypeOf(this.$Realm, this, V);
  } // ECMA262 9.1.3


  $IsExtensible() {
    // 1. Return ! OrdinaryIsExtensible(O).
    return (0, _index3.OrdinaryIsExtensible)(this.$Realm, this);
  } // ECMA262 9.1.4


  $PreventExtensions() {
    // 1. Return ! OrdinaryPreventExtensions(O).
    return (0, _index3.OrdinaryPreventExtensions)(this.$Realm, this);
  } // ECMA262 9.1.5


  $GetOwnProperty(P) {
    // 1. Return ! OrdinaryGetOwnProperty(O, P).
    return _singletons.Properties.OrdinaryGetOwnProperty(this.$Realm, this, P);
  } // ECMA262 9.1.6


  $DefineOwnProperty(P, Desc) {
    // 1. Return ? OrdinaryDefineOwnProperty(O, P, Desc).
    return _singletons.Properties.OrdinaryDefineOwnProperty(this.$Realm, this, P, Desc);
  } // ECMA262 9.1.7


  $HasProperty(P) {
    if (this.unknownProperty !== undefined && this.$GetOwnProperty(P) === undefined) {
      _index2.AbstractValue.reportIntrospectionError(this, P);

      throw new _errors.FatalError();
    }

    return (0, _index3.OrdinaryHasProperty)(this.$Realm, this, P);
  } // ECMA262 9.1.8


  $Get(P, Receiver) {
    let prop = this.unknownProperty;

    if (prop !== undefined && prop.descriptor !== undefined && this.$GetOwnProperty(P) === undefined) {
      let desc = prop.descriptor;
      (0, _invariant.default)(desc !== undefined);
      let val = desc.value;
      (0, _invariant.default)(val instanceof _index2.AbstractValue);
      let propValue;

      if (P instanceof _index2.StringValue) {
        propValue = P;
      } else if (typeof P === "string") {
        propValue = new _index2.StringValue(this.$Realm, P);
      }

      if (val.kind === "widened numeric property") {
        (0, _invariant.default)(Receiver instanceof _index2.ArrayValue && _index2.ArrayValue.isIntrinsicAndHasWidenedNumericProperty(Receiver));
        let propName;

        if (P instanceof _index2.StringValue) {
          propName = P.value;
        } else {
          propName = P;
        }

        return (0, _index3.GetFromArrayWithWidenedNumericProperty)(this.$Realm, Receiver, propName);
      } else if (!propValue) {
        _index2.AbstractValue.reportIntrospectionError(val, "abstract computed property name");

        throw new _errors.FatalError();
      }

      return this.specializeJoin(val, propValue);
    } // 1. Return ? OrdinaryGet(O, P, Receiver).


    return (0, _index3.OrdinaryGet)(this.$Realm, this, P, Receiver);
  }

  _SafeGetDataPropertyValue(P) {
    let savedInvariantLevel = this.$Realm.invariantLevel;

    try {
      this.$Realm.invariantLevel = 0;
      let desc = this.$GetOwnProperty(P);
      return desc !== undefined && desc.value instanceof _index2.Value ? desc.value : this.$Realm.intrinsics.undefined;
    } finally {
      this.$Realm.invariantLevel = savedInvariantLevel;
    }
  }

  $GetPartial(P, Receiver) {
    if (Receiver instanceof _index2.AbstractValue && Receiver.getType() === _index2.StringValue && P === "length") {
      return _index2.AbstractValue.createFromTemplate(this.$Realm, lengthTemplate, _index2.NumberValue, [Receiver], lengthTemplateSrc);
    }

    if (!(P instanceof _index2.AbstractValue)) return this.$Get(P, Receiver); // A string coercion might have side-effects.
    // TODO #1682: We assume that simple objects mean that they don't have a
    // side-effectful valueOf and toString but that's not enforced.

    if (P.mightNotBeString() && P.mightNotBeNumber() && !P.isSimpleObject()) {
      if (this.$Realm.isInPureScope()) {
        // If we're in pure scope, we can havoc the key and keep going.
        // Coercion can only have effects on anything reachable from the key.
        _singletons.Havoc.value(this.$Realm, P);
      } else {
        let error = new _errors.CompilerDiagnostic("property key might not have a well behaved toString or be a symbol", this.$Realm.currentLocation, "PP0002", "RecoverableError");

        if (this.$Realm.handleError(error) !== "Recover") {
          throw new _errors.FatalError();
        }
      }
    } // We assume that simple objects have no getter/setter properties.


    if (!this.isSimpleObject()) {
      if (this.$Realm.isInPureScope()) {
        // If we're in pure scope, we can havoc the object. Coercion
        // can only have effects on anything reachable from this object.
        // We assume that if the receiver is different than this object,
        // then we only got here because there were no other keys with
        // this name on other parts of the prototype chain.
        // TODO #1675: A fix to 1675 needs to take this into account.
        _singletons.Havoc.value(this.$Realm, Receiver);

        return _index2.AbstractValue.createTemporalFromBuildFunction(this.$Realm, _index2.Value, [Receiver, P], (0, _generator.createOperationDescriptor)("OBJECT_GET_PARTIAL"), {
          skipInvariant: true,
          isPure: true
        });
      } else {
        let error = new _errors.CompilerDiagnostic("unknown property access might need to invoke a getter", this.$Realm.currentLocation, "PP0030", "RecoverableError");

        if (this.$Realm.handleError(error) !== "Recover") {
          throw new _errors.FatalError();
        }
      }
    }

    P = _singletons.To.ToStringAbstract(this.$Realm, P); // If all else fails, use this expression
    // TODO #1675: Check the prototype chain for known properties too.

    let result;

    if (this.isPartialObject()) {
      if (isWidenedValue(P)) {
        // TODO #1678: Use a snapshot or havoc this object.
        return _index2.AbstractValue.createTemporalFromBuildFunction(this.$Realm, _index2.Value, [this, P], (0, _generator.createOperationDescriptor)("OBJECT_GET_PARTIAL"), {
          skipInvariant: true,
          isPure: true
        });
      }

      result = _index2.AbstractValue.createFromType(this.$Realm, _index2.Value, "sentinel member expression", [this, P]);
    } else {
      result = _index2.AbstractValue.createTemporalFromBuildFunction(this.$Realm, _index2.Value, [this, P], (0, _generator.createOperationDescriptor)("OBJECT_GET_PARTIAL"), {
        skipInvariant: true,
        isPure: true
      });
    } // Get a specialization of the join of all values written to the object
    // with abstract property names.


    let prop = this.unknownProperty;

    if (prop !== undefined) {
      let desc = prop.descriptor;

      if (desc !== undefined) {
        let val = desc.value;
        (0, _invariant.default)(val instanceof _index2.AbstractValue);

        if (val.kind === "widened numeric property") {
          (0, _invariant.default)(Receiver instanceof _index2.ArrayValue && _index2.ArrayValue.isIntrinsicAndHasWidenedNumericProperty(Receiver));
          return (0, _index3.GetFromArrayWithWidenedNumericProperty)(this.$Realm, Receiver, P instanceof _index2.StringValue ? P.value : P);
        }

        result = this.specializeJoin(val, P);
      }
    } // Join in all of the other values that were written to the object with
    // concrete property names.


    for (let [key, propertyBinding] of this.properties) {
      let desc = propertyBinding.descriptor;
      if (desc === undefined) continue; // deleted

      (0, _invariant.default)(desc.value !== undefined); // otherwise this is not simple

      let val = desc.value;
      (0, _invariant.default)(val instanceof _index2.Value);

      let cond = _index2.AbstractValue.createFromBinaryOp(this.$Realm, "===", P, new _index2.StringValue(this.$Realm, key), undefined, "check for known property");

      result = _index2.AbstractValue.createFromConditionalOp(this.$Realm, cond, val, result);
    }

    return result;
  }

  specializeJoin(absVal, propName) {
    if (absVal.kind === "widened property") {
      let ob = absVal.args[0];

      if (propName instanceof _index2.StringValue) {
        let pName = propName.value;
        let pNumber = +pName;
        if (pName === pNumber + "") propName = new _index2.NumberValue(this.$Realm, pNumber);
      }

      return _index2.AbstractValue.createTemporalFromBuildFunction(this.$Realm, absVal.getType(), [ob, propName], (0, _generator.createOperationDescriptor)("OBJECT_GET_PARTIAL"), {
        skipInvariant: true,
        isPure: true
      });
    }

    (0, _invariant.default)(absVal.args.length === 3 && absVal.kind === "conditional");
    let generic_cond = absVal.args[0];
    (0, _invariant.default)(generic_cond instanceof _index2.AbstractValue);
    let cond = this.specializeCond(generic_cond, propName);
    let arg1 = absVal.args[1];
    if (arg1 instanceof _index2.AbstractValue && arg1.args.length === 3) arg1 = this.specializeJoin(arg1, propName);
    let arg2 = absVal.args[2];

    if (arg2 instanceof _index2.AbstractValue) {
      if (arg2.kind === "template for prototype member expression") {
        let ob = arg2.args[0];
        arg2 = _index2.AbstractValue.createTemporalFromBuildFunction(this.$Realm, absVal.getType(), [ob, propName], (0, _generator.createOperationDescriptor)("OBJECT_GET_PARTIAL"), {
          skipInvariant: true,
          isPure: true
        });
      } else if (arg2.args.length === 3) {
        arg2 = this.specializeJoin(arg2, propName);
      }
    }

    return _index2.AbstractValue.createFromConditionalOp(this.$Realm, cond, arg1, arg2, absVal.expressionLocation);
  }

  specializeCond(absVal, propName) {
    if (absVal.kind === "template for property name condition") return _index2.AbstractValue.createFromBinaryOp(this.$Realm, "===", absVal.args[0], propName);
    return absVal;
  } // ECMA262 9.1.9


  $Set(P, V, Receiver) {
    // 1. Return ? OrdinarySet(O, P, V, Receiver).
    return _singletons.Properties.OrdinarySet(this.$Realm, this, P, V, Receiver);
  }

  $SetPartial(P, V, Receiver) {
    if (!(P instanceof _index2.AbstractValue)) return this.$Set(P, V, Receiver);
    let pIsLoopVar = isWidenedValue(P);

    let pIsNumeric = _index2.Value.isTypeCompatibleWith(P.getType(), _index2.NumberValue); // A string coercion might have side-effects.
    // TODO #1682: We assume that simple objects mean that they don't have a
    // side-effectful valueOf and toString but that's not enforced.


    if (P.mightNotBeString() && P.mightNotBeNumber() && !P.isSimpleObject()) {
      if (this.$Realm.isInPureScope()) {
        // If we're in pure scope, we can havoc the key and keep going.
        // Coercion can only have effects on anything reachable from the key.
        _singletons.Havoc.value(this.$Realm, P);
      } else {
        let error = new _errors.CompilerDiagnostic("property key might not have a well behaved toString or be a symbol", this.$Realm.currentLocation, "PP0002", "RecoverableError");

        if (this.$Realm.handleError(error) !== "Recover") {
          throw new _errors.FatalError();
        }
      }
    } // We assume that simple objects have no getter/setter properties and
    // that all properties are writable.


    if (!this.isSimpleObject()) {
      if (this.$Realm.isInPureScope()) {
        // If we're in pure scope, we can havoc the object and leave an
        // assignment in place.
        _singletons.Havoc.value(this.$Realm, Receiver); // We also need to havoc the value since it might leak to a setter.


        _singletons.Havoc.value(this.$Realm, V);

        this.$Realm.evaluateWithPossibleThrowCompletion(() => {
          let generator = this.$Realm.generator;
          (0, _invariant.default)(generator);
          (0, _invariant.default)(P instanceof _index2.AbstractValue);
          generator.emitStatement([Receiver, P, V], (0, _generator.createOperationDescriptor)("OBJECT_SET_PARTIAL"));
          return this.$Realm.intrinsics.undefined;
        }, _index.TypesDomain.topVal, _index.ValuesDomain.topVal); // The emitted assignment might throw at runtime but if it does, that
        // is handled by evaluateWithPossibleThrowCompletion. Anything that
        // happens after this, can assume we didn't throw and therefore,
        // we return true here.

        return true;
      } else {
        let error = new _errors.CompilerDiagnostic("unknown property access might need to invoke a setter", this.$Realm.currentLocation, "PP0030", "RecoverableError");

        if (this.$Realm.handleError(error) !== "Recover") {
          throw new _errors.FatalError();
        }
      }
    } // We should never consult the prototype chain for unknown properties.
    // If it was simple, it would've been an assignment to the receiver.
    // The only case the Receiver isn't this, if this was a ToObject
    // coercion from a PrimitiveValue.


    (0, _invariant.default)(this === Receiver || (0, _index3.HasCompatibleType)(Receiver, _index2.PrimitiveValue));
    P = _singletons.To.ToStringAbstract(this.$Realm, P);

    function createTemplate(realm, propName) {
      return _index2.AbstractValue.createFromBinaryOp(realm, "===", propName, new _index2.StringValue(realm, ""), undefined, "template for property name condition");
    }

    let prop;

    if (this.unknownProperty === undefined) {
      prop = {
        descriptor: undefined,
        object: this,
        key: P
      };
      this.unknownProperty = prop;
    } else {
      prop = this.unknownProperty;
    }

    this.$Realm.recordModifiedProperty(prop);
    let desc = prop.descriptor;

    if (desc === undefined) {
      let newVal = V;

      if (!(V instanceof _index2.UndefinedValue) && !isWidenedValue(P)) {
        // join V with sentinel, using a property name test as the condition
        let cond = createTemplate(this.$Realm, P);

        let sentinel = _index2.AbstractValue.createFromType(this.$Realm, _index2.Value, "template for prototype member expression", [Receiver, P]);

        newVal = _index2.AbstractValue.createFromConditionalOp(this.$Realm, cond, V, sentinel);
      }

      prop.descriptor = {
        writable: true,
        enumerable: true,
        configurable: true,
        value: newVal
      };
    } else {
      // join V with current value of this.unknownProperty. I.e. weak update.
      let oldVal = desc.value;
      (0, _invariant.default)(oldVal instanceof _index2.Value);
      let newVal = oldVal;

      if (!(V instanceof _index2.UndefinedValue)) {
        if (isWidenedValue(P)) {
          newVal = V; // It will be widened later on
        } else {
          let cond = createTemplate(this.$Realm, P);
          newVal = _index2.AbstractValue.createFromConditionalOp(this.$Realm, cond, V, oldVal);
        }
      }

      desc.value = newVal;
    } // Since we don't know the name of the property we are writing to, we also need
    // to perform weak updates of all of the known properties.
    // First clear out this.unknownProperty so that helper routines know its OK to update the properties


    let savedUnknownProperty = this.unknownProperty;
    this.unknownProperty = undefined;

    for (let [key, propertyBinding] of this.properties) {
      if (pIsLoopVar && pIsNumeric) {
        // Delete numeric properties and don't do weak updates on other properties.
        if (key !== +key + "") continue;
        this.properties.delete(key);
        continue;
      }

      let oldVal = this.$Realm.intrinsics.empty;

      if (propertyBinding.descriptor && propertyBinding.descriptor.value) {
        oldVal = propertyBinding.descriptor.value;
        (0, _invariant.default)(oldVal instanceof _index2.Value); // otherwise this is not simple
      }

      let cond = _index2.AbstractValue.createFromBinaryOp(this.$Realm, "===", P, new _index2.StringValue(this.$Realm, key));

      let newVal = _index2.AbstractValue.createFromConditionalOp(this.$Realm, cond, V, oldVal);

      _singletons.Properties.OrdinarySet(this.$Realm, this, key, newVal, Receiver);
    }

    this.unknownProperty = savedUnknownProperty;
    return true;
  } // ECMA262 9.1.10


  $Delete(P) {
    if (this.unknownProperty !== undefined) {
      // TODO #946: generate a delete from the object
      _index2.AbstractValue.reportIntrospectionError(this, P);

      throw new _errors.FatalError();
    } // 1. Return ? OrdinaryDelete(O, P).


    return _singletons.Properties.OrdinaryDelete(this.$Realm, this, P);
  } // ECMA262 9.1.11


  $OwnPropertyKeys() {
    return (0, _index3.OrdinaryOwnPropertyKeys)(this.$Realm, this);
  }

  static refuseSerializationOnPropertyBinding(pb) {
    if (pb.object.refuseSerialization) return true;
    if (pb.internalSlot && typeof pb.key === "string" && pb.key[0] === "_") return true;
    return false;
  }

}

exports.default = ObjectValue;

_defineProperty(ObjectValue, "trackedPropertyNames", ["_isPartial", "_isHavoced", "_isSimple", "_isFinal", "_simplicityIsTransitive", "_temporalAlias", "$ArrayIteratorNextIndex", "$DateValue", "$Extensible", "$IteratedList", "$IteratedObject", "$IteratedSet", "$IteratedString", "$Map", "$MapData", "$MapNextIndex", "$Prototype", "$SetData", "$SetNextIndex", "$StringIteratorNextIndex", "$WeakMapData", "$WeakSetData"]);

_defineProperty(ObjectValue, "trackedPropertyBindingNames", new Map());
//# sourceMappingURL=ObjectValue.js.map