first commit

build/node_modules/prepack/lib/evaluators/UnaryExpression.js

@@ -0,0 +1,221 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (ast, strictCode, env, realm) {
+  function reportError() {
+    var error = new _errors.CompilerDiagnostic("might be a symbol or an object with an unknown valueOf or toString or Symbol.toPrimitive method", ast.argument.loc, "PP0008", "RecoverableError");
+    if (realm.handleError(error) === "Fail") throw new _errors.FatalError();
+  }
+
+  var expr = env.evaluate(ast.argument, strictCode);
+
+  if (ast.operator === "+") {
+    // ECMA262 12.5.6.1
+
+    // 1. Let expr be the result of evaluating UnaryExpression.
+    expr;
+
+    // 2. Return ? ToNumber(? GetValue(expr)).
+    var value = _singletons.Environment.GetValue(realm, expr);
+    if (value instanceof _index.AbstractValue) {
+      if (!_singletons.To.IsToNumberPure(realm, value)) reportError();
+      return _index.AbstractValue.createFromUnaryOp(realm, "+", value);
+    }
+    (0, _invariant2.default)(value instanceof _index.ConcreteValue);
+
+    return new _index.NumberValue(realm, _singletons.To.ToNumber(realm, value));
+  } else if (ast.operator === "-") {
+    // ECMA262 12.5.7.1
+
+    // 1. Let expr be the result of evaluating UnaryExpression.
+    expr;
+
+    // 2. Let oldValue be ? ToNumber(? GetValue(expr)).
+    var _value = _singletons.Environment.GetValue(realm, expr);
+    if (_value instanceof _index.AbstractValue) {
+      if (!_singletons.To.IsToNumberPure(realm, _value)) reportError();
+      return _index.AbstractValue.createFromUnaryOp(realm, "-", _value);
+    }
+    (0, _invariant2.default)(_value instanceof _index.ConcreteValue);
+    var oldValue = _singletons.To.ToNumber(realm, _value);
+
+    // 3. If oldValue is NaN, return NaN.
+    if (isNaN(oldValue)) {
+      return realm.intrinsics.NaN;
+    }
+
+    // 4. Return the result of negating oldValue; that is, compute a Number with the same magnitude but opposite sign.
+    return new _index.NumberValue(realm, -oldValue);
+  } else if (ast.operator === "~") {
+    // ECMA262 12.5.8
+
+    // 1. Let expr be the result of evaluating UnaryExpression.
+    expr;
+
+    // 2. Let oldValue be ? ToInt32(? GetValue(expr)).
+    var _value2 = _singletons.Environment.GetValue(realm, expr);
+    if (_value2 instanceof _index.AbstractValue) {
+      if (!_singletons.To.IsToNumberPure(realm, _value2)) reportError();
+      return _index.AbstractValue.createFromUnaryOp(realm, "~", _value2);
+    }
+    (0, _invariant2.default)(_value2 instanceof _index.ConcreteValue);
+    var _oldValue = _singletons.To.ToInt32(realm, _value2);
+
+    // 3. Return the result of applying bitwise complement to oldValue. The result is a signed 32-bit integer.
+    return new _index.NumberValue(realm, ~_oldValue);
+  } else if (ast.operator === "!") {
+    // ECMA262 12.6.9
+
+    // 1. Let expr be the result of evaluating UnaryExpression.
+    expr;
+
+    // 2. Let oldValue be ToBoolean(? GetValue(expr)).
+    var _value3 = _singletons.Environment.GetValue(realm, expr);
+    if (_value3 instanceof _index.AbstractValue) return _index.AbstractValue.createFromUnaryOp(realm, "!", _value3);
+    (0, _invariant2.default)(_value3 instanceof _index.ConcreteValue);
+    var _oldValue2 = _singletons.To.ToBoolean(realm, _value3);
+
+    // 3. If oldValue is true, return false.
+    if (_oldValue2 === true) return realm.intrinsics.false;
+
+    // 4. Return true.
+    return realm.intrinsics.true;
+  } else if (ast.operator === "void") {
+    // 1. Let expr be the result of evaluating UnaryExpression.
+    expr;
+
+    // 2. Perform ? GetValue(expr).
+    _singletons.Environment.GetValue(realm, expr);
+
+    // 3. Return undefined.
+    return realm.intrinsics.undefined;
+  } else if (ast.operator === "typeof") {
+    // ECMA262 12.6.5
+
+    // 1. Let val be the result of evaluating UnaryExpression.
+    var val = expr;
+
+    // 2. If Type(val) is Reference, then
+    if (val instanceof _environment.Reference) {
+      // a. If IsUnresolvableReference(val) is true, return "undefined".
+      if (_singletons.Environment.IsUnresolvableReference(realm, val)) {
+        return new _index.StringValue(realm, "undefined");
+      }
+    }
+
+    // 3. Let val be ? GetValue(val).
+    val = _singletons.Environment.GetValue(realm, val);
+
+    // 4. Return a String according to Table 35.
+    var proto = val.getType().prototype;
+    if (isInstance(proto, _index.UndefinedValue)) {
+      return new _index.StringValue(realm, "undefined");
+    } else if (isInstance(proto, _index.NullValue)) {
+      return new _index.StringValue(realm, "object");
+    } else if (isInstance(proto, _index.StringValue)) {
+      return new _index.StringValue(realm, "string");
+    } else if (isInstance(proto, _index.BooleanValue)) {
+      return new _index.StringValue(realm, "boolean");
+    } else if (isInstance(proto, _index.NumberValue)) {
+      return new _index.StringValue(realm, "number");
+    } else if (isInstance(proto, _index.SymbolValue)) {
+      return new _index.StringValue(realm, "symbol");
+    } else if (isInstance(proto, _index.ObjectValue)) {
+      if ((0, _index2.IsCallable)(realm, val)) {
+        return new _index.StringValue(realm, "function");
+      }
+      return new _index.StringValue(realm, "object");
+    } else {
+      (0, _invariant2.default)(val instanceof _index.AbstractValue);
+      return _index.AbstractValue.createFromUnaryOp(realm, "typeof", val);
+    }
+  } else {
+    (0, _invariant2.default)(ast.operator === "delete");
+    // ECMA262 12.5.3.2
+
+    // 1. Let ref be the result of evaluating UnaryExpression.
+    var ref = expr;
+
+    // 2. ReturnIfAbrupt(ref).
+
+    // 3. If Type(ref) is not Reference, return true.
+    if (!(ref instanceof _environment.Reference)) return realm.intrinsics.true;
+
+    // 4. If IsUnresolvableReference(ref) is true, then
+    if (_singletons.Environment.IsUnresolvableReference(realm, ref)) {
+      // a. Assert: IsStrictReference(ref) is false.
+      (0, _invariant2.default)(!_singletons.Environment.IsStrictReference(realm, ref), "did not expect a strict reference");
+
+      // b. Return true.
+      return realm.intrinsics.true;
+    }
+
+    // 5. If IsPropertyReference(ref) is true, then
+    if (_singletons.Environment.IsPropertyReference(realm, ref)) {
+      // a. If IsSuperReference(ref) is true, throw a ReferenceError exception.
+      if (_singletons.Environment.IsSuperReference(realm, ref)) {
+        throw realm.createErrorThrowCompletion(realm.intrinsics.ReferenceError);
+      }
+
+      // b. Let baseObj be ! ToObject(GetBase(ref)).
+      var base = _singletons.Environment.GetBase(realm, ref);
+      // Constructing the reference checks that base is coercible to an object hence
+      (0, _invariant2.default)(base instanceof _index.ConcreteValue || base instanceof _index.AbstractObjectValue);
+      var baseObj = base instanceof _index.ConcreteValue ? _singletons.To.ToObject(realm, base) : base;
+
+      // c. Let deleteStatus be ? baseObj.[[Delete]](GetReferencedName(ref)).
+      var deleteStatus = baseObj.$Delete(_singletons.Environment.GetReferencedName(realm, ref));
+
+      // d. If deleteStatus is false and IsStrictReference(ref) is true, throw a TypeError exception.
+      if (!deleteStatus && _singletons.Environment.IsStrictReference(realm, ref)) {
+        throw realm.createErrorThrowCompletion(realm.intrinsics.TypeError);
+      }
+
+      // e. Return deleteStatus.
+      return new _index.BooleanValue(realm, deleteStatus);
+    }
+
+    // 6. Else ref is a Reference to an Environment Record binding,
+    // a. Let bindings be GetBase(ref).
+    var bindings = _singletons.Environment.GetBase(realm, ref);
+    (0, _invariant2.default)(bindings instanceof _environment.EnvironmentRecord);
+
+    // b. Return ? bindings.DeleteBinding(GetReferencedName(ref)).
+    var referencedName = _singletons.Environment.GetReferencedName(realm, ref);
+    (0, _invariant2.default)(typeof referencedName === "string");
+    return new _index.BooleanValue(realm, bindings.DeleteBinding(referencedName));
+  }
+};
+
+var _errors = require("../errors.js");
+
+var _index = require("../values/index.js");
+
+var _environment = require("../environment.js");
+
+var _invariant = require("../invariant.js");
+
+var _invariant2 = _interopRequireDefault(_invariant);
+
+var _index2 = require("../methods/index.js");
+
+var _singletons = require("../singletons.js");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Copyright (c) 2017-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+function isInstance(proto, Constructor) {
+  return proto instanceof Constructor || proto === Constructor.prototype;
+}
+//# sourceMappingURL=UnaryExpression.js.map