ES6 Unscopables

test/mjsunit/harmony/unscopables.js

Index: test/mjsunit/harmony/unscopables.js
diff --git a/test/mjsunit/harmony/unscopables.js b/test/mjsunit/harmony/unscopables.js
new file mode 100644
index 0000000000000000000000000000000000000000..f76396d32285944b24b9a6d3d0b42ae92ea6d026
--- /dev/null
+++ b/test/mjsunit/harmony/unscopables.js
@@ -0,0 +1,200 @@
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --harmony-unscopables
+
+
+(function TestBasics() {

[rossberg, 2014/07/11 11:59:07]

Some of these tests should probably be run on different kinds of objects
(normal, array, function, the global, etc.). And in particular, proxies... ;)
(that one maybe in a separate file, to allow separate shipping).

Also, include a test that not just reads but writes some variables, as that can
take quite different code paths. Likewise, a test where the properties in
question (on the with'ed object) are accessors.

[arv (Not doing code reviews), 2014/07/11 21:47:28]

Our proxies do not support symbol property names so we cannot put a
Symbol.unscopables on the actual proxy... but I can do some basic tests since
with a proxy it is possible to have an inconsistent getOwnPropertyDescriptor
which is used for Lookup and then later for GetProperty.

For setting, unscopables only comes in for the first pass when we do HasBinding.
If that is true, then a normal Put is used.

http://people.mozilla.org/~jorendorff/es6-draft.html#sec-object-environment-r...

This leads to pretty strange behavior and I commented on the bug about it.

+  var x = 1;
+  var y = 2;
+  var z = 3;
+  var object = {
+    x: 4,
+    y: 5
+  };
+
+  with (object) {
+    assertEquals(x, 4);
+    assertEquals(y, 5);
+    assertEquals(z, 3);
+  }
+
+  object[Symbol.unscopables] = {x: true};
+  with (object) {
+    assertEquals(x, 1);
+    assertEquals(y, 5);
+    assertEquals(z, 3);
+  }
+
+  object[Symbol.unscopables] = {x: 0, y: true};
+  with (object) {
+    assertEquals(x, 1);
+    assertEquals(y, 2);
+    assertEquals(z, 3);
+  }
+})();
+
+
+(function TestOnProto() {
+  var x = 1;
+  var y = 2;
+  var z = 3;
+  var proto = {
+    x: 4
+  };
+  var object = {
+    __proto__: proto,
+    y: 5
+  };
+
+  with (object) {
+    assertEquals(x, 4);
+    assertEquals(y, 5);
+    assertEquals(z, 3);
+  }
+
+  proto[Symbol.unscopables] = {x: true};
+  with (object) {
+    assertEquals(x, 1);
+    assertEquals(y, 5);
+    assertEquals(z, 3);
+  }
+
+  object[Symbol.unscopables] = {y: true};
+  with (object) {
+    assertEquals(x, 1);
+    assertEquals(y, 2);
+    assertEquals(z, 3);
+  }
+
+  proto[Symbol.unscopables] = {y: true};
+  object[Symbol.unscopables] = {x: true};
+  with (object) {
+    assertEquals(x, 4);
+    assertEquals(y, 5);
+    assertEquals(z, 3);
+  }
+})();
+
+
+(function TestNonObject() {
+  var x = 1;
+  var y = 2;
+  var object = {
+    x: 3,
+    y: 4
+  };
+
+  object[Symbol.unscopables] = 'xy';
+  with (object) {
+    assertEquals(x, 3);
+    assertEquals(y, 4);
+  }
+
+  object[Symbol.unscopables] = null;
+  with (object) {
+    assertEquals(x, 3);
+    assertEquals(y, 4);
+  }
+})();
+
+
+(function TestChangeDuringWith() {

[rossberg, 2014/07/11 11:59:07]

It would be good to have a variation of this test where the _same_ variable
reference is evaluated several times (e.g. using a loop) with different results.
Just to ensure that no overoptimistic optimisation can screw anything up.

[arv (Not doing code reviews), 2014/07/11 21:47:28]

Done.

+  var x = 1;
+  var y = 2;
+  var object = {
+    x: 3,
+    y: 4
+  };
+
+  with (object) {
+    assertEquals(3, x);
+    assertEquals(4, y);
+    object[Symbol.unscopables] = {x: true};
+    assertEquals(1, x);
+    assertEquals(4, y);
+  }
+})();
+
+
+var global = this;
+(function TestGlobal() {
+  global.values = 'global.values';
+  Array.prototype.values = 'Array.prototype.values';
+  Array.prototype[Symbol.unscopables] = {values: true};
+  Array.prototype.__proto__ = {values: 42};
+  var array = [];
+  with (array) {
+    assertEquals(values, 42);
+  }
+})();
+
+
+(function TestAccessorReceiver() {

[rossberg, 2014/07/11 11:59:07]

Hm, this test doesn't use unscopables at all...

[arv (Not doing code reviews), 2014/07/11 21:47:29]

Since --harmony-unscopables changes how with works I need to test this code path
too. I'm also adding a test that runs all of the existing tests with unscopables
turned on so maybe this can be removed.

+  var x = 'local variable';
+
+  var proto = {
+    get x() {
+      assertEquals(this, object);
+      return this._x;
+    },
+    _x: 'proto'
+  };
+  var object = {
+    __proto__: proto,
+    _x: 'object'
+  };
+
+  with (object) {
+    assertEquals(x, 'object');
+  }
+})();
+
+
+(function TestUnscopablesGetter() {
+  var x = 'local variable';
+  var object = {
+    x: 'object'
+  };
+
+  var callCount = 0;
+  Object.defineProperty(object, Symbol.unscopables, {
+    get: function() {
+      callCount++;
+      return {};
+    },
+    configurable: true
+  });
+  with (object) {
+    assertEquals(x, 'object');
+  }
+  // Once for HasBinding and once for GetBindingValue
+  assertEquals(callCount, 2);
+
+  callCount = 0;
+  Object.defineProperty(object, Symbol.unscopables, {

[rossberg, 2014/07/11 11:59:07]

It would definitely be good to have variants of the following two tests using
assignments to x. I'm not even sure where those assignment are supposed to end
up... :)

[arv (Not doing code reviews), 2014/07/11 21:47:28]

Done.

+    get: function() {
+      callCount++;
+      return callCount === 1 ? {x: true} : {};
+    }
+  });
+  with (object) {
+    assertEquals(x, 'local variable');
+  }
+  // Once for HasBinding
+  assertEquals(callCount, 1);
+
+  callCount = 0;
+  Object.defineProperty(object, Symbol.unscopables, {
+    get: function() {
+      callCount++;
+      return callCount === 1 ? {} : {x: true};
+    }
+  });
+  with (object) {
+    assertEquals(x, undefined);
+  }
+  // Once for HasBinding, once for GetBindingValue.
+  assertEquals(callCount, 2);
+})();