[strong] create strong array literals

test/mjsunit/strong/literals.js

Index: test/mjsunit/strong/literals.js
diff --git a/test/mjsunit/strong/literals.js b/test/mjsunit/strong/literals.js
index db608fc626f86045eb5aed5ca5aa8c94188a84b6..73129e7a09072197df16ec1d88ac76ccfab1597d 100644
--- a/test/mjsunit/strong/literals.js
+++ b/test/mjsunit/strong/literals.js
@@ -4,52 +4,37 @@
 
 // Flags: --strong-mode --allow-natives-syntax
 // Flags: --harmony-arrow-functions --harmony-rest-parameters
-// Flags: --harmony-destructuring
+// Flags: --harmony-destructuring --harmony-spread-arrays
 
 'use strict';
 
-let GeneratorFunctionPrototype = (function*(){}).__proto__;
-
-function assertStrongObject(o) {
-  assertTrue(%IsStrong(o));
-  assertSame(Object.prototype, o.__proto__);
-}
-
-function assertStrongArray(a) {
-  assertTrue(%IsStrong(a));
-  assertSame(Array.prototype, a.__proto__);
-}
-
-function assertStrongFunction(f) {
-  assertTrue(%IsStrong(f));
-  assertSame(Function.prototype, f.__proto__);
-}
-
-function assertStrongGenerator(g) {
-  assertTrue(%IsStrong(g));
-  assertSame(GeneratorFunctionPrototype, g.__proto__);
-}
-
 (function WeakObjectLiterals() {
-  assertTrue(!%IsStrong({}));
-  assertTrue(!%IsStrong({a: 0, b: 0}));
-  assertTrue(!%IsStrong({a: [], b: {}}));
-  assertTrue(!%IsStrong({a: [], b: {}}.a));
-  assertTrue(!%IsStrong({a: [], b: {}}.b));
-  assertTrue(!%IsStrong({a: {b: {c: {}}}}.a));
-  assertTrue(!%IsStrong({a: {b: {c: {}}}}.a.b));
-  assertTrue(!%IsStrong({a: {b: {c: {}}}}.a.b.c));
-  assertTrue(!%IsStrong({f: function(){}}));
-  assertTrue(!%IsStrong(Realm.eval(Realm.current(),
-                                   "({f: function(){}})")));
+  function assertWeakObject(x) {
+    assertFalse(%IsStrong(x));
+    assertSame(Object.prototype, Object.getPrototypeOf(x));
+  }
+  assertWeakObject({});
+  assertWeakObject({a: 0, b: 0});
+  assertWeakObject({a: [], b: {}});
+  assertWeakObject({a: [], b: {}}.b);
+  assertWeakObject({a: {b: {c: {}}}}.a);
+  assertWeakObject({a: {b: {c: {}}}}.a.b);
+  assertWeakObject({a: {b: {c: {}}}}.a.b.c);
+  assertWeakObject([[1], {}, [[3]]][1]);
+  assertWeakObject({f: function(){}});
+  assertWeakObject(
+    Realm.eval(Realm.current(), "({f: function(){}})"));
 })();
 
 (function StrongObjectLiterals() {
   'use strong';
+  function assertStrongObject(x) {
+    assertTrue(%IsStrong(x));
+    assertSame(Object.prototype, Object.getPrototypeOf(x));
+  }
   assertStrongObject({});
   assertStrongObject({a: 0, b: 0});
   assertStrongObject({a: [], b: {}});
-  assertStrongArray({a: [], b: {}}.a);
   assertStrongObject({a: [], b: {}}.b);
   assertStrongObject({a: {b: {c: {}}}}.a);
   assertStrongObject({a: {b: {c: {}}}}.a.b);
@@ -97,73 +82,92 @@ function assertStrongGenerator(g) {
     x191: 0, x192: 0, x193: 0, x194: 0, x195: 0,
     x196: 0, x197: 0, x198: 0, x199: 0, x200: 0,
   });
+  assertStrongObject([[1], {}, [[3]]][1]);
   assertStrongObject({[Date() + ""]: 0, [Symbol()]: 0});
   assertStrongObject({m() { super.m() }});
+  assertTrue(%IsStrong({__proto__: {}, get a() {}, set b(x) {}}));
   // Object literals with constant functions are treated specially,
   // but currently only on the toplevel (using Realm.eval to emulate that).
   assertStrongObject({f: function(){}});
-  assertStrongObject(Realm.eval(Realm.current(),
-                       "'use strong'; ({f: function(){}})"));
-  assertTrue(%IsStrong({__proto__: {}, get a() {}, set b(x) {}}));
+  assertStrongObject(
+    Realm.eval(Realm.current(), "'use strong'; ({f: function(){}})"));
 })();
 
 (function WeakArrayLiterals(...args) {
+  function assertWeakArray(x) {
+    assertFalse(%IsStrong(x));
+    assertSame(Array.prototype, Object.getPrototypeOf(x));
+  }
   let [...r] = [];
-  assertTrue(!%IsStrong(args));
-  assertTrue(!%IsStrong(r));
-  assertTrue(!%IsStrong([]));
-  assertTrue(!%IsStrong([1, 2, 3]));
-  assertTrue(!%IsStrong([[[]]]));
-  assertTrue(!%IsStrong([[1], {}, [[3]]]));
-  assertTrue(!%IsStrong([[1], {}, [[3]]][0]));
-  assertTrue(!%IsStrong([[1], {}, [[3]]][1]));
-  assertTrue(!%IsStrong([[1], {}, [[3]]][2]));
-  assertTrue(!%IsStrong([[1], {}, [[3]]][2][0]));
+  assertWeakArray(args);
+  assertWeakArray(r);
+  assertWeakArray([]);
+  assertWeakArray([1, 2, 3]);
+  assertWeakArray([1, 2, ...[3, 4], 5]);
+  assertWeakArray([[[]]]);
+  assertWeakArray([[1], {}, [[3]]]);
+  assertWeakArray([[1], {}, [[3]]][0]);
+  assertWeakArray([[1], {}, [[3]]][2]);
+  assertWeakArray([[1], {}, [[3]]][2][0]);
+  assertWeakArray({a: [], b: {}}.a);
 })();
 
 (function StrongArrayLiterals(...args) {
   'use strong';
+  function assertStrongArray(x) {
+    assertTrue(%IsStrong(x));
+    assertSame(Array.prototype, Object.getPrototypeOf(x));
+  }
   let [...r] = [];
-  // TODO(rossberg): teach strongness to FastCloneShallowArrayStub
-  // assertTrue(%IsStrong(args));
-  // assertTrue(%IsStrong(r));
-  // assertTrue(%IsStrong([]));
-  // assertTrue(%IsStrong([1, 2, 3]));
-  // assertTrue(%IsStrong([1, 2, ...[3, 4], 5]));
+  assertStrongArray(args);
+  assertStrongArray(r);
+  assertStrongArray([]);
+  assertStrongArray([1, 2, 3]);
+  assertStrongArray([1, 2, ...[3, 4], 5]);
   assertStrongArray([[[]]]);
   assertStrongArray([[1], {}, [[3]]]);
   assertStrongArray([[1], {}, [[3]]][0]);
-  assertStrongObject([[1], {}, [[3]]][1]);
   assertStrongArray([[1], {}, [[3]]][2]);
   assertStrongArray([[1], {}, [[3]]][2][0]);
+  assertStrongArray({a: [], b: {}}.a);
 })();
 
 (function WeakFunctionLiterals() {
+  function assertWeakFunction(x) {
+    assertFalse(%IsStrong(x));
+    assertFalse(%IsStrong(x.prototype));
+    assertSame(Function.prototype, Object.getPrototypeOf(x));
+  }
   function f() {}
-  assertTrue(!%IsStrong(f));
-  assertTrue(!%IsStrong(function(){}));
-  assertTrue(!%IsStrong(function f(){}));
-  assertTrue(!%IsStrong(() => {}));
-  assertTrue(!%IsStrong(x => x));
-  assertTrue(!%IsStrong({m(){}}.m));
-  assertTrue(!%IsStrong(Object.getOwnPropertyDescriptor(
-      {get a(){}}, 'a').get));
-  assertTrue(!%IsStrong(Object.getOwnPropertyDescriptor(
-      {set a(x){}}, 'a').set));
-  assertTrue(!%IsStrong((class {static m(){}}).m));
-  assertTrue(!%IsStrong(Object.getOwnPropertyDescriptor(
-      class {static get a(){}}, 'a').get));
-  assertTrue(!%IsStrong(Object.getOwnPropertyDescriptor(
-      class {static set a(x){}}, 'a').set));
-  assertTrue(!%IsStrong((new class {m(){}}).m));
-  assertTrue(!%IsStrong(Object.getOwnPropertyDescriptor(
-      (class {get a(){}}).prototype, 'a').get));
-  assertTrue(!%IsStrong(Object.getOwnPropertyDescriptor(
-      (class {set a(x){}}).prototype, 'a').set));
+  assertWeakFunction(f);
+  assertWeakFunction(function(){});
+  assertWeakFunction(function f(){});
+  assertWeakFunction(() => {});
+  assertWeakFunction(x => x);
+  assertWeakFunction({m(){}}.m);
+  assertWeakFunction(Object.getOwnPropertyDescriptor(
+      {get a(){}}, 'a').get);
+  assertWeakFunction(Object.getOwnPropertyDescriptor(
+      {set a(x){}}, 'a').set);
+  assertWeakFunction((class {static m(){}}).m);
+  assertWeakFunction(Object.getOwnPropertyDescriptor(
+      class {static get a(){}}, 'a').get);
+  assertWeakFunction(Object.getOwnPropertyDescriptor(
+      class {static set a(x){}}, 'a').set);
+  assertWeakFunction((new class {m(){}}).m);
+  assertWeakFunction(Object.getOwnPropertyDescriptor(
+      (class {get a(){}}).prototype, 'a').get);
+  assertWeakFunction(Object.getOwnPropertyDescriptor(
+      (class {set a(x){}}).prototype, 'a').set);
 })();
 
 (function StrongFunctionLiterals() {
   'use strong';
+  function assertStrongFunction(x) {
+    assertTrue(%IsStrong(x));
+    assertFalse('prototype' in x);
+    assertSame(Function.prototype, Object.getPrototypeOf(x));
+  }
   function f() {}
   assertStrongFunction(f);
   assertStrongFunction(function(){});
@@ -188,6 +192,11 @@ function assertStrongGenerator(g) {
 })();
 
 (function SelfStrongFunctionLiterals() {
+  function assertStrongFunction(x) {
+    assertTrue(%IsStrong(x));
+    assertFalse('prototype' in x);
+    assertSame(Function.prototype, Object.getPrototypeOf(x));
+  }
   function f() {'use strong'}
   assertStrongFunction(f);
   assertStrongFunction(function(){'use strong'});
@@ -211,18 +220,34 @@ function assertStrongGenerator(g) {
       (class {set a(x){'use strong'}}).prototype, 'a').set);
 })();
 
+let GeneratorPrototype = (function*(){}).__proto__;
+
 (function WeakGeneratorLiterals() {
+  function assertWeakGenerator(x) {
+    assertFalse(%IsStrong(x));
+    assertFalse(%IsStrong(x.prototype));
+    assertSame(GeneratorPrototype, Object.getPrototypeOf(x));
+    assertFalse(%IsStrong(x()));
+  }
   function* g() {}
-  assertTrue(!%IsStrong(g));
-  assertTrue(!%IsStrong(function*(){}));
-  assertTrue(!%IsStrong(function* g(){}));
-  assertTrue(!%IsStrong({*m(){}}.m));
-  assertTrue(!%IsStrong((class {static *m(){}}).m));
-  assertTrue(!%IsStrong((new class {*m(){}}).m));
+  assertWeakGenerator(g);
+  assertWeakGenerator(function*(){});
+  assertWeakGenerator(function* g(){});
+  assertWeakGenerator({*m(){}}.m);
+  assertWeakGenerator((class {static *m(){}}).m);
+  assertWeakGenerator((new class {*m(){}}).m);
 })();
 
 (function StrongGeneratorLiterals() {
   'use strong';
+  function assertStrongGenerator(x) {
+    assertTrue(%IsStrong(x));
+    // TODO(rossberg): strongify generator prototypes
+    // assertTrue(%IsStrong(x.prototype));
+    assertSame(GeneratorPrototype, Object.getPrototypeOf(x));
+    // TODO(rossberg): strongify generator instances
+    // assertTrue(%IsStrong(x()));
+  }
   function* g() {}
   assertStrongGenerator(g);
   assertStrongGenerator(function*(){});
@@ -233,6 +258,14 @@ function assertStrongGenerator(g) {
 })();
 
 (function SelfStrongGeneratorLiterals() {
+  function assertStrongGenerator(x) {
+    assertTrue(%IsStrong(x));
+    // TODO(rossberg): strongify generator prototypes
+    // assertTrue(%IsStrong(x.prototype));
+    assertSame(GeneratorPrototype, Object.getPrototypeOf(x));
+    // TODO(rossberg): strongify generator instances
+    // assertTrue(%IsStrong(x()));
+  }
   function* g() {'use strong'}
   assertStrongGenerator(g);
   assertStrongGenerator(function*(){'use strong'});
@@ -243,30 +276,31 @@ function assertStrongGenerator(g) {
 })();
 
 (function WeakClassLiterals() {
-  function assertWeakClass(C) {
-    assertTrue(!%IsStrong(C));
-    assertTrue(!%IsStrong(C.prototype));
+  function assertWeakClass(x) {
+    assertFalse(%IsStrong(x));
+    assertFalse(%IsStrong(x.prototype));
+    assertFalse(%IsStrong(new x));
   }
   class C {};
   class D extends C {};
   class E extends Object {};
-  class F extends null {};
+  // class F extends null {};

[arv (Not doing code reviews), 2015/05/28 16:11:45]

Because new fails. Maybe just do a different assertion for these?

   const S = (() => {'use strong'; return class {}})();
   class G extends S {};
   assertWeakClass(C);
   assertWeakClass(D);
   assertWeakClass(E);
-  assertWeakClass(F);
+  // assertWeakClass(F);
   assertWeakClass(G);
   assertWeakClass(class {});
   assertWeakClass(class extends Object {});
-  assertWeakClass(class extends null {});
+  // assertWeakClass(class extends null {});
   assertWeakClass(class extends C {});
   assertWeakClass(class extends S {});
   assertWeakClass(class extends class {} {});
   assertWeakClass(class C {});
   assertWeakClass(class D extends Object {});
-  assertWeakClass(class D extends null {});
+  // assertWeakClass(class D extends null {});
   assertWeakClass(class D extends C {});
   assertWeakClass(class D extends S {});
   assertWeakClass(class D extends class {} {});
@@ -274,42 +308,45 @@ function assertStrongGenerator(g) {
 
 (function StrongClassLiterals() {
   'use strong';
-  function assertStrongClass(C) {
-    assertTrue(%IsStrong(C));
-    // TODO(rossberg): prototype object is not yet strongified
-    // assertTrue(%IsStrong(C.prototype));
+  function assertStrongClass(x) {
+    assertTrue(%IsStrong(x));
+    // TODO(rossberg): strongify class prototype and instance
+    // assertTrue(%IsStrong(x.prototype));
+    // assertTrue(%IsStrong(new x));
   }
   class C {};
   class D extends C {};
   class E extends Object {};
-  class F extends null {};

[arv (Not doing code reviews), 2015/05/28 16:11:45]

same here?

[conradw, 2015/05/29 11:38:30]

The fact that these were removed instead of commented out makes me wonder if
there's a strong mode restriction in play here that I'm not appreciating. I'll
hold off on committing this until Andreas comes back on Monday.

[rossberg, 2015/06/01 11:31:24]

Yes, I figured that in strong mode we should just throw immediately if an
extends clause evaluates to null (just added that to the spreadsheet), so these
tests no longer make sense. Just forgot to remove them above.

   const W = (1, eval)(() => {'use strict'; return class {}})();
   class G extends W {};
   assertStrongClass(C);
   assertStrongClass(D);
   assertStrongClass(E);
-  assertStrongClass(F);
   assertStrongClass(G);
   assertStrongClass(class {});
   assertStrongClass(class extends Object {});
-  assertStrongClass(class extends null {});
   assertStrongClass(class extends C {});
   assertStrongClass(class extends W {});
   assertStrongClass(class extends class {} {});
   assertStrongClass(class C {});
   assertStrongClass(class D extends Object {});
-  assertStrongClass(class D extends null {});
   assertStrongClass(class D extends C {});
   assertStrongClass(class D extends W {});
   assertStrongClass(class D extends class {} {});
 })();
 
 (function WeakRegExpLiterals() {
-  assertTrue(!%IsStrong(/abc/));
+  function assertWeakRegExp(x) {
+    assertFalse(%IsStrong(x));
+  }
+  assertWeakRegExp(/abc/);
 })();
 
 (function StrongRegExpLiterals() {
   'use strong';
-  // TODO(rossberg): implement strong regexp literals
-  // assertTrue(%IsStrong(/abc/));
+  function assertStrongRegExp(x) {
+    // TODO(rossberg): strongify regexps
+    // assertTrue(%IsStrong(x));
+  }
+  assertStrongRegExp(/abc/);
 })();