1// Copyright 2015 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5// Flags: --strong-mode --allow-natives-syntax
6// Flags: --harmony-destructuring-bind
7
8'use strict';
9
10(function WeakObjectLiterals() {
11  function assertWeakObject(x) {
12    assertFalse(%IsStrong(x));
13    assertSame(Object.prototype, Object.getPrototypeOf(x));
14  }
15  assertWeakObject({});
16  assertWeakObject({a: 0, b: 0});
17  assertWeakObject({a: [], b: {}});
18  assertWeakObject({a: [], b: {}}.b);
19  assertWeakObject({a: {b: {c: {}}}}.a);
20  assertWeakObject({a: {b: {c: {}}}}.a.b);
21  assertWeakObject({a: {b: {c: {}}}}.a.b.c);
22  assertWeakObject([[1], {}, [[3]]][1]);
23  assertWeakObject({f: function(){}});
24  assertWeakObject(
25    Realm.eval(Realm.current(), "({f: function(){}})"));
26})();
27
28(function StrongObjectLiterals() {
29  'use strong';
30  function assertStrongObject(x) {
31    assertTrue(%IsStrong(x));
32    assertSame(Object.prototype, Object.getPrototypeOf(x));
33  }
34  assertStrongObject({});
35  assertStrongObject({a: 0, b: 0});
36  assertStrongObject({a: [], b: {}});
37  assertStrongObject({a: [], b: {}}.b);
38  assertStrongObject({a: {b: {c: {}}}}.a);
39  assertStrongObject({a: {b: {c: {}}}}.a.b);
40  assertStrongObject({a: {b: {c: {}}}}.a.b.c);
41  // Maps for literals with too many properties are not cached.
42  assertStrongObject({
43    x001: 0, x002: 0, x003: 0, x004: 0, x005: 0,
44    x006: 0, x007: 0, x008: 0, x009: 0, x010: 0,
45    x011: 0, x012: 0, x013: 0, x014: 0, x015: 0,
46    x016: 0, x017: 0, x018: 0, x019: 0, x020: 0,
47    x021: 0, x022: 0, x023: 0, x024: 0, x025: 0,
48    x026: 0, x027: 0, x028: 0, x029: 0, x030: 0,
49    x031: 0, x032: 0, x033: 0, x034: 0, x035: 0,
50    x036: 0, x037: 0, x038: 0, x039: 0, x040: 0,
51    x041: 0, x042: 0, x043: 0, x044: 0, x045: 0,
52    x046: 0, x047: 0, x048: 0, x049: 0, x050: 0,
53    x051: 0, x052: 0, x053: 0, x054: 0, x055: 0,
54    x056: 0, x057: 0, x058: 0, x059: 0, x060: 0,
55    x061: 0, x062: 0, x063: 0, x064: 0, x065: 0,
56    x066: 0, x067: 0, x068: 0, x069: 0, x070: 0,
57    x071: 0, x072: 0, x073: 0, x074: 0, x075: 0,
58    x076: 0, x077: 0, x078: 0, x079: 0, x080: 0,
59    x081: 0, x082: 0, x083: 0, x084: 0, x085: 0,
60    x086: 0, x087: 0, x088: 0, x089: 0, x090: 0,
61    x091: 0, x092: 0, x093: 0, x094: 0, x095: 0,
62    x096: 0, x097: 0, x098: 0, x099: 0, x100: 0,
63    x101: 0, x102: 0, x103: 0, x104: 0, x105: 0,
64    x106: 0, x107: 0, x108: 0, x109: 0, x110: 0,
65    x111: 0, x112: 0, x113: 0, x114: 0, x115: 0,
66    x116: 0, x117: 0, x118: 0, x119: 0, x120: 0,
67    x121: 0, x122: 0, x123: 0, x124: 0, x125: 0,
68    x126: 0, x127: 0, x128: 0, x129: 0, x130: 0,
69    x131: 0, x132: 0, x133: 0, x134: 0, x135: 0,
70    x136: 0, x137: 0, x138: 0, x139: 0, x140: 0,
71    x141: 0, x142: 0, x143: 0, x144: 0, x145: 0,
72    x146: 0, x147: 0, x148: 0, x149: 0, x150: 0,
73    x151: 0, x152: 0, x153: 0, x154: 0, x155: 0,
74    x156: 0, x157: 0, x158: 0, x159: 0, x160: 0,
75    x161: 0, x162: 0, x163: 0, x164: 0, x165: 0,
76    x166: 0, x167: 0, x168: 0, x169: 0, x170: 0,
77    x171: 0, x172: 0, x173: 0, x174: 0, x175: 0,
78    x176: 0, x177: 0, x178: 0, x179: 0, x180: 0,
79    x181: 0, x182: 0, x183: 0, x184: 0, x185: 0,
80    x186: 0, x187: 0, x188: 0, x189: 0, x190: 0,
81    x191: 0, x192: 0, x193: 0, x194: 0, x195: 0,
82    x196: 0, x197: 0, x198: 0, x199: 0, x200: 0,
83  });
84  assertStrongObject([[1], {}, [[3]]][1]);
85  assertStrongObject({[Date() + ""]: 0, [Symbol()]: 0});
86  assertStrongObject({m() { super.m() }});
87  assertTrue(%IsStrong({__proto__: {}, get a() {}, set b(x) {}}));
88  // Object literals with constant functions are treated specially,
89  // but currently only on the toplevel (using Realm.eval to emulate that).
90  assertStrongObject({f: function(){}});
91  assertStrongObject(
92    Realm.eval(Realm.current(), "'use strong'; ({f: function(){}})"));
93})();
94
95(function WeakArrayLiterals(...args) {
96  function assertWeakArray(x) {
97    assertFalse(%IsStrong(x));
98    assertSame(Array.prototype, Object.getPrototypeOf(x));
99  }
100  let [...r] = [];
101  assertWeakArray(args);
102  assertWeakArray(r);
103  assertWeakArray([]);
104  assertWeakArray([1, 2, 3]);
105  assertWeakArray([1, 2, ...[3, 4], 5]);
106  assertWeakArray([[[]]]);
107  assertWeakArray([[1], {}, [[3]]]);
108  assertWeakArray([[1], {}, [[3]]][0]);
109  assertWeakArray([[1], {}, [[3]]][2]);
110  assertWeakArray([[1], {}, [[3]]][2][0]);
111  assertWeakArray({a: [], b: {}}.a);
112})();
113
114(function StrongArrayLiterals() {
115  'use strong';
116  function assertStrongArray(x) {
117    assertTrue(%IsStrong(x));
118    assertSame(Array.prototype, Object.getPrototypeOf(x));
119  }
120  let [...r] = [];
121  assertStrongArray((function(...a) { return a; })());
122  assertStrongArray(r);
123  assertStrongArray([]);
124  assertStrongArray([1, 2, 3]);
125  assertStrongArray([1, 2, ...[3, 4], 5]);
126  assertStrongArray([[[]]]);
127  assertStrongArray([[1], {}, [[3]]]);
128  assertStrongArray([[1], {}, [[3]]][0]);
129  assertStrongArray([[1], {}, [[3]]][2]);
130  assertStrongArray([[1], {}, [[3]]][2][0]);
131  assertStrongArray({a: [], b: {}}.a);
132})();
133
134(function WeakFunctionLiterals() {
135  function assertWeakFunction(x) {
136    assertFalse(%IsStrong(x));
137    assertFalse(%IsStrong(x.prototype));
138    assertSame(Function.prototype, Object.getPrototypeOf(x));
139  }
140  function f() {}
141  assertWeakFunction(f);
142  assertWeakFunction(function(){});
143  assertWeakFunction(function f(){});
144  assertWeakFunction(() => {});
145  assertWeakFunction(x => x);
146  assertWeakFunction({m(){}}.m);
147  assertWeakFunction(Object.getOwnPropertyDescriptor(
148      {get a(){}}, 'a').get);
149  assertWeakFunction(Object.getOwnPropertyDescriptor(
150      {set a(x){}}, 'a').set);
151  assertWeakFunction((class {static m(){}}).m);
152  assertWeakFunction(Object.getOwnPropertyDescriptor(
153      class {static get a(){}}, 'a').get);
154  assertWeakFunction(Object.getOwnPropertyDescriptor(
155      class {static set a(x){}}, 'a').set);
156  assertWeakFunction((new class {m(){}}).m);
157  assertWeakFunction(Object.getOwnPropertyDescriptor(
158      (class {get a(){}}).prototype, 'a').get);
159  assertWeakFunction(Object.getOwnPropertyDescriptor(
160      (class {set a(x){}}).prototype, 'a').set);
161})();
162
163(function StrongFunctionLiterals() {
164  'use strong';
165  function assertStrongFunction(x) {
166    assertTrue(%IsStrong(x));
167    assertFalse('prototype' in x);
168    assertSame(Function.prototype, Object.getPrototypeOf(x));
169  }
170  function f() {}
171  assertStrongFunction(f);
172  assertStrongFunction(function(){});
173  assertStrongFunction(function f(){});
174  assertStrongFunction(() => {});
175  assertStrongFunction(x => x);
176  assertStrongFunction({m(){}}.m);
177  assertStrongFunction(Object.getOwnPropertyDescriptor(
178      {get a(){}}, 'a').get);
179  assertStrongFunction(Object.getOwnPropertyDescriptor(
180      {set a(x){}}, 'a').set);
181  assertStrongFunction((class {static m(){}}).m);
182  assertStrongFunction(Object.getOwnPropertyDescriptor(
183      class {static get a(){}}, 'a').get);
184  assertStrongFunction(Object.getOwnPropertyDescriptor(
185      class {static set a(x){}}, 'a').set);
186  assertStrongFunction((new class {m(){}}).m);
187  assertStrongFunction(Object.getOwnPropertyDescriptor(
188      (class {get a(){}}).prototype, 'a').get);
189  assertStrongFunction(Object.getOwnPropertyDescriptor(
190      (class {set a(x){}}).prototype, 'a').set);
191})();
192
193(function SelfStrongFunctionLiterals() {
194  function assertStrongFunction(x) {
195    assertTrue(%IsStrong(x));
196    assertFalse('prototype' in x);
197    assertSame(Function.prototype, Object.getPrototypeOf(x));
198  }
199  function f() {'use strong'}
200  assertStrongFunction(f);
201  assertStrongFunction(function(){'use strong'});
202  assertStrongFunction(function f(){'use strong'});
203  assertStrongFunction(() => {'use strong'});
204  assertStrongFunction(x => {'use strong'});
205  assertStrongFunction({m(){'use strong'}}.m);
206  assertStrongFunction(Object.getOwnPropertyDescriptor(
207      {get a(){'use strong'}}, 'a').get);
208  assertStrongFunction(Object.getOwnPropertyDescriptor(
209      {set a(x){'use strong'}}, 'a').set);
210  assertStrongFunction((class {static m(){'use strong'}}).m);
211  assertStrongFunction(Object.getOwnPropertyDescriptor(
212      class {static get a(){'use strong'}}, 'a').get);
213  assertStrongFunction(Object.getOwnPropertyDescriptor(
214      class {static set a(x){'use strong'}}, 'a').set);
215  assertStrongFunction((new class {m(){'use strong'}}).m);
216  assertStrongFunction(Object.getOwnPropertyDescriptor(
217      (class {get a(){'use strong'}}).prototype, 'a').get);
218  assertStrongFunction(Object.getOwnPropertyDescriptor(
219      (class {set a(x){'use strong'}}).prototype, 'a').set);
220})();
221
222let GeneratorPrototype = (function*(){}).__proto__;
223
224(function WeakGeneratorLiterals() {
225  function assertWeakGenerator(x) {
226    assertFalse(%IsStrong(x));
227    assertFalse(%IsStrong(x.prototype));
228    assertSame(GeneratorPrototype, Object.getPrototypeOf(x));
229    assertFalse(%IsStrong(x()));
230  }
231  function* g() {}
232  assertWeakGenerator(g);
233  assertWeakGenerator(function*(){});
234  assertWeakGenerator(function* g(){});
235  assertWeakGenerator({*m(){}}.m);
236  assertWeakGenerator((class {static *m(){}}).m);
237  assertWeakGenerator((new class {*m(){}}).m);
238})();
239
240(function StrongGeneratorLiterals() {
241  'use strong';
242  function assertStrongGenerator(x) {
243    assertTrue(%IsStrong(x));
244    // TODO(rossberg): strongify generator prototypes
245    // assertTrue(%IsStrong(x.prototype));
246    assertSame(GeneratorPrototype, Object.getPrototypeOf(x));
247    // TODO(rossberg): strongify generator instances
248    // assertTrue(%IsStrong(x()));
249  }
250  function* g() {}
251  assertStrongGenerator(g);
252  assertStrongGenerator(function*(){});
253  assertStrongGenerator(function* g(){});
254  assertStrongGenerator({*m(){}}.m);
255  assertStrongGenerator((class {static *m(){}}).m);
256  assertStrongGenerator((new class {*m(){}}).m);
257})();
258
259(function SelfStrongGeneratorLiterals() {
260  function assertStrongGenerator(x) {
261    assertTrue(%IsStrong(x));
262    // TODO(rossberg): strongify generator prototypes
263    // assertTrue(%IsStrong(x.prototype));
264    assertSame(GeneratorPrototype, Object.getPrototypeOf(x));
265    // TODO(rossberg): strongify generator instances
266    // assertTrue(%IsStrong(x()));
267  }
268  function* g() {'use strong'}
269  assertStrongGenerator(g);
270  assertStrongGenerator(function*(){'use strong'});
271  assertStrongGenerator(function* g(){'use strong'});
272  assertStrongGenerator({*m(){'use strong'}}.m);
273  assertStrongGenerator((class {static *m(){'use strong'}}).m);
274  assertStrongGenerator((new class {*m(){'use strong'}}).m);
275})();
276
277(function WeakRegExpLiterals() {
278  function assertWeakRegExp(x) {
279    assertFalse(%IsStrong(x));
280  }
281  assertWeakRegExp(/abc/);
282})();
283
284(function StrongRegExpLiterals() {
285  'use strong';
286  function assertStrongRegExp(x) {
287    // TODO(rossberg): strongify regexps
288    // assertTrue(%IsStrong(x));
289  }
290  assertStrongRegExp(/abc/);
291})();
292