Upgrade V8 to version 4.9.385.28
https://chromium.googlesource.com/v8/v8/+/4.9.385.28
FPIIM-449
Change-Id: I4b2e74289d4bf3667f2f3dc8aa2e541f63e26eb4
diff --git a/test/mjsunit/strong/literals.js b/test/mjsunit/strong/literals.js
new file mode 100644
index 0000000..6bdf0f0
--- /dev/null
+++ b/test/mjsunit/strong/literals.js
@@ -0,0 +1,291 @@
+// Copyright 2015 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: --strong-mode --allow-natives-syntax
+// Flags: --harmony-destructuring-bind
+
+'use strict';
+
+(function WeakObjectLiterals() {
+ 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: {}});
+ assertStrongObject({a: [], b: {}}.b);
+ assertStrongObject({a: {b: {c: {}}}}.a);
+ assertStrongObject({a: {b: {c: {}}}}.a.b);
+ assertStrongObject({a: {b: {c: {}}}}.a.b.c);
+ // Maps for literals with too many properties are not cached.
+ assertStrongObject({
+ x001: 0, x002: 0, x003: 0, x004: 0, x005: 0,
+ x006: 0, x007: 0, x008: 0, x009: 0, x010: 0,
+ x011: 0, x012: 0, x013: 0, x014: 0, x015: 0,
+ x016: 0, x017: 0, x018: 0, x019: 0, x020: 0,
+ x021: 0, x022: 0, x023: 0, x024: 0, x025: 0,
+ x026: 0, x027: 0, x028: 0, x029: 0, x030: 0,
+ x031: 0, x032: 0, x033: 0, x034: 0, x035: 0,
+ x036: 0, x037: 0, x038: 0, x039: 0, x040: 0,
+ x041: 0, x042: 0, x043: 0, x044: 0, x045: 0,
+ x046: 0, x047: 0, x048: 0, x049: 0, x050: 0,
+ x051: 0, x052: 0, x053: 0, x054: 0, x055: 0,
+ x056: 0, x057: 0, x058: 0, x059: 0, x060: 0,
+ x061: 0, x062: 0, x063: 0, x064: 0, x065: 0,
+ x066: 0, x067: 0, x068: 0, x069: 0, x070: 0,
+ x071: 0, x072: 0, x073: 0, x074: 0, x075: 0,
+ x076: 0, x077: 0, x078: 0, x079: 0, x080: 0,
+ x081: 0, x082: 0, x083: 0, x084: 0, x085: 0,
+ x086: 0, x087: 0, x088: 0, x089: 0, x090: 0,
+ x091: 0, x092: 0, x093: 0, x094: 0, x095: 0,
+ x096: 0, x097: 0, x098: 0, x099: 0, x100: 0,
+ x101: 0, x102: 0, x103: 0, x104: 0, x105: 0,
+ x106: 0, x107: 0, x108: 0, x109: 0, x110: 0,
+ x111: 0, x112: 0, x113: 0, x114: 0, x115: 0,
+ x116: 0, x117: 0, x118: 0, x119: 0, x120: 0,
+ x121: 0, x122: 0, x123: 0, x124: 0, x125: 0,
+ x126: 0, x127: 0, x128: 0, x129: 0, x130: 0,
+ x131: 0, x132: 0, x133: 0, x134: 0, x135: 0,
+ x136: 0, x137: 0, x138: 0, x139: 0, x140: 0,
+ x141: 0, x142: 0, x143: 0, x144: 0, x145: 0,
+ x146: 0, x147: 0, x148: 0, x149: 0, x150: 0,
+ x151: 0, x152: 0, x153: 0, x154: 0, x155: 0,
+ x156: 0, x157: 0, x158: 0, x159: 0, x160: 0,
+ x161: 0, x162: 0, x163: 0, x164: 0, x165: 0,
+ x166: 0, x167: 0, x168: 0, x169: 0, x170: 0,
+ x171: 0, x172: 0, x173: 0, x174: 0, x175: 0,
+ x176: 0, x177: 0, x178: 0, x179: 0, x180: 0,
+ x181: 0, x182: 0, x183: 0, x184: 0, x185: 0,
+ x186: 0, x187: 0, x188: 0, x189: 0, x190: 0,
+ 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(){}})"));
+})();
+
+(function WeakArrayLiterals(...args) {
+ function assertWeakArray(x) {
+ assertFalse(%IsStrong(x));
+ assertSame(Array.prototype, Object.getPrototypeOf(x));
+ }
+ let [...r] = [];
+ 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() {
+ 'use strong';
+ function assertStrongArray(x) {
+ assertTrue(%IsStrong(x));
+ assertSame(Array.prototype, Object.getPrototypeOf(x));
+ }
+ let [...r] = [];
+ assertStrongArray((function(...a) { return a; })());
+ assertStrongArray(r);
+ assertStrongArray([]);
+ assertStrongArray([1, 2, 3]);
+ assertStrongArray([1, 2, ...[3, 4], 5]);
+ assertStrongArray([[[]]]);
+ assertStrongArray([[1], {}, [[3]]]);
+ assertStrongArray([[1], {}, [[3]]][0]);
+ 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() {}
+ 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(){});
+ assertStrongFunction(function f(){});
+ assertStrongFunction(() => {});
+ assertStrongFunction(x => x);
+ assertStrongFunction({m(){}}.m);
+ assertStrongFunction(Object.getOwnPropertyDescriptor(
+ {get a(){}}, 'a').get);
+ assertStrongFunction(Object.getOwnPropertyDescriptor(
+ {set a(x){}}, 'a').set);
+ assertStrongFunction((class {static m(){}}).m);
+ assertStrongFunction(Object.getOwnPropertyDescriptor(
+ class {static get a(){}}, 'a').get);
+ assertStrongFunction(Object.getOwnPropertyDescriptor(
+ class {static set a(x){}}, 'a').set);
+ assertStrongFunction((new class {m(){}}).m);
+ assertStrongFunction(Object.getOwnPropertyDescriptor(
+ (class {get a(){}}).prototype, 'a').get);
+ assertStrongFunction(Object.getOwnPropertyDescriptor(
+ (class {set a(x){}}).prototype, 'a').set);
+})();
+
+(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'});
+ assertStrongFunction(function f(){'use strong'});
+ assertStrongFunction(() => {'use strong'});
+ assertStrongFunction(x => {'use strong'});
+ assertStrongFunction({m(){'use strong'}}.m);
+ assertStrongFunction(Object.getOwnPropertyDescriptor(
+ {get a(){'use strong'}}, 'a').get);
+ assertStrongFunction(Object.getOwnPropertyDescriptor(
+ {set a(x){'use strong'}}, 'a').set);
+ assertStrongFunction((class {static m(){'use strong'}}).m);
+ assertStrongFunction(Object.getOwnPropertyDescriptor(
+ class {static get a(){'use strong'}}, 'a').get);
+ assertStrongFunction(Object.getOwnPropertyDescriptor(
+ class {static set a(x){'use strong'}}, 'a').set);
+ assertStrongFunction((new class {m(){'use strong'}}).m);
+ assertStrongFunction(Object.getOwnPropertyDescriptor(
+ (class {get a(){'use strong'}}).prototype, 'a').get);
+ assertStrongFunction(Object.getOwnPropertyDescriptor(
+ (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() {}
+ 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*(){});
+ assertStrongGenerator(function* g(){});
+ assertStrongGenerator({*m(){}}.m);
+ assertStrongGenerator((class {static *m(){}}).m);
+ assertStrongGenerator((new class {*m(){}}).m);
+})();
+
+(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'});
+ assertStrongGenerator(function* g(){'use strong'});
+ assertStrongGenerator({*m(){'use strong'}}.m);
+ assertStrongGenerator((class {static *m(){'use strong'}}).m);
+ assertStrongGenerator((new class {*m(){'use strong'}}).m);
+})();
+
+(function WeakRegExpLiterals() {
+ function assertWeakRegExp(x) {
+ assertFalse(%IsStrong(x));
+ }
+ assertWeakRegExp(/abc/);
+})();
+
+(function StrongRegExpLiterals() {
+ 'use strong';
+ function assertStrongRegExp(x) {
+ // TODO(rossberg): strongify regexps
+ // assertTrue(%IsStrong(x));
+ }
+ assertStrongRegExp(/abc/);
+})();