diff options
Diffstat (limited to 'js/src/tests/non262/class')
99 files changed, 3907 insertions, 0 deletions
diff --git a/js/src/tests/non262/class/boundFunctionSubclassing.js b/js/src/tests/non262/class/boundFunctionSubclassing.js new file mode 100644 index 0000000000..be9058bb9e --- /dev/null +++ b/js/src/tests/non262/class/boundFunctionSubclassing.js @@ -0,0 +1,37 @@ +class func extends Function { } +let inst = new func("x", "return this.bar + x"); + +// First, ensure that we get sane prototype chains for the bound instance +let bound = inst.bind({bar: 3}, 4); +assertEq(bound instanceof func, true); +assertEq(bound(), 7); + +// Check the corner case for Function.prototype.bind where the function has +// a null [[Prototype]] +Object.setPrototypeOf(inst, null); +bound = Function.prototype.bind.call(inst, {bar:1}, 3); +assertEq(Object.getPrototypeOf(bound), null); +assertEq(bound(), 4); + +// Check that we actually pass the proper new.target when calling super() +function toBind() { } + +var boundArgs = []; +for (let i = 0; i < 5; i++) { + boundArgs.push(i); + let bound = toBind.bind(undefined, ...boundArgs); + + // We have to wire it up by hand to allow us to use a bound function + // as a superclass, but it's doable. + bound.prototype = {}; + class test extends bound { }; + let passedArgs = []; + for (let j = 0; j < 15; j++) { + passedArgs.push(j); + assertEq(Object.getPrototypeOf(new test(...passedArgs)), test.prototype); + } +} + + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/browser.js b/js/src/tests/non262/class/browser.js new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/js/src/tests/non262/class/browser.js diff --git a/js/src/tests/non262/class/bytecodePatternMatching.js b/js/src/tests/non262/class/bytecodePatternMatching.js new file mode 100644 index 0000000000..446184f805 --- /dev/null +++ b/js/src/tests/non262/class/bytecodePatternMatching.js @@ -0,0 +1,29 @@ +// Constructors can't be called so we can't pattern match +// them in replace and sort. +function a() { + var b = {a: "A"}; + + class X { + constructor(a) { + return b[a] + } + }; + + assertThrowsInstanceOf(() => "a".replace(/a/, X), TypeError); +} + +function b() { + class X { + constructor(x, y) { + return x - y; + } + } + + assertThrowsInstanceOf(() => [1, 2, 3].sort(X), TypeError); +} + +a(); +b(); + +if (typeof reportCompare === "function") + reportCompare(0, 0, "OK"); diff --git a/js/src/tests/non262/class/classConstructorNoCall.js b/js/src/tests/non262/class/classConstructorNoCall.js new file mode 100644 index 0000000000..f59f87b9c5 --- /dev/null +++ b/js/src/tests/non262/class/classConstructorNoCall.js @@ -0,0 +1,21 @@ +// Class constructors don't have a [[Call]] +class Foo { + constructor() { } +} + +assertThrowsInstanceOf(Foo, TypeError); + +class Bar extends Foo { + constructor() { } +} + +assertThrowsInstanceOf(Bar, TypeError); + +assertThrowsInstanceOf(class { constructor() { } }, TypeError); +assertThrowsInstanceOf(class extends Foo { constructor() { } }, TypeError); + +assertThrowsInstanceOf(class foo { constructor() { } }, TypeError); +assertThrowsInstanceOf(class foo extends Foo { constructor() { } }, TypeError); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/classHeritage.js b/js/src/tests/non262/class/classHeritage.js new file mode 100644 index 0000000000..478c23fc21 --- /dev/null +++ b/js/src/tests/non262/class/classHeritage.js @@ -0,0 +1,97 @@ +// It's an error to have a non-constructor as your heritage +assertThrowsInstanceOf(() => eval(`class a extends Math.sin { + constructor() { } + }`), TypeError); +assertThrowsInstanceOf(() => eval(`(class a extends Math.sin { + constructor() { } + })`), TypeError); + +// Unless it's null, in which case it works like a normal class, except that +// the prototype object does not inherit from Object.prototype. +class basic { + constructor() { } +} +class nullExtends extends null { + constructor() { } +} +var nullExtendsExpr = class extends null { constructor() { } }; + +assertEq(Object.getPrototypeOf(basic), Function.prototype); +assertEq(Object.getPrototypeOf(basic.prototype), Object.prototype); + +for (let extension of [nullExtends, nullExtendsExpr]) { + assertEq(Object.getPrototypeOf(extension), Function.prototype); + assertEq(Object.getPrototypeOf(extension.prototype), null); +} + +var baseMethodCalled; +var staticMethodCalled; +var overrideCalled; +class base { + constructor() { }; + method() { baseMethodCalled = true; } + static staticMethod() { staticMethodCalled = true; } + override() { overrideCalled = "base" } +} +class derived extends base { + constructor() { super(); }; + override() { overrideCalled = "derived"; } +} +var derivedExpr = class extends base { + constructor() { super(); }; + override() { overrideCalled = "derived"; } +}; + +// Make sure we get the right object layouts. +for (let extension of [derived, derivedExpr]) { + baseMethodCalled = false; + staticMethodCalled = false; + overrideCalled = ""; + // Make sure we get the right object layouts. + assertEq(Object.getPrototypeOf(extension), base); + assertEq(Object.getPrototypeOf(extension.prototype), base.prototype); + + // We do inherit the methods, right? + (new extension()).method(); + assertEq(baseMethodCalled, true); + + // But we can still override them? + (new extension()).override(); + assertEq(overrideCalled, "derived"); + + // What about the statics? + extension.staticMethod(); + assertEq(staticMethodCalled, true); +} + +// Gotta extend an object, or null. +function nope() { + class Foo extends "Bar" { + constructor() { } + } +} +function nopeExpr() { + (class extends "Bar" { + constructor() { } + }); +} +assertThrowsInstanceOf(nope, TypeError); +assertThrowsInstanceOf(nopeExpr, TypeError); + +// The .prototype of the extension must be an object, or null. +nope.prototype = "not really, no"; +function stillNo() { + class Foo extends nope { + constructor() { } + } +} +function stillNoExpr() { + (class extends nope { + constructor() { } + }); +} +assertThrowsInstanceOf(stillNo, TypeError); +assertThrowsInstanceOf(stillNoExpr, TypeError); + +if (typeof reportCompare === "function") + reportCompare(0, 0, "OK"); diff --git a/js/src/tests/non262/class/className.js b/js/src/tests/non262/class/className.js new file mode 100644 index 0000000000..e72510e18d --- /dev/null +++ b/js/src/tests/non262/class/className.js @@ -0,0 +1,248 @@ +function testName(C, name, hasValue, hasGetter, hasSetter, isFunction=false) { + if (isFunction) { + assertEq(typeof C.name, "function"); + } else { + assertEq(C.name, name); + } + + var desc = Object.getOwnPropertyDescriptor(C, "name"); + if (!hasValue && !hasGetter && !hasSetter) { + assertEq(desc, undefined); + return; + } + + if (hasValue) { + assertEq("value" in desc, true); + if (isFunction) { + assertEq(typeof desc.value, "function"); + } else { + assertEq(desc.value, name); + } + // FIXME: Methods defined in classes should not be enumerable + // (bug 1144630). + // assertEq(desc.enumerable, false); + assertEq(desc.configurable, true); + + assertEq("get" in desc, false); + assertEq("set" in desc, false); + + return; + } + + assertEq("value" in desc, false); + + if (hasGetter) { + assertEq("get" in desc, true); + assertEq(desc.get(), name); + // assertEq(desc.enumerable, false); + assertEq(desc.configurable, true); + } else { + assertEq("get" in desc, true); + assertEq(desc.get, undefined); + // assertEq(desc.enumerable, false); + assertEq(desc.configurable, true); + } + + if (hasSetter) { + assertEq("set" in desc, true); + assertEq(typeof desc.set, "function"); + // assertEq(desc.enumerable, false); + assertEq(desc.configurable, true); + } else { + assertEq("set" in desc, true); + assertEq(desc.set, undefined); + // assertEq(desc.enumerable, false); + assertEq(desc.configurable, true); + } +} + +// ---- declaration --- + +class Decl { + constructor() {} +} +testName(Decl, "Decl", true, false, false); + +class DeclWithFunc { + constructor() {} + static name() {} +} +testName(DeclWithFunc, "DeclWithFunc", true, false, false, true); + +class DeclWithGetter { + constructor() {} + static get name() { return "base"; } +} +testName(DeclWithGetter, "base", false, true, false); + +class DeclWithSetter { + constructor() {} + static set name(v) {} +} +testName(DeclWithSetter, undefined, false, false, true); + +class DeclWithGetterSetter { + constructor() {} + static get name() { return "base"; } + static set name(v) {} +} +testName(DeclWithGetterSetter, "base", false, true, true); + +function prop() { + return "name"; +} +class DeclWithComputed { + constructor() {} + static get [prop()]() { return "base"; } +} +testName(DeclWithGetterSetter, "base", false, true, true); + +class ExtendedDecl1 extends Decl { + constructor() {} +} +testName(ExtendedDecl1, "ExtendedDecl1", true, false, false); +delete ExtendedDecl1.name; +testName(ExtendedDecl1, "Decl", false, false, false); + +class ExtendedDecl2 extends DeclWithGetterSetter { + constructor() {} + static get name() { return "extend"; } +} +testName(ExtendedDecl2, "extend", false, true, false); +delete ExtendedDecl2.name; +testName(ExtendedDecl2, "base", false, false, false); + +class ExtendedDecl3 extends DeclWithGetterSetter { + constructor() {} + static set name(v) {} +} +testName(ExtendedDecl3, undefined, false, false, true); +delete ExtendedDecl3.name; +testName(ExtendedDecl3, "base", false, false, false); + +// ---- expression --- + +let Expr = class Expr { + constructor() {} +}; +testName(Expr, "Expr", true, false, false); + +let ExprWithGetter = class ExprWithGetter { + constructor() {} + static get name() { return "base"; } +}; +testName(ExprWithGetter, "base", false, true, false); + +let ExprWithSetter = class ExprWithSetter { + constructor() {} + static set name(v) {} +}; +testName(ExprWithSetter, undefined, false, false, true); + +let ExprWithGetterSetter = class ExprWithGetterSetter { + constructor() {} + static get name() { return "base"; } + static set name(v) {} +}; +testName(ExprWithGetterSetter, "base", false, true, true); + + +let ExtendedExpr1 = class ExtendedExpr1 extends Expr { + constructor() {} +}; +testName(ExtendedExpr1, "ExtendedExpr1", true, false, false); +delete ExtendedExpr1.name; +testName(ExtendedExpr1, "Expr", false, false, false); + +let ExtendedExpr2 = class ExtendedExpr2 extends ExprWithGetterSetter { + constructor() {} + static get name() { return "extend"; } +}; +testName(ExtendedExpr2, "extend", false, true, false); +delete ExtendedExpr2.name; +testName(ExtendedExpr2, "base", false, false, false); + +let ExtendedExpr3 = class ExtendedExpr3 extends ExprWithGetterSetter { + constructor() {} + static set name(v) {} +}; +testName(ExtendedExpr3, undefined, false, false, true); +delete ExtendedExpr3.name; +testName(ExtendedExpr3, "base", false, false, false); + +// ---- anonymous ---- + +// Anonymous class expressions use the empty string as the default name property. +// Use property assignment to avoid setting name property. +let tmp = {}; +let Anon = tmp.value = class { + constructor() {} +}; +testName(Anon, "", true, false, false); + +let AnonDefault = tmp.value = class { }; +testName(AnonDefault, "", true, false, false); + +let AnonWithGetter = tmp.value = class { + constructor() {} + static get name() { return "base"; } +}; +testName(AnonWithGetter, "base", false, true, false); + +let AnonWithSetter = tmp.value = class { + constructor() {} + static set name(v) {} +}; +testName(AnonWithSetter, undefined, false, false, true); + +let AnonWithGetterSetter = tmp.value = class { + constructor() {} + static get name() { return "base"; } + static set name(v) {} +}; +testName(AnonWithGetterSetter, "base", false, true, true); + + +let ExtendedAnon1 = tmp.value = class extends Anon { + constructor() {} +}; +testName(ExtendedAnon1, "", true, false, false); + +let ExtendedAnonDefault = tmp.value = class extends Anon { }; +testName(ExtendedAnonDefault, "", true, false, false); + +let ExtendedAnon2 = tmp.value = class extends AnonWithGetterSetter { + constructor() {} + static get name() { return "extend"; } +}; +testName(ExtendedAnon2, "extend", false, true, false); +delete ExtendedAnon2.name; +testName(ExtendedAnon2, "base", false, false, false); + +let ExtendedAnon3 = tmp.value = class extends AnonWithGetterSetter { + constructor() {} + static set name(v) {} +}; +testName(ExtendedAnon3, undefined, false, false, true); +delete ExtendedAnon3.name; +testName(ExtendedAnon3, "base", false, false, false); + +// ---- mixed ---- + +let ExtendedExpr4 = class ExtendedExpr4 extends Anon { + constructor() {} +} +testName(ExtendedExpr4, "ExtendedExpr4", true, false, false); +delete ExtendedExpr4.name; +testName(ExtendedExpr4, "", false, false, false); + +let ExtendedExpr5 = class ExtendedExpr5 extends AnonWithGetterSetter { + constructor() {} + static get name() { return "extend"; } +} +testName(ExtendedExpr5, "extend", false, true, false); +delete ExtendedExpr5.name; +testName(ExtendedExpr5, "base", false, false, false); + +if (typeof reportCompare === "function") + reportCompare(0, 0, "OK"); diff --git a/js/src/tests/non262/class/classPrototype.js b/js/src/tests/non262/class/classPrototype.js new file mode 100644 index 0000000000..0d2296037c --- /dev/null +++ b/js/src/tests/non262/class/classPrototype.js @@ -0,0 +1,65 @@ +// The prototype of a class is a non-writable, non-configurable, non-enumerable data property. +class a { constructor() { } } +let b = class { constructor() { } }; +for (let test of [a,b]) { + var protoDesc = Object.getOwnPropertyDescriptor(test, "prototype"); + assertEq(protoDesc.writable, false); + assertEq(protoDesc.configurable, false); + assertEq(protoDesc.enumerable, false); + + var prototype = protoDesc.value; + assertEq(typeof prototype, "object"); + assertEq(Object.getPrototypeOf(prototype), Object.prototype); + assertEq(Object.isExtensible(prototype), true); + + var desiredPrototype = {}; + Object.defineProperty(desiredPrototype, "constructor", { writable: true, + configurable: true, + enumerable: false, + value: test }); + assertDeepEq(prototype, desiredPrototype); +} + +// As such, it should by a TypeError to try and overwrite "prototype" with a +// static member. The only way to try is with a computed property name; the rest +// are early errors. +assertThrowsInstanceOf(() => eval(` + class a { + constructor() { }; + static ["prototype"]() { } + } + `), TypeError); +assertThrowsInstanceOf(() => eval(` + class a { + constructor() { }; + static get ["prototype"]() { } + } + `), TypeError); +assertThrowsInstanceOf(() => eval(` + class a { + constructor() { }; + static set ["prototype"](x) { } + } + `), TypeError); + +assertThrowsInstanceOf(() => eval(`( + class a { + constructor() { }; + static ["prototype"]() { } + } + )`), TypeError); +assertThrowsInstanceOf(() => eval(`( + class a { + constructor() { }; + static get ["prototype"]() { } + } + )`), TypeError); +assertThrowsInstanceOf(() => eval(`( + class a { + constructor() { }; + static set ["prototype"](x) { } + } + )`), TypeError); + +if (typeof reportCompare === "function") + reportCompare(0, 0, "OK"); diff --git a/js/src/tests/non262/class/compPropDestr.js b/js/src/tests/non262/class/compPropDestr.js new file mode 100644 index 0000000000..2bd8cbd49a --- /dev/null +++ b/js/src/tests/non262/class/compPropDestr.js @@ -0,0 +1,11 @@ +var BUGNUMBER = 924688; +var summary = 'Computed Property Names'; + +print(BUGNUMBER + ": " + summary); + +var key = "z"; +var { [key]: foo } = { z: "bar" }; +assertEq(foo, "bar"); + +if (typeof reportCompare === 'function') + reportCompare(0, 0, "ok"); diff --git a/js/src/tests/non262/class/compPropNames.js b/js/src/tests/non262/class/compPropNames.js new file mode 100644 index 0000000000..1c4064d8a5 --- /dev/null +++ b/js/src/tests/non262/class/compPropNames.js @@ -0,0 +1,243 @@ +var BUGNUMBER = 924688; +var summary = 'Computed Property Names'; + +print(BUGNUMBER + ": " + summary); + +// Function definitions. +function syntaxError (script) { + try { + Function(script); + } catch (e) { + if (e instanceof SyntaxError) { + return; + } + } + throw new Error('Expected syntax error: ' + script); +} + + +// Tests begin. + +assertThrowsInstanceOf(function() { var a = {[field1]: "a", [field2]: "b"}; }, ReferenceError); + +assertThrowsInstanceOf(function() { + field1 = 1; + var a = {[field1]: "a", [field2]: "b"}; + }, ReferenceError); + +var f1 = 1; +var f2 = 2; +var a = {[f1]: "a", [f2]: "b"}; +assertEq(a[1], "a"); +assertEq(a[2], "b"); + +var a = {[f1]: "a", f2: "b"}; +assertEq(a[1], "a"); +assertEq(a.f2, "b"); + +var a = {["f1"]: "a", [++f2]: "b"}; +assertEq(a.f1, "a"); +assertEq(a[3], "b"); + +var a = {["f1"]: "a", f2: "b"}; +assertEq(a.f1, "a"); +assertEq(a.f2, "b"); + + +var i = 0; +var a = { + ["foo" + ++i]: i, + ["foo" + ++i]: i, + ["foo" + ++i]: i +}; +assertEq(a.foo1, 1); +assertEq(a.foo2, 2); +assertEq(a.foo3, 3); + +var expr = "abc"; +syntaxError("({["); +syntaxError("({[expr"); +syntaxError("({[expr]"); +syntaxError("({[expr]})"); +syntaxError("({[expr] 0})"); +syntaxError("({[expr], 0})"); +syntaxError("[[expr]: 0]"); +syntaxError("({[expr]: name: 0})"); +syntaxError("({[1, 2]: 3})"); // because '1,2' is an Expression but not an AssignmentExpression +syntaxError("({[1;]: 1})"); // and not an ExpressionStatement +syntaxError("({[if (0) 0;]})"); // much less a Statement +syntaxError("function f() { {[x]: 1} }"); // that's not even an ObjectLiteral +syntaxError("function f() { [x]: 1 }"); // or that +syntaxError('a = {[f1@]: "a", [f2]: "b"}'); // unexpected symbol at end of AssignmentExpression +try { JSON.parse('{["a"]:4}'); } catch(e) { + if (!(e instanceof SyntaxError)) throw new Error('Expected syntax error'); +} + +// Property characteristics. +a = { ["b"] : 4 }; +b = Object.getOwnPropertyDescriptor(a, "b"); +assertEq(b.configurable, true); +assertEq(b.enumerable, true); +assertEq(b.writable, true); +assertEq(b.value, 4); + +// Setter and getter are not hit. +Object.defineProperty(Object.prototype, "x", { set: function (x) { throw "FAIL"; }, + get: function (x) { throw "FAIL"; } }); +var a = {["x"]: 0}; +assertEq(a.x, 0); + +a = {["x"]: 1, ["x"]: 2}; +assertEq(a.x, 2); +a = {x: 1, ["x"]: 2}; +assertEq(a.x, 2); +a = {["x"]: 1, x: 2}; +assertEq(a.x, 2); + +// Symbols +var unique_sym = Symbol("1"), registered_sym = Symbol.for("2"); +a = { [unique_sym] : 2, [registered_sym] : 3 }; +assertEq(a[unique_sym], 2); +assertEq(a[registered_sym], 3); + +// Same expression can be run several times to build objects with different property names. +a = []; +for (var i = 0; i < 3; i++) { + a[i] = {["foo" + i]: i}; +} +assertEq(a[0].foo0, 0); +assertEq(a[1].foo1, 1); +assertEq(a[2].foo2, 2); + +// Following are stored in object's elements rather than slots. +var i = 0; +a = { [++i] : i, + [++i] : i, + [++i] : i, + [++i] : i, + [++i] : i, + [++i] : i, + [++i] : i, + [++i] : i +} +for (var i = 1; i < 9; i++) + assertEq(a[i], i); +syntaxError("a.1"); +syntaxError("a.2"); +syntaxError("a.3"); +syntaxError("a.4"); +syntaxError("a.5"); +syntaxError("a.6"); +syntaxError("a.7"); +syntaxError("a.8"); + +// Adding a single large index. +var i = 0; +a = { [++i] : i, + [++i] : i, + [++i] : i, + [++i] : i, + [++i] : i, + [++i] : i, + [++i] : i, + [++i] : i, + [3000] : 2999 +} +for (var i = 1; i < 9; i++) + assertEq(a[i], i); +assertEq(a[3000], 2999); + +// Defining several properties using eval. +var code = "({"; +for (i = 0; i < 1000; i++) + code += "['foo' + " + i + "]: 'ok', " +code += "['bar']: 'ok'});"; +var obj = eval(code); +for (i = 0; i < 1000; i++) + assertEq(obj["foo" + i], "ok"); +assertEq(obj["bar"], "ok"); + +// Can yield in a computed property name which is in a generator. +function* g() { + var a = { [yield 1]: 2, [yield 2]: 3}; + return a; +} + +var it = g(); +var next = it.next(); +assertEq(next.done, false); +assertEq(next.value, 1); +next = it.next("hello"); +assertEq(next.done, false); +assertEq(next.value, 2); +next = it.next("world"); +assertEq(next.done, true); +assertEq(next.value.hello, 2); +assertEq(next.value.world, 3); + +// get and set. +expr = "abc"; +syntaxError("({get ["); +syntaxError("({get [expr()"); +syntaxError("({get [expr]()"); +syntaxError("({get [expr]()})"); +syntaxError("({get [expr] 0 ()})"); +syntaxError("({get [expr], 0(})"); +syntaxError("[get [expr]: 0()]"); +syntaxError("({get [expr](: name: 0})"); +syntaxError("({get [1, 2](): 3})"); +syntaxError("({get [1;](): 1})"); +syntaxError("({get [if (0) 0;](){}})"); +syntaxError("({set [(a)"); +syntaxError("({set [expr(a)"); +syntaxError("({set [expr](a){}"); +syntaxError("({set [expr]}(a)"); +syntaxError("({set [expr](a), 0})"); +syntaxError("[set [expr](a): 0]"); +syntaxError("({set [expr](a): name: 0})"); +syntaxError("({set [1, 2](a) {return 3;}})"); +syntaxError("({set [1;](a) {return 1}})"); +syntaxError("({set [if (0) 0;](a){}})"); +syntaxError("function f() { {get [x](): 1} }"); +syntaxError("function f() { get [x](): 1 }"); +syntaxError("function f() { {set [x](a): 1} }"); +syntaxError("function f() { set [x](a): 1 }"); +f1 = "abc"; +syntaxError('a = {get [f1@](){}, set [f1](a){}}'); // unexpected symbol at end of AssignmentExpression +syntaxError('a = {get@ [f1](){}, set [f1](a){}}'); // unexpected symbol after get +syntaxError('a = {get [f1](){}, set@ [f1](a){}}'); // unexpected symbol after set + +expr = "hey"; +a = {get [expr]() { return 3; }, set[expr](v) { throw 2; }}; +assertEq(a.hey, 3); +assertThrowsValue(() => { a.hey = 5; }, 2); + +// Symbols with duplicate get and set. +expr = Symbol("hey"); +a = {get [expr]() { return 3; }, set[expr](v) { throw 2; }, + set [expr] (w) { throw 4; }, get[expr](){return 5; }}; +assertEq(a[expr], 5); +assertThrowsValue(() => { a[expr] = 7; }, 4); + +// expressions with side effects are called in the right order +log = ""; +obj = { + "a": log += 'a', + get [log += 'b']() {}, + [log += 'c']: log += 'd', + set [log += 'e'](a) {} +}; +assertEq(log, "abcde"); + +// assignment expressions, objects and regex in computed names +obj = { + get [a = "hey"]() { return 1; }, + get [a = {b : 4}.b]() { return 2; }, + set [/x/.source](a) { throw 3; } +} +assertEq(obj.hey, 1); +assertEq(obj[4], 2); +assertThrowsValue(() => { obj.x = 7; }, 3); + +if (typeof reportCompare === 'function') + reportCompare(0, 0, "ok"); diff --git a/js/src/tests/non262/class/constructorCalled.js b/js/src/tests/non262/class/constructorCalled.js new file mode 100644 index 0000000000..144cc08c79 --- /dev/null +++ b/js/src/tests/non262/class/constructorCalled.js @@ -0,0 +1,45 @@ +// The constructor specified should get called, regardless of order, or +// other distractions + +var called = false; +class a { constructor(x) { assertEq(x, 4); called = true } } +new a(4); +assertEq(called, true); + +called = false; +var aExpr = class { constructor(x) { assertEq(x, 4); called = true } }; +new aExpr(4); +assertEq(called, true); + +called = false; +class b { constructor() { called = true } method() { } } +new b(); +assertEq(called, true); + +called = false; +var bExpr = class { constructor() { called = true } method() { } }; +new bExpr(); +assertEq(called, true); + +called = false; +class c { method() { } constructor() { called = true; } } +new c(); +assertEq(called, true); + +called = false; +var cExpr = class { method() { } constructor() { called = true; } } +new cExpr(); +assertEq(called, true); + +called = false; +class d { ["constructor"]() { throw new Error("NO"); } constructor() { called = true; } } +new d(); +assertEq(called, true); + +called = false; +var dExpr = class { ["constructor"]() { throw new Error("NO"); } constructor() { called = true; } } +new dExpr(); +assertEq(called, true); + +if (typeof reportCompare === "function") + reportCompare(0, 0, "OK"); diff --git a/js/src/tests/non262/class/defaultConstructorBase.js b/js/src/tests/non262/class/defaultConstructorBase.js new file mode 100644 index 0000000000..2d977935dd --- /dev/null +++ b/js/src/tests/non262/class/defaultConstructorBase.js @@ -0,0 +1,18 @@ +class base { + method() { return 1; } + *gen() { return 2; } + static sMethod() { return 3; } + get answer() { return 42; } +} + +// Having a default constructor should work, and also not make you lose +// everything for no good reason + +assertEq(Object.getPrototypeOf(new base()), base.prototype); +assertEq(new base().method(), 1); +assertEq(new base().gen().next().value, 2); +assertEq(base.sMethod(), 3); +assertEq(new base().answer, 42); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/defaultConstructorDerivedSpread.js b/js/src/tests/non262/class/defaultConstructorDerivedSpread.js new file mode 100644 index 0000000000..4de18ec2fb --- /dev/null +++ b/js/src/tests/non262/class/defaultConstructorDerivedSpread.js @@ -0,0 +1,23 @@ +/* Make sure that the default derived class constructor has the required spread semantics. + * + * Test credit André Bargull + */ + +// <https://github.com/tc39/ecma262/pull/2216> changed default derived class +// constructors to no longer execute the spread iteration protocol. +Array.prototype[Symbol.iterator] = function*() { + throw new Error("unexpected call"); +}; + +class Base { + constructor(a, b) { + assertEq(a, 1); + assertEq(b, 2); + } +}; +class Derived extends Base {}; + +new Derived(1, 2); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/defaultConstructorNotCallable.js b/js/src/tests/non262/class/defaultConstructorNotCallable.js new file mode 100644 index 0000000000..558f8dcc2f --- /dev/null +++ b/js/src/tests/non262/class/defaultConstructorNotCallable.js @@ -0,0 +1,8 @@ +class badBase {} +assertThrowsInstanceOf(badBase, TypeError); + +class badSub extends (class {}) {} +assertThrowsInstanceOf(badSub, TypeError); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/derivedConstructorArrowEvalBinding.js b/js/src/tests/non262/class/derivedConstructorArrowEvalBinding.js new file mode 100644 index 0000000000..d6b15baab3 --- /dev/null +++ b/js/src/tests/non262/class/derivedConstructorArrowEvalBinding.js @@ -0,0 +1,12 @@ +// Make sure it doesn't matter when we make the arrow function +new class extends class { } { + constructor() { + let arrow = () => this; + assertThrowsInstanceOf(arrow, ReferenceError); + super(); + assertEq(arrow(), this); + } +}(); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/derivedConstructorArrowEvalClosed.js b/js/src/tests/non262/class/derivedConstructorArrowEvalClosed.js new file mode 100644 index 0000000000..431a73c92f --- /dev/null +++ b/js/src/tests/non262/class/derivedConstructorArrowEvalClosed.js @@ -0,0 +1,11 @@ +new class extends class { } { + constructor() { + let a1 = () => this; + let a2 = (() => super()); + assertThrowsInstanceOf(a1, ReferenceError); + assertEq(a2(), a1()); + } +}(); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/derivedConstructorArrowEvalEscape.js b/js/src/tests/non262/class/derivedConstructorArrowEvalEscape.js new file mode 100644 index 0000000000..2676d4b946 --- /dev/null +++ b/js/src/tests/non262/class/derivedConstructorArrowEvalEscape.js @@ -0,0 +1,13 @@ +let arrow; + +class foo extends class { } { + constructor() { + arrow = () => this; + super(); + } +} + +assertEq(new foo(), arrow()); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/derivedConstructorArrowEvalEscapeUninitialized.js b/js/src/tests/non262/class/derivedConstructorArrowEvalEscapeUninitialized.js new file mode 100644 index 0000000000..970beb0436 --- /dev/null +++ b/js/src/tests/non262/class/derivedConstructorArrowEvalEscapeUninitialized.js @@ -0,0 +1,38 @@ +let superArrow; +let thisArrow; + +let thisStash; + +class base { + constructor() { + // We run this constructor twice as part of the double init check + if (!thisStash) + thisStash = {prop:45}; + return thisStash; + } +} + +class foo extends base { + constructor() { + superArrow = (()=>super()); + thisArrow = ()=>this; + } +} + +// Populate the arrow function saves. Since we never invoke super(), we throw +assertThrowsInstanceOf(()=>new foo(), ReferenceError); + +// No |this| binding in the closure, yet +assertThrowsInstanceOf(thisArrow, ReferenceError); + +// call super() +superArrow(); + +// Can't call it twice +assertThrowsInstanceOf(superArrow, ReferenceError); + +// Oh look, |this| is populated, now. +assertEq(thisArrow(), thisStash); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/derivedConstructorArrowEvalGetThis.js b/js/src/tests/non262/class/derivedConstructorArrowEvalGetThis.js new file mode 100644 index 0000000000..26f9843d2c --- /dev/null +++ b/js/src/tests/non262/class/derivedConstructorArrowEvalGetThis.js @@ -0,0 +1,10 @@ +new class extends class { } { + constructor() { + super(); + assertEq(this, (()=>this)()); + assertEq(this, eval("this")); + } +}(); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/derivedConstructorArrowEvalNestedSuperCall.js b/js/src/tests/non262/class/derivedConstructorArrowEvalNestedSuperCall.js new file mode 100644 index 0000000000..d81f186485 --- /dev/null +++ b/js/src/tests/non262/class/derivedConstructorArrowEvalNestedSuperCall.js @@ -0,0 +1,34 @@ +new class extends class { } { + constructor() { + (()=>eval("super()"))(); + assertEq(this, eval("this")); + assertEq(this, (()=>this)()); + } +}(); + +new class extends class { } { + constructor() { + (()=>(()=>super())())(); + assertEq(this, eval("this")); + assertEq(this, (()=>this)()); + } +}(); + +new class extends class { } { + constructor() { + eval("(()=>super())()"); + assertEq(this, eval("this")); + assertEq(this, (()=>this)()); + } +}(); + +new class extends class { } { + constructor() { + eval("eval('super()')"); + assertEq(this, eval("this")); + assertEq(this, (()=>this)()); + } +}(); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/derivedConstructorArrowEvalSuperCall.js b/js/src/tests/non262/class/derivedConstructorArrowEvalSuperCall.js new file mode 100644 index 0000000000..0f60df7465 --- /dev/null +++ b/js/src/tests/non262/class/derivedConstructorArrowEvalSuperCall.js @@ -0,0 +1,18 @@ +new class extends class { } { + constructor() { + assertEq(eval("super(); this"), this); + assertEq(this, eval("this")); + assertEq(this, (()=>this)()); + } +}(); + +new class extends class { } { + constructor() { + (()=>super())(); + assertEq(this, eval("this")); + assertEq(this, (()=>this)()); + } +}(); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/derivedConstructorInlining.js b/js/src/tests/non262/class/derivedConstructorInlining.js new file mode 100644 index 0000000000..53b6a52f24 --- /dev/null +++ b/js/src/tests/non262/class/derivedConstructorInlining.js @@ -0,0 +1,19 @@ +// Since we (for now!) can't emit jitcode for derived class statements. Make +// sure we can correctly invoke derived class constructors. + +class foo extends null { + constructor() { + // Anything that tests |this| should throw, so just let it run off the + // end. + } +} + +function intermediate() { + new foo(); +} + +for (let i = 0; i < 1100; i++) + assertThrownErrorContains(intermediate, "this"); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/derivedConstructorName.js b/js/src/tests/non262/class/derivedConstructorName.js new file mode 100644 index 0000000000..13d47addb4 --- /dev/null +++ b/js/src/tests/non262/class/derivedConstructorName.js @@ -0,0 +1,11 @@ +class A { + constructor() { } +} + +class B extends A { } + +var b = new B(); +assertEq(b.constructor.name, "B"); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/derivedConstructorReturnPrimitive.js b/js/src/tests/non262/class/derivedConstructorReturnPrimitive.js new file mode 100644 index 0000000000..8b1594fa81 --- /dev/null +++ b/js/src/tests/non262/class/derivedConstructorReturnPrimitive.js @@ -0,0 +1,15 @@ +class foo extends null { + constructor() { + // Returning a primitive is a TypeError in derived constructors. This + // ensures that super() can take the return value directly, without + // checking it. Use |null| here, as a tricky check to make sure we + // didn't lump it in with the object check, somehow. + return null; + } +} + +for (let i = 0; i < 1100; i++) + assertThrownErrorContains(() => new foo(), "return"); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/derivedConstructorTDZExplicitThis.js b/js/src/tests/non262/class/derivedConstructorTDZExplicitThis.js new file mode 100644 index 0000000000..4a4922d57e --- /dev/null +++ b/js/src/tests/non262/class/derivedConstructorTDZExplicitThis.js @@ -0,0 +1,12 @@ +class foo extends null { + constructor() { + this; + assertEq(false, true); + } +} + +for (let i = 0; i < 1100; i++) + assertThrownErrorContains(() => new foo(), "this"); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/derivedConstructorTDZOffEdge.js b/js/src/tests/non262/class/derivedConstructorTDZOffEdge.js new file mode 100644 index 0000000000..28a2c377ca --- /dev/null +++ b/js/src/tests/non262/class/derivedConstructorTDZOffEdge.js @@ -0,0 +1,11 @@ +class foo extends null { + constructor() { + // Let it fall off the edge and throw. + } +} + +for (let i = 0; i < 1100; i++) + assertThrownErrorContains(() => new foo(), "this"); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/derivedConstructorTDZReturnAliasedTry.js b/js/src/tests/non262/class/derivedConstructorTDZReturnAliasedTry.js new file mode 100644 index 0000000000..3399c69b0c --- /dev/null +++ b/js/src/tests/non262/class/derivedConstructorTDZReturnAliasedTry.js @@ -0,0 +1,14 @@ +class base {} +class derived extends base { + constructor() { + try { + (function() { p1(eval()) }()) + } catch (e) { + return + } + } +} +assertThrowsInstanceOf(()=>new derived(), ReferenceError); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/derivedConstructorTDZReturnObject.js b/js/src/tests/non262/class/derivedConstructorTDZReturnObject.js new file mode 100644 index 0000000000..48206a881e --- /dev/null +++ b/js/src/tests/non262/class/derivedConstructorTDZReturnObject.js @@ -0,0 +1,13 @@ +class foo extends null { + constructor() { + // If you return an object, we don't care that |this| went + // uninitialized + return {}; + } +} + +for (let i = 0; i < 1100; i++) + new foo(); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/derivedConstructorTDZReturnTry.js b/js/src/tests/non262/class/derivedConstructorTDZReturnTry.js new file mode 100644 index 0000000000..96791c0e78 --- /dev/null +++ b/js/src/tests/non262/class/derivedConstructorTDZReturnTry.js @@ -0,0 +1,16 @@ +class base {} +class derived extends base { + constructor() { + try { + return; + } catch (e) { + try { + return; + } catch (e) {} + } + } +} +assertThrowsInstanceOf(() => new derived, ReferenceError); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/derivedConstructorTDZReturnUndefined.js b/js/src/tests/non262/class/derivedConstructorTDZReturnUndefined.js new file mode 100644 index 0000000000..21b8a3a05c --- /dev/null +++ b/js/src/tests/non262/class/derivedConstructorTDZReturnUndefined.js @@ -0,0 +1,13 @@ +class foo extends null { + constructor() { + // Explicit returns of undefined should act the same as falling off the + // end of the function. That is to say, they should throw. + return undefined; + } +} + +for (let i = 0; i < 1100; i++) + assertThrownErrorContains(() => new foo(), "this"); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/extendBuiltinConstructors.js b/js/src/tests/non262/class/extendBuiltinConstructors.js new file mode 100644 index 0000000000..f823d81343 --- /dev/null +++ b/js/src/tests/non262/class/extendBuiltinConstructors.js @@ -0,0 +1,110 @@ +function testBuiltinInstanceIsInstanceOf(instance, builtin, class_) { + assertEq(instance instanceof class_, true); + assertEq(instance instanceof builtin, true); + + if (builtin === Array) + assertEq(Array.isArray(instance), true); +} + +function testBuiltinInstance(builtin, ...args) { + class sub extends builtin { + constructor(...args) { + super(...args); + this.called = true; + } + } + + let instance = new sub(...args); + assertEq(instance.called, true); + testBuiltinInstanceIsInstanceOf(instance, builtin, sub); +} + +function testBuiltinMultipleSubclasses(builtin, ...args) { + function f(obj, prop) { + assertEq(obj.prop, prop); + } + + class sub1 extends builtin { }; + class sub2 extends builtin { }; + + const prop1 = "A"; + const prop2 = "B"; + + sub1.prototype.prop = prop1; + sub2.prototype.prop = prop2; + + let instance1 = new sub1(...args); + let instance2 = new sub2(...args); + + // Also make sure we get the properties we want with a default constructor + testBuiltinInstanceIsInstanceOf(instance1, builtin, sub1); + + for (let i = 0; i < 10; i++) { + f(instance1, prop1); + f(instance2, prop2); + } +} + +function testBuiltin(builtin, ...args) { + testBuiltinInstance(builtin, ...args); + testBuiltinMultipleSubclasses(builtin, ...args); +} + +function testBuiltinTypedArrays() { + let typedArrays = [Int8Array, + Uint8Array, + Uint8ClampedArray, + Int16Array, + Uint16Array, + Int32Array, + Uint32Array, + Float32Array, + Float64Array]; + + for (let array of typedArrays) { + testBuiltin(array); + testBuiltin(array, 5); + testBuiltin(array, new array()); + testBuiltin(array, new ArrayBuffer()); + } +} + +testBuiltin(Function); +testBuiltin(Object); +testBuiltin(Boolean); +testBuiltin(Error); +testBuiltin(EvalError); +testBuiltin(RangeError); +testBuiltin(ReferenceError); +testBuiltin(SyntaxError); +testBuiltin(TypeError); +testBuiltin(URIError); +testBuiltin(Number); +testBuiltin(Date); +testBuiltin(Date, 5); +testBuiltin(Date, 5, 10); +testBuiltin(RegExp); +testBuiltin(RegExp, /Regexp Argument/); +testBuiltin(RegExp, "String Argument"); +testBuiltin(Map); +testBuiltin(Set); +testBuiltin(WeakMap); +testBuiltin(WeakSet); +testBuiltin(ArrayBuffer); +testBuiltinTypedArrays(); +testBuiltin(DataView, new ArrayBuffer()); +testBuiltin(DataView, new (newGlobal().ArrayBuffer)()); +testBuiltin(String); +testBuiltin(Array); +testBuiltin(Array, 15); +testBuiltin(Array, 3.0); +testBuiltin(Array, "non-length one-arg"); +testBuiltin(Array, 5, 10, 15, "these are elements"); +// More Promise subclassing tests can be found in non262/Promise/promise-subclassing.js +testBuiltin(Promise, _=>{}); + +if (this.SharedArrayBuffer) + testBuiltin(SharedArrayBuffer); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/fields-instance-class-name-binding-eval.js b/js/src/tests/non262/class/fields-instance-class-name-binding-eval.js new file mode 100644 index 0000000000..6b6d3a0857 --- /dev/null +++ b/js/src/tests/non262/class/fields-instance-class-name-binding-eval.js @@ -0,0 +1,40 @@ +// Instance field initialisers can access the inner name binding for class definitions. +{ + class C { + field = eval("C"); + } + assertEq(new C().field, C); +} +{ + let C = class Inner { + field = eval("Inner"); + }; + assertEq(new C().field, C); +} + +// Instance field initialiser expressions always resolve the inner name binding. +{ + class C { + field = () => eval("C"); + } + assertEq(new C().field(), C); + + const D = C; + C = null; + + assertEq(new D().field(), D); +} +{ + let C = class Inner { + field = () => eval("Inner"); + } + assertEq(new C().field(), C); + + const D = C; + C = null; + + assertEq(new D().field(), D); +} + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/class/fields-instance-class-name-binding.js b/js/src/tests/non262/class/fields-instance-class-name-binding.js new file mode 100644 index 0000000000..10cac12504 --- /dev/null +++ b/js/src/tests/non262/class/fields-instance-class-name-binding.js @@ -0,0 +1,40 @@ +// Instance field initialisers can access the inner name binding for class definitions. +{ + class C { + field = C; + } + assertEq(new C().field, C); +} +{ + let C = class Inner { + field = Inner; + }; + assertEq(new C().field, C); +} + +// Instance field initialiser expressions always resolve the inner name binding. +{ + class C { + field = () => C; + } + assertEq(new C().field(), C); + + const D = C; + C = null; + + assertEq(new D().field(), D); +} +{ + let C = class Inner { + field = () => Inner; + } + assertEq(new C().field(), C); + + const D = C; + C = null; + + assertEq(new D().field(), D); +} + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/class/fields-static-class-name-binding-eval.js b/js/src/tests/non262/class/fields-static-class-name-binding-eval.js new file mode 100644 index 0000000000..34185e7ecd --- /dev/null +++ b/js/src/tests/non262/class/fields-static-class-name-binding-eval.js @@ -0,0 +1,59 @@ +// Static field initialisers can access the inner name binding for class definitions. +{ + class C { + static field = eval("C"); + } + assertEq(C.field, C); +} +{ + let C = class Inner { + static field = eval("Inner"); + }; + assertEq(C.field, C); +} + +// Static field initialisers can't access the outer name binding for class expressions +// before it has been initialised. +{ + assertThrowsInstanceOf(() => { + let C = class { + static field = eval("C"); + }; + }, ReferenceError); +} + +// Static field initialisers can access the outer name binding for class expressions after +// the binding has been initialised +{ + let C = class { + static field = () => eval("C"); + }; + assertEq(C.field(), C); +} + +// Static field initialiser expressions always resolve the inner name binding. +{ + class C { + static field = () => eval("C"); + } + assertEq(C.field(), C); + + const D = C; + C = null; + + assertEq(D.field(), D); +} +{ + let C = class Inner { + static field = () => eval("Inner"); + } + assertEq(C.field(), C); + + const D = C; + C = null; + + assertEq(D.field(), D); +} + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/class/fields-static-class-name-binding.js b/js/src/tests/non262/class/fields-static-class-name-binding.js new file mode 100644 index 0000000000..54032b03ff --- /dev/null +++ b/js/src/tests/non262/class/fields-static-class-name-binding.js @@ -0,0 +1,59 @@ +// Static field initialisers can access the inner name binding for class definitions. +{ + class C { + static field = C; + } + assertEq(C.field, C); +} +{ + let C = class Inner { + static field = Inner; + }; + assertEq(C.field, C); +} + +// Static field initialisers can't access the outer name binding for class expressions +// before it has been initialised. +{ + assertThrowsInstanceOf(() => { + let C = class { + static field = C; + }; + }, ReferenceError); +} + +// Static field initialisers can access the outer name binding for class expressions after +// the binding has been initialised +{ + let C = class { + static field = () => C; + }; + assertEq(C.field(), C); +} + +// Static field initialiser expressions always resolve the inner name binding. +{ + class C { + static field = () => C; + } + assertEq(C.field(), C); + + const D = C; + C = null; + + assertEq(D.field(), D); +} +{ + let C = class Inner { + static field = () => Inner; + } + assertEq(C.field(), C); + + const D = C; + C = null; + + assertEq(D.field(), D); +} + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/class/geterNoExprClosure.js b/js/src/tests/non262/class/geterNoExprClosure.js new file mode 100644 index 0000000000..e37cb287a9 --- /dev/null +++ b/js/src/tests/non262/class/geterNoExprClosure.js @@ -0,0 +1,20 @@ +// getter/setter with expression closure is allowed only in object literal. + +assertThrowsInstanceOf(() => eval(` + class foo { + constructor() {} + + get a() 1 + } +`), SyntaxError); + +assertThrowsInstanceOf(() => eval(` + class foo { + constructor() {} + + set a(v) 1 + } +`), SyntaxError); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/innerBinding.js b/js/src/tests/non262/class/innerBinding.js new file mode 100644 index 0000000000..b1afa177e0 --- /dev/null +++ b/js/src/tests/non262/class/innerBinding.js @@ -0,0 +1,86 @@ +// Named class definitions should create an immutable inner binding. +// Since all code in classes is in strict mode, attempts to mutate it +// should throw. +class Foof { constructor() { }; tryBreak() { Foof = 4; } } +for (let result of [Foof, class Bar { constructor() { }; tryBreak() { Bar = 4; } }]) + assertThrowsInstanceOf(() => new result().tryBreak(), TypeError); + +{ + class foo { constructor() { }; tryBreak() { foo = 4; } } + for (let result of [foo, class Bar { constructor() { }; tryBreak() { Bar = 4 } }]) + assertThrowsInstanceOf(() => new result().tryBreak(), TypeError); +} + +// TDZ applies to inner bindings +assertThrowsInstanceOf(()=>eval(`class Bar { + constructor() { }; + [Bar] () { }; + }`), ReferenceError); + +assertThrowsInstanceOf(()=>eval(`(class Bar { + constructor() { }; + [Bar] () { }; + })`), ReferenceError); + +// There's no magic "inner binding" global +{ + class Foo { + constructor() { }; + test() { + class Bar { + constructor() { } + test() { return Foo === Bar } + } + return new Bar().test(); + } + } + assertEq(new Foo().test(), false); + assertEq(new class foo { + constructor() { }; + test() { + return new class bar { + constructor() { } + test() { return foo === bar } + }().test(); + } + }().test(), false); +} + +// Inner bindings are shadowable +{ + class Foo { + constructor() { } + test(Foo) { return Foo; } + } + assertEq(new Foo().test(4), 4); + assertEq(new class foo { + constructor() { }; + test(foo) { return foo } + }().test(4), 4); +} + +// Inner bindings in expressions should shadow even existing names. +class Foo { constructor() { } static method() { throw new Error("NO!"); } } +assertEq(new class Foo { + constructor() { }; + static method() { return 4; }; + test() { return Foo.method(); } + }().test(), 4); + +// The outer binding is distinct from the inner one +{ + let orig_X; + + class X { + constructor() { } + f() { assertEq(X, orig_X); } + } + + orig_X = X; + X = 13; + assertEq(X, 13); + new orig_X().f(); +} + +if (typeof reportCompare === "function") + reportCompare(0, 0, "OK"); diff --git a/js/src/tests/non262/class/member-expr-after-super.js b/js/src/tests/non262/class/member-expr-after-super.js new file mode 100644 index 0000000000..fa965b24e5 --- /dev/null +++ b/js/src/tests/non262/class/member-expr-after-super.js @@ -0,0 +1,44 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +class Base { + get test() { + return "ok"; + } +} + +class SuperThenProperty extends Base { + constructor() { + var result = super().test; + return {result}; + } +} +assertEq(new SuperThenProperty().result, "ok"); + +class SuperThenMember extends Base { + constructor() { + var result = super()["tes" + String.fromCodePoint("t".codePointAt(0))]; + return {result}; + } +} +assertEq(new SuperThenMember().result, "ok"); + +class SuperThenCall extends Function { + constructor() { + var result = super("o, k", "return o + k;")("o", "k"); + return {result}; + } +} +assertEq(new SuperThenCall().result, "ok"); + +class SuperThenTemplateCall extends Function { + constructor() { + var result = super("cooked", "return cooked[0][0] + cooked.raw[0][1];")`ok`; + return {result}; + } +} +assertEq(new SuperThenTemplateCall().result, "ok"); + +if (typeof reportCompare === "function") + reportCompare(0, 0); diff --git a/js/src/tests/non262/class/methDefn.js b/js/src/tests/non262/class/methDefn.js new file mode 100644 index 0000000000..9513bdfb30 --- /dev/null +++ b/js/src/tests/non262/class/methDefn.js @@ -0,0 +1,204 @@ +var BUGNUMBER = 924672; +var summary = 'Method Definitions' + +print(BUGNUMBER + ": " + summary); + +// Function definitions. +function syntaxError (script) { + try { + Function(script); + } catch (e) { + if (e instanceof SyntaxError) { + return; + } + } + throw new Error('Expected syntax error: ' + script); +} + + +// Tests begin. + +syntaxError("{a(){}}"); +syntaxError("b = {a("); +syntaxError("b = {a)"); +syntaxError("b = {a(}"); +syntaxError("b = {a)}"); +syntaxError("b = {a()"); +syntaxError("b = {a()}"); +syntaxError("b = {a(){}"); +syntaxError("b = {a){}"); +syntaxError("b = {a}}"); +syntaxError("b = {a{}}"); +syntaxError("b = {a({}}"); +syntaxError("b = {a@(){}}"); +syntaxError("b = {a() => 0}"); +syntaxError("b = {a() void 0}"); +syntaxError("b = {a() 1}"); +syntaxError("b = {a() false}"); + +b = {a(){return 5;}}; +assertEq(b.a(), 5); + +b = {a(){return "hey";}}; +assertEq(b.a(), "hey"); + +b = {a(){return arguments;}}; +assertEq(b.a().length, 0); + +b = {a(c){return arguments;}}; +assertEq(b.a().length, 0); + +b = {a(c){return arguments;}}; +assertEq(b.a(1).length, 1); + +b = {a(c){return arguments;}}; +assertEq(b.a(1)[0], 1); + +b = {a(c,d){return arguments;}}; +assertEq(b.a(1,2).length, 2); + +b = {a(c,d){return arguments;}}; +assertEq(b.a(1,2)[0], 1); + +b = {a(c,d){return arguments;}}; +assertEq(b.a(1,2)[1], 2); + +// Methods along with other properties. +syntaxError("b = {,a(){}}"); +syntaxError("b = {@,a(){}}"); +syntaxError("b = {a(){},@}"); +syntaxError("b = {a : 5 , (){}}"); +syntaxError("b = {a : 5@ , a(){}}"); +syntaxError("b = {a : , a(){}}"); +syntaxError("b = {a : 5, a()}}"); +syntaxError("b = {a : 5, a({}}"); +syntaxError("b = {a : 5, a){}}"); +syntaxError("b = {a : 5, a(){}"); +var c = "d"; +b = { a : 5, + [c] : "hey", + e() {return 6;}, + get f() {return 7;}, + set f(g) {this.h = 9;} +} +assertEq(b.a, 5); +assertEq(b.d, "hey"); +assertEq(b.e(), 6); +assertEq(b.f, 7); +assertEq(b.h !== 9, true); +b.f = 15; +assertEq(b.h, 9); + + +var i = 0; +var a = { + foo0 : function (){return 0;}, + ["foo" + ++i](){return 1;}, + ["foo" + ++i](){return 2;}, + ["foo" + ++i](){return 3;}, + foo4(){return 4;} +}; +assertEq(a.foo0(), 0); +assertEq(a.foo1(), 1); +assertEq(a.foo2(), 2); +assertEq(a.foo3(), 3); +assertEq(a.foo4(), 4); + +// Symbols. +var unique_sym = Symbol("1"), registered_sym = Symbol.for("2"); +a = { [unique_sym](){return 2;}, [registered_sym](){return 3;} }; +assertEq(a[unique_sym](), 2); +assertEq(a[registered_sym](), 3); + +// Method characteristics. +a = { b(){ return 4;} }; +b = Object.getOwnPropertyDescriptor(a, "b"); +assertEq(b.configurable, true); +assertEq(b.enumerable, true); +assertEq(b.writable, true); +assertEq(b.value(), 4); + +// prototype property +assertEq(a.b.prototype, undefined); +assertEq(a.b.hasOwnProperty("prototype"), false); + +// Defining several methods using eval. +var code = "({"; +for (i = 0; i < 1000; i++) + code += "['foo' + " + i + "]() {return 'ok';}, " +code += "['bar']() {return 'all ok'}});"; +var obj = eval(code); +for (i = 0; i < 1000; i++) + assertEq(obj["foo" + i](), "ok"); +assertEq(obj["bar"](), "all ok"); + +// this +var obj = { + a : "hey", + meth(){return this.a;} +} +assertEq(obj.meth(), "hey"); + +// Inheritance +var obj2 = Object.create(obj); +assertEq(obj2.meth(), "hey"); + +var obj = { + a() { + return "hey"; + } +} +assertEq(obj.a.call(), "hey"); + +// Duplicates +var obj = { + meth : 3, + meth() { return 4; }, + meth() { return 5; } +} +assertEq(obj.meth(), 5); + +var obj = { + meth() { return 4; }, + meth() { return 5; }, + meth : 3 +} +assertEq(obj.meth, 3); +assertThrowsInstanceOf(function() {obj.meth();}, TypeError); + +// Strict mode +a = {b(c){"use strict";return c;}}; +assertEq(a.b(1), 1); +a = {["b"](c){"use strict";return c;}}; +assertEq(a.b(1), 1); + +// Allow strict-reserved names as methods in objects. +// (Bug 1124362) +a = { static() { return 4; } }; +assertEq(a.static(), 4); + +a = { get static() { return 4; } }; +assertEq(a.static, 4); + +a = { set static(x) { assertEq(x, 4); } }; +a.static = 4; + +function testStrictMode() { + "use strict"; + var obj = { static() { return 4; } }; + assertEq(obj.static(), 4); + + obj = { get static() { return 4; } }; + assertEq(obj.static, 4); + + obj = { set static(x) { assertEq(x, 4); } }; + obj.static = 4; +} +testStrictMode(); + +// Tests provided by benvie in the bug to distinguish from ES5 desugar. +assertEq(({ method() {} }).method.name, "method"); +assertThrowsInstanceOf(function() {({ method() { method() } }).method() }, ReferenceError); + +if (typeof reportCompare === 'function') + reportCompare(0, 0, "ok"); diff --git a/js/src/tests/non262/class/methDefnGen.js b/js/src/tests/non262/class/methDefnGen.js new file mode 100644 index 0000000000..3165ed4481 --- /dev/null +++ b/js/src/tests/non262/class/methDefnGen.js @@ -0,0 +1,83 @@ +var BUGNUMBER = 924672; +var summary = 'Method Definitions - Generators' + +print(BUGNUMBER + ": " + summary); + +// Function definitions. +function syntaxError (script) { + try { + Function(script); + } catch (e) { + if (e instanceof SyntaxError) { + return; + } + } + throw new Error('Expected syntax error: ' + script); +} + + +// Tests begin. + +syntaxError("{*a(){}}"); +syntaxError("b = {*(){}"); +syntaxError("b = {*{}"); +syntaxError("b = {*){}"); +syntaxError("b = {*({}"); +syntaxError("b = {*(){"); +syntaxError("b = {*()}"); +syntaxError("b = {*a("); +syntaxError("b = {*a)"); +syntaxError("b = {*a(}"); +syntaxError("b = {*a)}"); +syntaxError("b = {*a()"); +syntaxError("b = {*a()}"); +syntaxError("b = {*a(){}"); +syntaxError("b = {*a){}"); +syntaxError("b = {*a}}"); +syntaxError("b = {*a{}}"); +syntaxError("b = {*a({}}"); +syntaxError("b = {*a@(){}}"); +syntaxError("b = {*@(){}}"); +syntaxError("b = {*get a(){}}"); +syntaxError("b = {get *a(){}}"); +syntaxError("b = {get a*(){}}"); +syntaxError("b = {*set a(c){}}"); +syntaxError("b = {set *a(c){}}"); +syntaxError("b = {set a*(c){}}"); +syntaxError("b = {*a : 1}"); +syntaxError("b = {a* : 1}"); +syntaxError("b = {a :* 1}"); +syntaxError("b = {a*(){}}"); + +// Generator methods. +b = { * g() { + var a = { [yield 1]: 2, [yield 2]: 3}; + return a; +} } +var it = b.g(); +var next = it.next(); +assertEq(next.done, false); +assertEq(next.value, 1); +next = it.next("hello"); +assertEq(next.done, false); +assertEq(next.value, 2); +next = it.next("world"); +assertEq(next.done, true); +assertEq(next.value.hello, 2); +assertEq(next.value.world, 3); + +// prototype property +assertEq(b.g.hasOwnProperty("prototype"), true); + +// Strict mode +a = {*b(c){"use strict";yield c;}}; +assertEq(a.b(1).next().value, 1); +a = {*["b"](c){"use strict";return c;}}; +assertEq(a.b(1).next().value, 1); + +// Generators should not have [[Construct]] +a = {*g() { yield 1; }} +assertThrowsInstanceOf(() => { new a.g }, TypeError); + +if (typeof reportCompare === 'function') + reportCompare(0, 0, "ok"); diff --git a/js/src/tests/non262/class/method-named-static.js b/js/src/tests/non262/class/method-named-static.js new file mode 100644 index 0000000000..c5a2ed8827 --- /dev/null +++ b/js/src/tests/non262/class/method-named-static.js @@ -0,0 +1,56 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +// Instance method named "static", with and without escape sequence. +assertEq((new class { + static() { return "method-static-no-escape"; } +}).static(), "method-static-no-escape"); + +assertEq((new class { + st\u0061tic() { return "method-static-escape"; } +}).static(), "method-static-escape"); + +// Instance getter named "static", with and without escape sequence. +assertEq((new class { + get static() { return "getter-static-no-escape"; } +}).static, "getter-static-no-escape"); + +assertEq((new class { + get static() { return "getter-static-escape"; } +}).static, "getter-static-escape"); + +// Static method named "static", with and without escape sequence. +assertEq(class { + static static() { return "static-method-static-no-escape"; } +}.static(), "static-method-static-no-escape"); + +assertEq(class { + static st\u0061tic() { return "static-method-static-escape"; } +}.static(), "static-method-static-escape"); + +// Static getter named "static", with and without escape sequence. +assertEq(class { + static get static() { return "static-getter-static-no-escape"; } +}.static, "static-getter-static-no-escape"); + +assertEq(class { + static get st\u0061tic() { return "static-getter-static-escape"; } +}.static, "static-getter-static-escape"); + + +// The static modifier itself must not contain any escape sequences. +assertThrowsInstanceOf(() => eval(String.raw` + class C { + st\u0061tic m() {} + } +`), SyntaxError); + +assertThrowsInstanceOf(() => eval(String.raw` + class C { + st\u0061tic get m() {} + } +`), SyntaxError); + +if (typeof reportCompare === "function") + reportCompare(0, 0, "ok"); diff --git a/js/src/tests/non262/class/methodInstallation.js b/js/src/tests/non262/class/methodInstallation.js new file mode 100644 index 0000000000..bbb6c2f727 --- /dev/null +++ b/js/src/tests/non262/class/methodInstallation.js @@ -0,0 +1,101 @@ +// Do the things we write in classes actually appear as they are supposed to? + +var methodCalled; +var getterCalled; +var setterCalled; +var constructorCalled; +var staticMethodCalled; +var staticGetterCalled; +var staticSetterCalled; +class testClass { + constructor() { constructorCalled = true; } + __proto__() { methodCalled = true } + get getter() { getterCalled = true; } + set setter(x) { setterCalled = true; } + static staticMethod() { staticMethodCalled = true; } + static get staticGetter() { staticGetterCalled = true; } + static set staticSetter(x) { staticSetterCalled = true; } + *[Symbol.iterator]() { yield "cow"; yield "pig"; } +} + +for (let a of [testClass, + class { + constructor() { constructorCalled = true; } + __proto__() { methodCalled = true } + get getter() { getterCalled = true; } + set setter(x) { setterCalled = true; } + static staticMethod() { staticMethodCalled = true; } + static get staticGetter() { staticGetterCalled = true; } + static set staticSetter(x) { staticSetterCalled = true; } + *[Symbol.iterator]() { yield "cow"; yield "pig"; } + }]) { + + methodCalled = false; + getterCalled = false; + setterCalled = false; + constructorCalled = false; + staticMethodCalled = false; + staticGetterCalled = false; + staticSetterCalled = false; + + var aConstDesc = Object.getOwnPropertyDescriptor(a.prototype, "constructor"); + assertEq(aConstDesc.writable, true); + assertEq(aConstDesc.configurable, true); + assertEq(aConstDesc.enumerable, false); + new aConstDesc.value(); + assertEq(constructorCalled, true); + + // __proto__ is just an identifier for classes. No prototype changes are made. + assertEq(Object.getPrototypeOf(a.prototype), Object.prototype); + var aMethDesc = Object.getOwnPropertyDescriptor(a.prototype, "__proto__"); + assertEq(aMethDesc.writable, true); + assertEq(aMethDesc.configurable, true); + assertEq(aMethDesc.enumerable, false); + aMethDesc.value(); + assertEq(methodCalled, true); + + var aGetDesc = Object.getOwnPropertyDescriptor(a.prototype, "getter"); + assertEq(aGetDesc.configurable, true); + assertEq(aGetDesc.enumerable, false); + aGetDesc.get(); + assertThrowsInstanceOf(() => new aGetDesc.get, TypeError); + assertEq(getterCalled, true); + + var aSetDesc = Object.getOwnPropertyDescriptor(a.prototype, "setter"); + assertEq(aSetDesc.configurable, true); + assertEq(aSetDesc.enumerable, false); + aSetDesc.set(); + assertThrowsInstanceOf(() => new aSetDesc.set, TypeError); + assertEq(setterCalled, true); + assertDeepEq(aSetDesc, Object.getOwnPropertyDescriptor(a.prototype, "setter")); + + assertEq(Object.getOwnPropertyDescriptor(new a(), "staticMethod"), undefined); + var aStaticMethDesc = Object.getOwnPropertyDescriptor(a, "staticMethod"); + assertEq(aStaticMethDesc.configurable, true); + assertEq(aStaticMethDesc.enumerable, false); + assertEq(aStaticMethDesc.writable, true); + aStaticMethDesc.value(); + assertThrowsInstanceOf(() => new aStaticMethDesc.value, TypeError); + assertEq(staticMethodCalled, true); + + assertEq(Object.getOwnPropertyDescriptor(new a(), "staticGetter"), undefined); + var aStaticGetDesc = Object.getOwnPropertyDescriptor(a, "staticGetter"); + assertEq(aStaticGetDesc.configurable, true); + assertEq(aStaticGetDesc.enumerable, false); + aStaticGetDesc.get(); + assertThrowsInstanceOf(() => new aStaticGetDesc.get, TypeError); + assertEq(staticGetterCalled, true); + + assertEq(Object.getOwnPropertyDescriptor(new a(), "staticSetter"), undefined); + var aStaticSetDesc = Object.getOwnPropertyDescriptor(a, "staticSetter"); + assertEq(aStaticSetDesc.configurable, true); + assertEq(aStaticSetDesc.enumerable, false); + aStaticSetDesc.set(); + assertThrowsInstanceOf(() => new aStaticSetDesc.set, TypeError); + assertEq(staticSetterCalled, true); + + assertEq([...new a()].join(), "cow,pig"); +} + +if (typeof reportCompare === "function") + reportCompare(0, 0, "OK"); diff --git a/js/src/tests/non262/class/methodName.js b/js/src/tests/non262/class/methodName.js new file mode 100644 index 0000000000..02a726c105 --- /dev/null +++ b/js/src/tests/non262/class/methodName.js @@ -0,0 +1,40 @@ +class TestClass { + get getter() { } + set setter(x) { } + method() { } + + static get staticGetter() { } + static set staticSetter(x) { } + static staticMethod() { } + + get 1() { } + set 2(v) { } + 3() { } + + static get 4() { } + static set 5(x) { } + static 6() { } +} + +function name(obj, property, get) { + let desc = Object.getOwnPropertyDescriptor(obj, property); + return (get ? desc.get : desc.set).name; +} + +assertEq(name(TestClass.prototype, "getter", true), "get getter"); +assertEq(name(TestClass.prototype, "setter", false), "set setter"); +assertEq(TestClass.prototype.method.name, "method"); + +assertEq(name(TestClass, "staticGetter", true), "get staticGetter"); +assertEq(name(TestClass, "staticSetter", false), "set staticSetter"); +assertEq(TestClass.staticMethod.name, "staticMethod"); + +assertEq(name(TestClass.prototype, "1", true), "get 1"); +assertEq(name(TestClass.prototype, "2", false), "set 2"); +assertEq(TestClass.prototype[3].name, "3"); + +assertEq(name(TestClass, "4", true), "get 4"); +assertEq(name(TestClass, "5", false), "set 5"); +assertEq(TestClass[6].name, "6"); + +reportCompare(true, true); diff --git a/js/src/tests/non262/class/methodOverwrites.js b/js/src/tests/non262/class/methodOverwrites.js new file mode 100644 index 0000000000..c1c460a28c --- /dev/null +++ b/js/src/tests/non262/class/methodOverwrites.js @@ -0,0 +1,80 @@ +// Ensure that we can overwrite methods when more tha one is present. +{ + var result = 0; + // Regardless of order, the constructor is overridden by any CPN, because it's + // processed seperately. + class a { ["constructor"]() { result += 1; }; constructor() { result += 2; } } + var aInst = new a(); + assertEq(result, 2); + aInst.constructor(); + assertEq(result, 3); + + class b { constructor() { result += 2; } ["constructor"]() { result += 1; }; } + var bInst = new b(); + assertEq(result, 5); + bInst.constructor(); + assertEq(result, 6); + + class c { constructor() { } method() { result += 1 } get method() { result += 2 } } + new c().method; + assertEq(result, 8); + + class d { constructor() { } get method() { result += 1 } method() { result += 2 } } + new d().method(); + assertEq(result, 10); + + // getters and setter should not overwrite each other, but merge cleanly. + class e { constructor() { } get method() { result += 1 } set method(x) { } } + new e().method; + assertEq(result, 11); + + class f { constructor() { } + set method(x) { throw "NO"; } + method() { throw "NO" } + get method() { return new Function("result += 1"); } + } + new f().method(); + assertEq(result, 12); +} + +// Try again with expressions. +{ + var result = 0; + // Regardless of order, the constructor is overridden by any CPN, because it's + // processed seperately. + let a = class { ["constructor"]() { result += 1; }; constructor() { result += 2; } }; + var aInst = new a(); + assertEq(result, 2); + aInst.constructor(); + assertEq(result, 3); + + let b = class { constructor() { result += 2; } ["constructor"]() { result += 1; }; }; + var bInst = new b(); + assertEq(result, 5); + bInst.constructor(); + assertEq(result, 6); + + let c = class { constructor() { } method() { result += 1 } get method() { result += 2 } }; + new c().method; + assertEq(result, 8); + + let d = class { constructor() { } get method() { result += 1 } method() { result += 2 } }; + new d().method(); + assertEq(result, 10); + + // getters and setter should not overwrite each other, but merge cleanly. + let e = class { constructor() { } get method() { result += 1 } set method(x) { } }; + new e().method; + assertEq(result, 11); + + let f = class { constructor() { } + set method(x) { throw "NO"; } + method() { throw "NO" } + get method() { return new Function("result += 1"); } + }; + new f().method(); + assertEq(result, 12); +} + +if (typeof reportCompare === "function") + reportCompare(0, 0, "OK"); diff --git a/js/src/tests/non262/class/methodsPrototype.js b/js/src/tests/non262/class/methodsPrototype.js new file mode 100644 index 0000000000..07a565ceb6 --- /dev/null +++ b/js/src/tests/non262/class/methodsPrototype.js @@ -0,0 +1,39 @@ +class TestClass { + constructor() { } + method() { } + get getter() { } + set setter(x) { } + *generator() { } + static staticMethod() { } + static get staticGetter() { } + static set staticSetter(x) { } + static *staticGenerator() { } +} + +var test = new TestClass(); + +var hasPrototype = [ + test.constructor, + test.generator, + TestClass.staticGenerator +] + +for (var fun of hasPrototype) { + assertEq(fun.hasOwnProperty('prototype'), true); +} + +var hasNoPrototype = [ + test.method, + Object.getOwnPropertyDescriptor(test.__proto__, 'getter').get, + Object.getOwnPropertyDescriptor(test.__proto__, 'setter').set, + TestClass.staticMethod, + Object.getOwnPropertyDescriptor(TestClass, 'staticGetter').get, + Object.getOwnPropertyDescriptor(TestClass, 'staticSetter').set, +] + +for (var fun of hasNoPrototype) { + assertEq(fun.hasOwnProperty('prototype'), false); +} + +if (typeof reportCompare === "function") + reportCompare(0, 0, "OK"); diff --git a/js/src/tests/non262/class/newTargetArgumentsIntact.js b/js/src/tests/non262/class/newTargetArgumentsIntact.js new file mode 100644 index 0000000000..d047085ea0 --- /dev/null +++ b/js/src/tests/non262/class/newTargetArgumentsIntact.js @@ -0,0 +1,44 @@ +// Since we put new.target at the end of the arguments vector, ensrue that it +// doesn't interact with the arguments object + +var argsContent; + +function argsWithNewTarget(foo) { + assertEq(arguments.length, argsContent.length); + for (let i = 0; i < arguments.length; i++) + assertEq(arguments[i], argsContent[i]); + let nt = new.target; + + // Assigning to the arguments object shouldn't infect new.target, either + arguments[arguments.length] = 42; + assertEq(new.target, nt); +} + +// Test constructing invocations, with under and overflow +argsContent = []; +for (let i = 0; i < 100; i++) + new argsWithNewTarget(); + +argsContent = [1]; +for (let i = 0; i < 100; i++) + new argsWithNewTarget(1); + +argsContent = [1,2,3]; +for (let i = 0; i < 100; i++) + new argsWithNewTarget(1, 2, 3); + +// Test spreadnew as well. +argsContent = []; +for (let i = 0; i < 100; i++) + new argsWithNewTarget(...[]); + +argsContent = [1]; +for (let i = 0; i < 100; i++) + new argsWithNewTarget(...[1]); + +argsContent = [1,2,3]; +for (let i = 0; i < 100; i++) + new argsWithNewTarget(...[1,2,3]); + +if (typeof reportCompare === "function") + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/newTargetArrow.js b/js/src/tests/non262/class/newTargetArrow.js new file mode 100644 index 0000000000..548f750475 --- /dev/null +++ b/js/src/tests/non262/class/newTargetArrow.js @@ -0,0 +1,24 @@ +// new.target is valid in any arrow function not in a global context. +new Function('(() => new.target)()'); + +// It's also good inside eval, but not global eval +assertThrowsInstanceOf(() => eval('() => new.target'), SyntaxError); + +function assertNewTarget(expected) { + assertEq((()=>new.target)(), expected); + assertEq(eval('()=>new.target')(), expected); + + // Make sure that arrow functions can escape their original context and + // still get the right answer. + return (() => new.target); +} + +const ITERATIONS = 550; +for (let i = 0; i < ITERATIONS; i++) + assertEq(assertNewTarget(undefined)(), undefined); + +for (let i = 0; i < ITERATIONS; i++) + assertEq(new assertNewTarget(assertNewTarget)(), assertNewTarget); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/newTargetBound.js b/js/src/tests/non262/class/newTargetBound.js new file mode 100644 index 0000000000..f65cfe3caf --- /dev/null +++ b/js/src/tests/non262/class/newTargetBound.js @@ -0,0 +1,16 @@ +function boundTarget(expected) { + assertEq(new.target, expected); +} + +let bound = boundTarget.bind(undefined); + +const TEST_ITERATIONS = 550; + +for (let i = 0; i < TEST_ITERATIONS; i++) + bound(undefined); + +for (let i = 0; i < TEST_ITERATIONS; i++) + new bound(boundTarget); + +if (typeof reportCompare === "function") + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/newTargetCCW.js b/js/src/tests/non262/class/newTargetCCW.js new file mode 100644 index 0000000000..9f5f870d40 --- /dev/null +++ b/js/src/tests/non262/class/newTargetCCW.js @@ -0,0 +1,10 @@ +// Make sure we wrap the new target on CCW construct calls. +var g = newGlobal(); + +let f = g.eval('(function (expected) { this.accept = new.target === expected; })'); + +for (let i = 0; i < 1100; i++) + assertEq(new f(f).accept, true); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/newTargetDVG.js b/js/src/tests/non262/class/newTargetDVG.js new file mode 100644 index 0000000000..1f9c7d7fc5 --- /dev/null +++ b/js/src/tests/non262/class/newTargetDVG.js @@ -0,0 +1,7 @@ +function thunk() { + new.target(); +} +assertThrownErrorContains(thunk, "new.target"); + +if (typeof reportCompare === "function") + reportCompare(0, 0, "OK"); diff --git a/js/src/tests/non262/class/newTargetDefaults.js b/js/src/tests/non262/class/newTargetDefaults.js new file mode 100644 index 0000000000..d5a4c5640b --- /dev/null +++ b/js/src/tests/non262/class/newTargetDefaults.js @@ -0,0 +1,25 @@ +// Check that new.target works properly in defaults. + +function check(expected, actual = new.target) { assertEq(actual, expected); } +new check(check); +check(undefined); + +let evaldCheck = eval("(" + check.toString() + ")"); +new evaldCheck(evaldCheck); +evaldCheck(undefined); + +function testInFunction() { + function checkInFunction(expected, actual = new.target) { assertEq(actual, expected); } + new checkInFunction(checkInFunction); + checkInFunction(undefined); + + let evaldCheckInFunction = eval("(" + checkInFunction.toString() + ")"); + new evaldCheckInFunction(evaldCheckInFunction); + evaldCheckInFunction(undefined); +} + +testInFunction(); +new testInFunction(); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/newTargetDirectInvoke.js b/js/src/tests/non262/class/newTargetDirectInvoke.js new file mode 100644 index 0000000000..d2cd1128c3 --- /dev/null +++ b/js/src/tests/non262/class/newTargetDirectInvoke.js @@ -0,0 +1,50 @@ +// new.target is valid inside Function() invocations +var func = new Function("new.target"); + +// Note that this will also test new.target in ion inlines. When the toplevel +// script is compiled, assertNewTarget will be inlined. +function assertNewTarget(expected, unused) { assertEq(new.target, expected); } + +// Test non-constructing invocations, with arg underflow, overflow, and correct +// numbers +for (let i = 0; i < 100; i++) + assertNewTarget(undefined, null); + +for (let i = 0; i < 100; i++) + assertNewTarget(undefined); + +for (let i = 0; i < 100; i++) + assertNewTarget(undefined, null, 1); + +// Test spread-call +for (let i = 0; i < 100; i++) + assertNewTarget(...[undefined]); + +for (let i = 0; i < 100; i++) + assertNewTarget(...[undefined, null]); + +for (let i = 0; i < 100; i++) + assertNewTarget(...[undefined, null, 1]); + +// Test constructing invocations, again with under and overflow +for (let i = 0; i < 100; i++) + new assertNewTarget(assertNewTarget, null); + +for (let i = 0; i < 100; i++) + new assertNewTarget(assertNewTarget); + +for (let i = 0; i < 100; i++) + new assertNewTarget(assertNewTarget, null, 1); + +// Test spreadnew as well. +for (let i = 0; i < 100; i++) + new assertNewTarget(...[assertNewTarget]); + +for (let i = 0; i < 100; i++) + new assertNewTarget(...[assertNewTarget, null]); + +for (let i = 0; i < 100; i++) + new assertNewTarget(...[assertNewTarget, null, 1]); + +if (typeof reportCompare === "function") + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/newTargetEval.js b/js/src/tests/non262/class/newTargetEval.js new file mode 100644 index 0000000000..f7581c5ab8 --- /dev/null +++ b/js/src/tests/non262/class/newTargetEval.js @@ -0,0 +1,40 @@ +// Eval of new.target is invalid outside functions. +try { + eval('new.target'); + assertEq(false, true); +} catch (e) { + if (!(e instanceof SyntaxError)) + throw e; +} + +// new.target is invalid inside eval inside top-level arrow functions +assertThrowsInstanceOf(() => eval('new.target'), SyntaxError); + +// new.target is invalid inside indirect eval. +let ieval = eval; +try { + (function () { return ieval('new.target'); })(); + assertEq(false, true); +} catch (e) { + if (!(e instanceof SyntaxError)) + throw e; +} + +function assertNewTarget(expected) { + assertEq(eval('new.target'), expected); + assertEq((()=>eval('new.target'))(), expected); + + // Also test nestings "by induction" + assertEq(eval('eval("new.target")'), expected); + assertEq(eval("eval('eval(`new.target`)')"), expected); +} + +const ITERATIONS = 550; +for (let i = 0; i < ITERATIONS; i++) + assertNewTarget(undefined); + +for (let i = 0; i < ITERATIONS; i++) + new assertNewTarget(assertNewTarget); + +if (typeof reportCompare === "function") + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/newTargetGenerators.js b/js/src/tests/non262/class/newTargetGenerators.js new file mode 100644 index 0000000000..614b1ab908 --- /dev/null +++ b/js/src/tests/non262/class/newTargetGenerators.js @@ -0,0 +1,14 @@ +function *generatorNewTarget(expected) { + assertEq(new.target, expected); + assertEq(eval('new.target'), expected); + assertEq((() => new.target)(), expected); + yield (() => new.target); +} + +const ITERATIONS = 25; + +for (let i = 0; i < ITERATIONS; i++) + assertEq(generatorNewTarget(undefined).next().value(), undefined); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/newTargetMethods.js b/js/src/tests/non262/class/newTargetMethods.js new file mode 100644 index 0000000000..2383dc8bd8 --- /dev/null +++ b/js/src/tests/non262/class/newTargetMethods.js @@ -0,0 +1,51 @@ +// Just like newTargetDirectInvoke, except to prove it works in functions +// defined with method syntax as well. Note that methods, getters, and setters +// are not constructible. + +let ol = { + olTest(arg) { assertEq(arg, 4); assertEq(new.target, undefined); }, + get ol() { assertEq(new.target, undefined); }, + set ol(arg) { assertEq(arg, 4); assertEq(new.target, undefined); } +} + +class cl { + constructor() { assertEq(new.target, cl); } + clTest(arg) { assertEq(arg, 4); assertEq(new.target, undefined); } + get cl() { assertEq(new.target, undefined); } + set cl(arg) { assertEq(arg, 4); assertEq(new.target, undefined); } + + static staticclTest(arg) { assertEq(arg, 4); assertEq(new.target, undefined); } + static get staticcl() { assertEq(new.target, undefined); } + static set staticcl(arg) { assertEq(arg, 4); assertEq(new.target, undefined); } +} + +const TEST_ITERATIONS = 150; + +for (let i = 0; i < TEST_ITERATIONS; i++) + ol.olTest(4); +for (let i = 0; i < TEST_ITERATIONS; i++) + ol.ol; +for (let i = 0; i < TEST_ITERATIONS; i++) + ol.ol = 4; + +for (let i = 0; i < TEST_ITERATIONS; i++) + cl.staticclTest(4); +for (let i = 0; i < TEST_ITERATIONS; i++) + cl.staticcl; +for (let i = 0; i < TEST_ITERATIONS; i++) + cl.staticcl = 4; + +for (let i = 0; i < TEST_ITERATIONS; i++) + new cl(); + +let clInst = new cl(); + +for (let i = 0; i < TEST_ITERATIONS; i++) + clInst.clTest(4); +for (let i = 0; i < TEST_ITERATIONS; i++) + clInst.cl; +for (let i = 0; i < TEST_ITERATIONS; i++) + clInst.cl = 4; + +if (typeof reportCompare === "function") + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/newTargetNonFunction.js b/js/src/tests/non262/class/newTargetNonFunction.js new file mode 100644 index 0000000000..59e6febef7 --- /dev/null +++ b/js/src/tests/non262/class/newTargetNonFunction.js @@ -0,0 +1,10 @@ +// Make sure that we can plumb new.target, even if the results are going to +// throw. + +assertThrowsInstanceOf(() => new ""(...Array()), TypeError); + +assertThrowsInstanceOf(() => new ""(), TypeError); +assertThrowsInstanceOf(() => new ""(1), TypeError); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/newTargetProxyNative.js b/js/src/tests/non262/class/newTargetProxyNative.js new file mode 100644 index 0000000000..89cdd64ab1 --- /dev/null +++ b/js/src/tests/non262/class/newTargetProxyNative.js @@ -0,0 +1,5 @@ +var proxyToArray = new Proxy(Array, {}); +new proxyToArray(); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/outerBinding.js b/js/src/tests/non262/class/outerBinding.js new file mode 100644 index 0000000000..19ffcb3e4a --- /dev/null +++ b/js/src/tests/non262/class/outerBinding.js @@ -0,0 +1,48 @@ +// |reftest| skip-if(!xulRuntime.shell) +// +// The above skip-if is because global lexicals aren't yet implemented. Remove +// that and the |evaluate| call below once they are. +// +// A class statement creates a mutable lexical outer binding. + +class Foo { constructor() { } } +assertEq(typeof Foo, "function"); +Foo = 5; +assertEq(Foo, 5); + +{ + class foo { constructor() { } } + assertEq(typeof foo, "function"); + foo = 4; + assertEq(foo, 4); +} + +{ + class PermanentBinding { constructor() { } } + delete PermanentBinding; + // That...didn't actually work, right? + assertEq(typeof PermanentBinding, "function"); +} + +evaluate("const globalConstant = 0; var earlyError = true;"); + +try { + evaluate("earlyError = false; class globalConstant { constructor() { } }"); +} catch (e) { + if (!(e instanceof SyntaxError)) + throw e; +} +assertEq(earlyError, true); + +function strictEvalShadows() { + "use strict"; + let x = 4; + eval(`class x { constructor() { } } + assertEq(typeof x, "function"); + `); + assertEq(x, 4); +} +strictEvalShadows() + +if (typeof reportCompare === "function") + reportCompare(0, 0, "OK"); diff --git a/js/src/tests/non262/class/parenExprToString.js b/js/src/tests/non262/class/parenExprToString.js new file mode 100644 index 0000000000..a93972ce92 --- /dev/null +++ b/js/src/tests/non262/class/parenExprToString.js @@ -0,0 +1,8 @@ +// Test that parenthesized class expressions don't get their toString offsets +// messed up. + +assertEq((class {}).toString(), "class {}"); +assertEq(((class {})).toString(), "class {}"); + +if (typeof reportCompare === "function") + reportCompare(0, 0, "OK"); diff --git a/js/src/tests/non262/class/shell.js b/js/src/tests/non262/class/shell.js new file mode 100644 index 0000000000..1169b2c5f4 --- /dev/null +++ b/js/src/tests/non262/class/shell.js @@ -0,0 +1,10 @@ +function assertThrownErrorContains(thunk, substr) { + try { + thunk(); + } catch (e) { + if (e.message.indexOf(substr) !== -1) + return; + throw new Error("Expected error containing " + substr + ", got " + e); + } + throw new Error("Expected error containing " + substr + ", no exception thrown"); +} diff --git a/js/src/tests/non262/class/staticConstructor.js b/js/src/tests/non262/class/staticConstructor.js new file mode 100644 index 0000000000..bd79c22005 --- /dev/null +++ b/js/src/tests/non262/class/staticConstructor.js @@ -0,0 +1,22 @@ +class testBasic { + constructor() { } + static constructor() { } +} + +class testWithExtends extends null { + constructor() { }; + static constructor() { }; +} + +class testOrder { + static constructor() { }; + constructor() { }; +} + +class testOrderWithExtends extends null { + static constructor() { }; + constructor() { }; +} + +if (typeof reportCompare === "function") + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/staticMethods.js b/js/src/tests/non262/class/staticMethods.js new file mode 100644 index 0000000000..756e5abf56 --- /dev/null +++ b/js/src/tests/non262/class/staticMethods.js @@ -0,0 +1,15 @@ +// basic static method test +class X { + static count() { return ++this.hits; } + constructor() { } +} +X.hits = 0; +assertEq(X.count(), 1); + +// A static method is just a function. +assertEq(X.count instanceof Function, true); +assertEq(X.count.length, 0); +assertEq(X.count.bind({hits: 77})(), 78); + +if (typeof reportCompare === "function") + reportCompare(0, 0, "OK"); diff --git a/js/src/tests/non262/class/strictExecution.js b/js/src/tests/non262/class/strictExecution.js new file mode 100644 index 0000000000..f459311e55 --- /dev/null +++ b/js/src/tests/non262/class/strictExecution.js @@ -0,0 +1,38 @@ +// Classes are always strict mode. Check computed property names and heritage +// expressions as well. + +class a { constructor() { Object.preventExtensions({}).prop = 0; } } +assertThrowsInstanceOf(() => new a(), TypeError); +var aExpr = class { constructor() { Object.preventExtensions().prop = 0; } }; +assertThrowsInstanceOf(() => new aExpr(), TypeError); + +function shouldThrowCPN() { + class b { + [Object.preventExtensions({}).prop = 4]() { } + constructor() { } + } +} +function shouldThrowCPNExpr() { + var b = class { + [Object.preventExtensions({}).prop = 4]() { } + constructor() { } + }; +} +assertThrowsInstanceOf(shouldThrowCPN, TypeError); +assertThrowsInstanceOf(shouldThrowCPNExpr, TypeError); + +function shouldThrowHeritage() { + class b extends (Object.preventExtensions({}).prop = 4) { + constructor() { } + } +} +function shouldThrowHeritageExpr() { + var b = class extends (Object.preventExtensions({}).prop = 4) { + constructor() { } + }; +} +assertThrowsInstanceOf(shouldThrowHeritage, TypeError); +assertThrowsInstanceOf(shouldThrowHeritageExpr, TypeError); + +if (typeof reportCompare === "function") + reportCompare(0, 0, "OK"); diff --git a/js/src/tests/non262/class/stringConstructor.js b/js/src/tests/non262/class/stringConstructor.js new file mode 100644 index 0000000000..4e8ae3331f --- /dev/null +++ b/js/src/tests/non262/class/stringConstructor.js @@ -0,0 +1,12 @@ +class A { + "constructor"() { return {}; } +} +assertEq(new A() instanceof A, false); + +class B extends class { } { + "constructor"() { return {}; } +} +assertEq(new B() instanceof B, false); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/subclassedArrayUnboxed.js b/js/src/tests/non262/class/subclassedArrayUnboxed.js new file mode 100644 index 0000000000..eb27a960d0 --- /dev/null +++ b/js/src/tests/non262/class/subclassedArrayUnboxed.js @@ -0,0 +1,22 @@ +class foo extends Array { } + +function testArrs(arrs) { + for (let arr of arrs) { + assertEq(Object.getPrototypeOf(arr), foo.prototype); + } +} + +var arrs = []; +for (var i = 0; i < 25; i++) + arrs.push(new foo(1)); + +testArrs(arrs); + +arrs[0].nonIndexedProp = "uhoh"; + +arrs.push(new foo(1)); + +testArrs(arrs); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superCallBadDynamicSuperClass.js b/js/src/tests/non262/class/superCallBadDynamicSuperClass.js new file mode 100644 index 0000000000..f5b3ac3c0c --- /dev/null +++ b/js/src/tests/non262/class/superCallBadDynamicSuperClass.js @@ -0,0 +1,12 @@ +class base { constructor() { } } + +class inst extends base { constructor() { super(); } } +Object.setPrototypeOf(inst, Math.sin); +assertThrowsInstanceOf(() => new inst(), TypeError); + +class defaultInst extends base { } +Object.setPrototypeOf(inst, Math.sin); +assertThrowsInstanceOf(() => new inst(), TypeError); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superCallBadNewTargetPrototype.js b/js/src/tests/non262/class/superCallBadNewTargetPrototype.js new file mode 100644 index 0000000000..43d1eb60d1 --- /dev/null +++ b/js/src/tests/non262/class/superCallBadNewTargetPrototype.js @@ -0,0 +1,25 @@ +class base { constructor() { } } + +// lies and the lying liars who tell them +function lies() { } +lies.prototype = 4; + +assertThrowsInstanceOf(()=>Reflect.consruct(base, [], lies), TypeError); + +// lie a slightly different way +function get(target, property, receiver) { + if (property === "prototype") + return 42; + return Reflect.get(target, property, receiver); +} + +class inst extends base { + constructor() { super(); } +} +assertThrowsInstanceOf(()=>new new Proxy(inst, {get})(), TypeError); + +class defaultInst extends base {} +assertThrowsInstanceOf(()=>new new Proxy(defaultInst, {get})(), TypeError); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superCallBaseInvoked.js b/js/src/tests/non262/class/superCallBaseInvoked.js new file mode 100644 index 0000000000..b66f9be170 --- /dev/null +++ b/js/src/tests/non262/class/superCallBaseInvoked.js @@ -0,0 +1,55 @@ +function testBase(base) { + class instance extends base { + constructor(inst, one) { + super(inst, one); + } + } + + let inst = new instance(instance, 1); + assertEq(Object.getPrototypeOf(inst), instance.prototype); + assertEq(inst.calledBase, true); + + class defaultInstance extends base { } + let defInst = new defaultInstance(defaultInstance, 1); + assertEq(Object.getPrototypeOf(defInst), defaultInstance.prototype); + assertEq(defInst.calledBase, true); +} + +class base { + // Base class must be [[Construct]]ed, as you cannot [[Call]] a class + // constructor + constructor(nt, one) { + assertEq(new.target, nt); + + // Check argument ordering + assertEq(one, 1); + this.calledBase = true; + } +} + +testBase(base); +testBase(class extends base { + constructor(nt, one) { + // Every step of the way, new.target and args should be right + assertEq(new.target, nt); + assertEq(one, 1); + super(nt, one); + } + }); +function baseFunc(nt, one) { + assertEq(new.target, nt); + assertEq(one, 1); + this.calledBase = true; +} + +testBase(baseFunc); + +let handler = {}; +let p = new Proxy(baseFunc, handler); +testBase(p); + +handler.construct = (target, args, nt) => Reflect.construct(target, args, nt); +testBase(p); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superCallIllegal.js b/js/src/tests/non262/class/superCallIllegal.js new file mode 100644 index 0000000000..8b7b36397d --- /dev/null +++ b/js/src/tests/non262/class/superCallIllegal.js @@ -0,0 +1,7 @@ +// super() invalid outside derived class constructors, including in dynamic +// functions and eval +assertThrowsInstanceOf(() => new Function("super();"), SyntaxError); +assertThrowsInstanceOf(() => eval("super()"), SyntaxError); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superCallInvalidBase.js b/js/src/tests/non262/class/superCallInvalidBase.js new file mode 100644 index 0000000000..86b24f96c5 --- /dev/null +++ b/js/src/tests/non262/class/superCallInvalidBase.js @@ -0,0 +1,9 @@ +class instance extends null { + constructor() { super(); } +} + +assertThrowsInstanceOf(() => new instance(), TypeError); +assertThrowsInstanceOf(() => new class extends null { }(), TypeError); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superCallOrder.js b/js/src/tests/non262/class/superCallOrder.js new file mode 100644 index 0000000000..46a1b0e57c --- /dev/null +++ b/js/src/tests/non262/class/superCallOrder.js @@ -0,0 +1,28 @@ +function base() { } + +class beforeSwizzle extends base { + constructor() { + super(Object.setPrototypeOf(beforeSwizzle, null)); + } +} + +new beforeSwizzle(); + +function MyError() {} + +// Again, testing both dynamic prototype dispatch, and that we verify the function +// is a constructor after evaluating args +class beforeThrow extends base { + constructor() { + function thrower() { throw new MyError(); } + super(thrower()); + } +} + +Object.setPrototypeOf(beforeThrow, Math.sin); + +// Won't throw that Math.sin is not a constructor before evaluating the args +assertThrowsInstanceOf(() => new beforeThrow(), MyError); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superCallProperBase.js b/js/src/tests/non262/class/superCallProperBase.js new file mode 100644 index 0000000000..cc03f57d08 --- /dev/null +++ b/js/src/tests/non262/class/superCallProperBase.js @@ -0,0 +1,34 @@ +class base1 { + constructor() { + this.base = 1; + } +} + +class base2 { + constructor() { + this.base = 2; + } +} + +class inst extends base1 { + constructor() { + super(); + } +} + +assertEq(new inst().base, 1); + +Object.setPrototypeOf(inst, base2); + +assertEq(new inst().base, 2); + +// Still works with default constructor + +class defaultInst extends base1 { } + +assertEq(new defaultInst().base, 1); +Object.setPrototypeOf(defaultInst, base2); +assertEq(new defaultInst().base, 2); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superCallSpreadCall.js b/js/src/tests/non262/class/superCallSpreadCall.js new file mode 100644 index 0000000000..1045f1a22a --- /dev/null +++ b/js/src/tests/non262/class/superCallSpreadCall.js @@ -0,0 +1,27 @@ +class base { + constructor(a, b, c) { + assertEq(a, 1); + assertEq(b, 2); + assertEq(c, 3); + this.calledBase = true; + } +} + +class doTest extends base { + constructor(arr) { + super(...arr); + } +} + +assertEq(new doTest([1,2,3]).calledBase, true); + +class testRest extends base { + constructor(...args) { + super(...args); + } +} + +assertEq(new testRest(1,2,3).calledBase, true); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superCallThisInit.js b/js/src/tests/non262/class/superCallThisInit.js new file mode 100644 index 0000000000..935f6b69ff --- /dev/null +++ b/js/src/tests/non262/class/superCallThisInit.js @@ -0,0 +1,48 @@ +function base() { this.prop = 42; } + +class testInitialize extends base { + constructor() { + // A poor man's assertThrowsInstanceOf, as arrow functions are currently + // disabled in this context + try { + this; + throw new Error(); + } catch (e) { + if (!(e instanceof ReferenceError)) + throw e; + } + super(); + assertEq(this.prop, 42); + } +} +assertEq(new testInitialize().prop, 42); + +// super() twice is a no-go. +class willThrow extends base { + constructor() { + super(); + super(); + } +} +assertThrowsInstanceOf(()=>new willThrow(), ReferenceError); + +// This is determined at runtime, not the syntax level. +class willStillThrow extends base { + constructor() { + for (let i = 0; i < 3; i++) { + super(); + } + } +} +assertThrowsInstanceOf(()=>new willStillThrow(), ReferenceError); + +class canCatchThrow extends base { + constructor() { + super(); + try { super(); } catch(e) { } + } +} +assertEq(new canCatchThrow().prop, 42); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superElemDelete.js b/js/src/tests/non262/class/superElemDelete.js new file mode 100644 index 0000000000..74d2c94e15 --- /dev/null +++ b/js/src/tests/non262/class/superElemDelete.js @@ -0,0 +1,68 @@ +// Make sure we get the proper side effects. +// |delete super[expr]| applies ToPropertyKey on |expr| before throwing. + +class base { + constructor() { } +} + +class derived extends base { + constructor() { super(); } + testDeleteElem() { + let sideEffect = 0; + let key = { + toString() { + sideEffect++; + return ""; + } + }; + assertThrowsInstanceOf(() => delete super[key], ReferenceError); + assertEq(sideEffect, 1); + } + testDeleteElemPropValFirst() { + // The deletion error is a reference error, even after munging the prototype + // chain. + let key = { + toString() { + Object.setPrototypeOf(derived.prototype, null); + return ""; + } + }; + delete super[key]; + } +} + +class derivedTestDeleteElem extends base { + constructor() { + let sideEffect = 0; + let key = { + toString() { + sideEffect++; + return ""; + } + }; + + assertThrowsInstanceOf(() => delete super[key], ReferenceError); + assertEq(sideEffect, 0); + + super(); + + assertThrowsInstanceOf(() => delete super[key], ReferenceError); + assertEq(sideEffect, 1); + + Object.setPrototypeOf(derivedTestDeleteElem.prototype, null); + + assertThrowsInstanceOf(() => delete super[key], ReferenceError); + assertEq(sideEffect, 2); + + return {}; + } +} + +var d = new derived(); +d.testDeleteElem(); +assertThrowsInstanceOf(() => d.testDeleteElemPropValFirst(), ReferenceError); + +new derivedTestDeleteElem(); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superPropBasicCalls.js b/js/src/tests/non262/class/superPropBasicCalls.js new file mode 100644 index 0000000000..c05d0ec26c --- /dev/null +++ b/js/src/tests/non262/class/superPropBasicCalls.js @@ -0,0 +1,27 @@ +// Super property (and calls) works in non-extending classes and object +// litterals. +class toStringTest { + constructor() { + // Install a property to make it plausible that it's the same this + this.foo = "rhinoceros"; + } + + test() { + assertEq(super.toString(), super["toString"]()); + assertEq(super.toString(), this.toString()); + } +} + +new toStringTest().test(); + +let toStrOL = { + test() { + assertEq(super.toString(), super["toString"]()); + assertEq(super.toString(), this.toString()); + } +} + +toStrOL.test(); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superPropBasicChain.js b/js/src/tests/non262/class/superPropBasicChain.js new file mode 100644 index 0000000000..12bf84820e --- /dev/null +++ b/js/src/tests/non262/class/superPropBasicChain.js @@ -0,0 +1,11 @@ +var o = { + access() { + super.foo.bar; + } +}; + +// Delazify +assertThrowsInstanceOf(o.access, TypeError); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superPropBasicGetter.js b/js/src/tests/non262/class/superPropBasicGetter.js new file mode 100644 index 0000000000..fe1f4eeee8 --- /dev/null +++ b/js/src/tests/non262/class/superPropBasicGetter.js @@ -0,0 +1,36 @@ +class base { + constructor() {} + + getValue() { + return this._prop; + } + + setValue(v) { + this._prop = v; + } +} + +class derived extends base { + constructor() { super(); } + + get a() { return super.getValue(); } + set a(v) { super.setValue(v); } + + get b() { return eval('super.getValue()'); } + set b(v) { eval('super.setValue(v);'); } + + test() { + this.a = 15; + assertEq(this.a, 15); + + assertEq(this.b, 15); + this.b = 30; + assertEq(this.b, 30); + } +} + +var derivedInstance = new derived(); +derivedInstance.test(); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superPropBasicNew.js b/js/src/tests/non262/class/superPropBasicNew.js new file mode 100644 index 0000000000..e1ca9b4ae1 --- /dev/null +++ b/js/src/tests/non262/class/superPropBasicNew.js @@ -0,0 +1,17 @@ +class Base { + constructor() {} +} +class Mid extends Base { + constructor() { super(); } + f() { return new super.constructor(); } +} +class Derived extends Mid { + constructor() { super(); } +} + +let d = new Derived(); +var df = d.f(); +assertEq(df.constructor, Base); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superPropChains.js b/js/src/tests/non262/class/superPropChains.js new file mode 100644 index 0000000000..e8c0de05cd --- /dev/null +++ b/js/src/tests/non262/class/superPropChains.js @@ -0,0 +1,58 @@ +// First, let's test the trivial. A chain of three works. +class base { + constructor() { } + testChain() { + this.baseCalled = true; + } +} + +class middle extends base { + constructor() { super(); } + testChain() { + this.middleCalled = true; + super.testChain(); + } +} + +class derived extends middle { + constructor() { super(); } + testChain() { + super.testChain(); + assertEq(this.middleCalled, true); + assertEq(this.baseCalled, true); + } +} + +new derived().testChain(); + +// Super even chains in a wellbehaved fashion with normal functions. +function bootlegMiddle() { } +bootlegMiddle.prototype = middle.prototype; + +new class extends bootlegMiddle { + constructor() { super(); } + testChain() { + super.testChain(); + assertEq(this.middleCalled, true); + assertEq(this.baseCalled, true); + } + }().testChain(); + +// Now let's try out some "long" chains +base.prototype.x = "yeehaw"; + +let chain = class extends base { constructor() { super(); } } + +const CHAIN_LENGTH = 100; +for (let i = 0; i < CHAIN_LENGTH; i++) + chain = class extends chain { constructor() { super(); } } + +// Now we poke the chain +let inst = new chain(); +inst.testChain(); +assertEq(inst.baseCalled, true); + +assertEq(inst.x, "yeehaw"); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superPropDVG.js b/js/src/tests/non262/class/superPropDVG.js new file mode 100644 index 0000000000..f187cb6ea1 --- /dev/null +++ b/js/src/tests/non262/class/superPropDVG.js @@ -0,0 +1,17 @@ +// Super property accesses should play nice with the pretty printer. +class testNonExistent { + constructor() { + super["prop"](); + } +} +// Should fold to super.prop +assertThrownErrorContains(() => new testNonExistent(), 'super.prop'); + +var ol = { testNonExistent() { super.prop(); } }; +assertThrownErrorContains(() => ol.testNonExistent(), "super.prop"); + +var olElem = { testNonExistent() { var prop = "prop"; super[prop](); } }; +assertThrownErrorContains(() => olElem.testNonExistent(), "super[prop]"); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superPropDelete.js b/js/src/tests/non262/class/superPropDelete.js new file mode 100644 index 0000000000..e0b71613ea --- /dev/null +++ b/js/src/tests/non262/class/superPropDelete.js @@ -0,0 +1,64 @@ +// Make sure we get the proper side effects. +// |delete super.prop| and |delete super[expr]| throw universally. + +class base { + constructor() { } +} + +class derived extends base { + constructor() { super(); } + testDeleteProp() { delete super.prop; } + testDeleteElem() { + let sideEffect = 0; + assertThrowsInstanceOf(() => delete super[sideEffect = 1], ReferenceError); + assertEq(sideEffect, 1); + } + testDeleteElemPropValFirst() { + // The deletion error is a reference error, but by munging the prototype + // chain, we can force a typeerror from JSOP_SUPERBASE + delete super[Object.setPrototypeOf(derived.prototype, null)]; + } +} + +var d = new derived(); +assertThrowsInstanceOf(() => d.testDeleteProp(), ReferenceError); +d.testDeleteElem(); +assertThrowsInstanceOf(() => d.testDeleteElemPropValFirst(), TypeError); + +// |delete super.x| does not delete anything before throwing. +var thing1 = { + go() { delete super.toString; } +}; +let saved = Object.prototype.toString; +assertThrowsInstanceOf(() => thing1.go(), ReferenceError); +assertEq(Object.prototype.toString, saved); + +// |delete super.x| does not tell the prototype to delete anything, when it's a proxy. +var thing2 = { + go() { delete super.prop; } +}; +Object.setPrototypeOf(thing2, new Proxy({}, { + deleteProperty(x) { throw "FAIL"; } +})); +assertThrowsInstanceOf(() => thing2.go(), ReferenceError); + +class derivedTestDeleteProp extends base { + constructor() { + // The deletion error is a reference error, even after munging the prototype + // chain. + Object.setPrototypeOf(derivedTestDeleteProp.prototype, null); + + assertThrowsInstanceOf(() => delete super.prop, ReferenceError); + + super(); + + assertThrowsInstanceOf(() => delete super.prop, ReferenceError); + + return {}; + } +} + +new derivedTestDeleteProp(); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superPropDerivedCalls.js b/js/src/tests/non262/class/superPropDerivedCalls.js new file mode 100644 index 0000000000..1a8a036057 --- /dev/null +++ b/js/src/tests/non262/class/superPropDerivedCalls.js @@ -0,0 +1,77 @@ +let derivedInstance; + +class base { + constructor() { } + method(a, b, c) { + assertEq(this, derivedInstance); + this.methodCalled = true; + assertEq(a, 1); + assertEq(b, 2); + assertEq(c, 3); + } + + get prop() { + assertEq(this, derivedInstance); + this.getterCalled = true; + return this._prop; + } + + set prop(val) { + assertEq(this, derivedInstance); + this.setterCalled = true; + this._prop = val; + } +} + +class derived extends base { + constructor() { super(); } + + // |super| actually checks the chain, not |this| + method() { throw "FAIL"; } + get prop() { throw "FAIL"; } + set prop(v) { throw "FAIL"; } + + test() { + this.reset(); + // While we're here. Let's check on super spread calls... + let spread = [1,2,3]; + super.method(...spread); + super.prop++; + this.asserts(); + } + + testInEval() { + this.reset(); + eval("super.method(1,2,3); super.prop++"); + this.asserts(); + } + + testInArrow() { + this.reset(); + (() => (super.method(1,2,3), super.prop++))(); + this.asserts(); + } + + reset() { + this._prop = 0; + this.methodCalled = false; + this.setterCalled = false; + this.getterCalled = false; + } + + asserts() { + assertEq(this.methodCalled, true); + assertEq(this.getterCalled, true); + assertEq(this.setterCalled, true); + assertEq(this._prop, 1); + } + +} + +derivedInstance = new derived(); +derivedInstance.test(); +derivedInstance.testInEval(); +derivedInstance.testInArrow(); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superPropDestructuring.js b/js/src/tests/non262/class/superPropDestructuring.js new file mode 100644 index 0000000000..84d1bb517a --- /dev/null +++ b/js/src/tests/non262/class/superPropDestructuring.js @@ -0,0 +1,43 @@ +class base { + constructor() { } +} + +let seenValues; +Object.defineProperty(base.prototype, "minutes", + { + set(x) { + assertEq(x, 525600); + seenValues.push(x); + } + }); +Object.defineProperty(base.prototype, "intendent", + { + set(x) { + assertEq(x, "Fred"); + seenValues.push(x) + } + }); + +const testArr = [525600, "Fred"]; +class derived extends base { + constructor() { super(); } + prepForTest() { seenValues = []; } + testAsserts() { assertDeepEq(seenValues, testArr); } + testProps() { + this.prepForTest(); + [super.minutes, super.intendent] = testArr; + this.testAsserts(); + } + testElems() { + this.prepForTest(); + [super["minutes"], super["intendent"]] = testArr; + this.testAsserts(); + } +} + +let d = new derived(); +d.testProps(); +d.testElems(); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superPropEvalInsideArrow.js b/js/src/tests/non262/class/superPropEvalInsideArrow.js new file mode 100644 index 0000000000..882f93ba0a --- /dev/null +++ b/js/src/tests/non262/class/superPropEvalInsideArrow.js @@ -0,0 +1,11 @@ +class foo { + constructor() { } + + method() { + return (() => eval('super.toString')); + } +} +assertEq(new foo().method()(), Object.prototype.toString); + +if (typeof reportCompare === "function") + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superPropEvalInsideNested.js b/js/src/tests/non262/class/superPropEvalInsideNested.js new file mode 100644 index 0000000000..04cdab0499 --- /dev/null +++ b/js/src/tests/non262/class/superPropEvalInsideNested.js @@ -0,0 +1,13 @@ +// It's invalid to eval super.prop inside a nested non-method, even if it +// appears inside a method definition +assertThrowsInstanceOf(() => +({ + method() { + (function () { + eval('super.toString'); + })(); + } +}).method(), SyntaxError); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superPropFor.js b/js/src/tests/non262/class/superPropFor.js new file mode 100644 index 0000000000..23b222cb3e --- /dev/null +++ b/js/src/tests/non262/class/superPropFor.js @@ -0,0 +1,25 @@ +class testForIn { + constructor() { + let hits = 0; + for (super.prop in { prop1: 1, prop2: 2 }) + hits++; + assertEq(this.prop, "prop2"); + assertEq(hits, 2); + } +} + +new testForIn(); + + +({ + testForOf() { + let hits = 0; + for (super["prop"] of [1, 2]) + hits++; + assertEq(this.prop, 2); + assertEq(hits, 2); + } +}).testForOf(); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superPropHeavyweightArrow.js b/js/src/tests/non262/class/superPropHeavyweightArrow.js new file mode 100644 index 0000000000..ce30690d53 --- /dev/null +++ b/js/src/tests/non262/class/superPropHeavyweightArrow.js @@ -0,0 +1,12 @@ +class foo { + constructor() { } + + method() { + return (() => (eval(''), super.toString)); + } +} + +assertEq(new foo().method()(), Object.prototype.toString); + +if (typeof reportCompare === "function") + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superPropHomeObject.js b/js/src/tests/non262/class/superPropHomeObject.js new file mode 100644 index 0000000000..b23c115dd5 --- /dev/null +++ b/js/src/tests/non262/class/superPropHomeObject.js @@ -0,0 +1,61 @@ +// This is super weird. A super property reference in the spec contains two +// things. The first is the object to do the lookup on, the super base. This +// should be unchanged, no matter what's going on: I can move the method to +// another object. I can pull it out as its own function. I can put it on my +// head and run around the front yard. No changes. The other half, the |this| +// for invoked calls, is the this at the time of referencing the property, which +// means it's gonna vary wildly as stuff gets moved around. + +class base { + constructor() { } + test(expectedThis) { assertEq(this, expectedThis); } +} + +class derived extends base { + constructor() { super(); } + test(expected) { super.test(expected); } + testArrow() { return (() => super.test(this)); } + ["testCPN"](expected) { super.test(expected); } +} + +let derivedInstance = new derived(); +derivedInstance.test(derivedInstance); +derivedInstance.testCPN(derivedInstance); + +let obj = { test: derivedInstance.test }; +obj.test(obj); + +// Classes are strict, so primitives are not boxed/turned into globals +let testSolo = derivedInstance.test; +testSolo(undefined); + +let anotherObject = { }; +derivedInstance.test.call(anotherObject, anotherObject); + +let strThis = "this is not an object!"; +derivedInstance.test.call(strThis, strThis); + +// You can take the arrow function out of the super, ... or something like that +let arrowTest = derivedInstance.testArrow(); +arrowTest(); + +// There's no magic "super script index" per code location. +class base1 { + constructor() { } + test() { return "llama"; } +} +class base2 { + constructor() { } + test() { return "alpaca"; } +} + +let animals = []; +for (let exprBase of [base1, base2]) + new class extends exprBase { + constructor() { super(); } + test() { animals.push(super["test"]()); } + }().test(); +assertDeepEq(animals, ["llama", "alpaca"]); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superPropIncDecElem.js b/js/src/tests/non262/class/superPropIncDecElem.js new file mode 100644 index 0000000000..a7b93eb371 --- /dev/null +++ b/js/src/tests/non262/class/superPropIncDecElem.js @@ -0,0 +1,24 @@ +// #1 +function base() { } + +base.prototype = { + test() { + --super[1]; + } +} + +var d = new base(); +d.test(); + +// #2 +class test2 { + test() { + super[1]++; + } +} + +var d = new test2(); +d.test() + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superPropLazyInnerFunction.js b/js/src/tests/non262/class/superPropLazyInnerFunction.js new file mode 100644 index 0000000000..d7a441f93b --- /dev/null +++ b/js/src/tests/non262/class/superPropLazyInnerFunction.js @@ -0,0 +1,19 @@ +testcase(); +function testcase() { + var tokenCodes = { + get try() { + try { + super.actual(); + } catch (e) {} + } + }; + var arr = [ + 'try', + ]; + for (var i = 0; i < arr.length; i++) { + if (tokenCodes[arr[i]] !== i) {}; + } +} + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superPropNoOverwriting.js b/js/src/tests/non262/class/superPropNoOverwriting.js new file mode 100644 index 0000000000..db44b509c5 --- /dev/null +++ b/js/src/tests/non262/class/superPropNoOverwriting.js @@ -0,0 +1,58 @@ +class X { + constructor() { + Object.defineProperty(this, "prop1", { + configurable: true, + writable: false, + value: 1 + }); + + Object.defineProperty(this, "prop2", { + configurable: true, + get: function() { return 15; } + }); + + Object.defineProperty(this, "prop3", { + configurable: true, + set: function(a) { } + }); + + Object.defineProperty(this, "prop4", { + configurable: true, + get: function() { return 20; }, + set: function(a) { } + }); + } + + f1() { + super.prop1 = 2; + } + + f2() { + super.prop2 = 3; + } + + f3() { + super.prop3 = 4; + } + + f4() { + super.prop4 = 5; + } +} + +var x = new X(); + +assertThrowsInstanceOf(() => x.f1(), TypeError); +assertEq(x.prop1, 1); + +assertThrowsInstanceOf(() => x.f2(), TypeError); +assertEq(x.prop2, 15); + +assertThrowsInstanceOf(() => x.f3(), TypeError); +assertEq(x.prop3, undefined); + +assertThrowsInstanceOf(() => x.f4(), TypeError); +assertEq(x.prop4, 20); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superPropOrdering.js b/js/src/tests/non262/class/superPropOrdering.js new file mode 100644 index 0000000000..1374d52c1c --- /dev/null +++ b/js/src/tests/non262/class/superPropOrdering.js @@ -0,0 +1,93 @@ +class base { + constructor() { } + method() { this.methodCalled++; } +} + +class derived extends base { + constructor() { super(); this.methodCalled = 0; } + + // Test orderings of various evaluations relative to the superbase + + // Unlike in regular element evaluation, the propVal is evaluated before + // checking the starting object ([[HomeObject]].[[Prototype]]) + testElem() { super[ruin()]; } + + // The starting object for looking up super.method is determined before + // ruin() is called. + testProp() { super.method(ruin()); } + + // The entire super.method property lookup has concluded before the args + // are evaluated + testPropCallDeleted() { super.method(()=>delete base.prototype.method); } + + // The starting object for looking up super["prop"] is determined before + // ruin() is called. + testElemAssign() { super["prop"] = ruin(); } + + // Test the normal assignment gotchas + testAssignElemPropValChange() { + let x = "prop1"; + super[x] = (()=>(x = "prop2", 0))(); + assertEq(this.prop1, 0); + assertEq(this.prop2, undefined); + } + + testAssignProp() { + Object.defineProperty(base.prototype, "piggy", + { + configurable: true, + set() { throw "WEE WEE WEE WEE"; } + }); + + // The property lookup is noted, but not actually evaluated, until the + // right hand side is. Please don't make the piggy cry. + super.piggy = (() => delete base.prototype.piggy)(); + } + testCompoundAssignProp() { + let getterCalled = false; + Object.defineProperty(base.prototype, "horse", + { + configurable: true, + get() { getterCalled = true; return "Of course"; }, + set() { throw "NO!"; } + }); + super.horse += (()=>(delete base.prototype.horse, ", of course!"))(); + assertEq(getterCalled, true); + + // So, is a horse a horse? + assertEq(this.horse, "Of course, of course!"); + } +} + +function ruin() { + Object.setPrototypeOf(derived.prototype, null); + return 5; +} + +function reset() { + Object.setPrototypeOf(derived.prototype, base.prototype); +} + +let instance = new derived(); +assertThrowsInstanceOf(() => instance.testElem(), TypeError); +reset(); + +instance.testProp(); +assertEq(instance.methodCalled, 1); +reset(); + +instance.testPropCallDeleted(); +assertEq(instance.methodCalled, 2); + +instance.testElemAssign(); +assertEq(instance.prop, 5); +reset(); + +instance.testAssignElemPropValChange(); + +instance.testAssignProp(); + +instance.testCompoundAssignProp(); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superPropProtoChanges.js b/js/src/tests/non262/class/superPropProtoChanges.js new file mode 100644 index 0000000000..d16ca16659 --- /dev/null +++ b/js/src/tests/non262/class/superPropProtoChanges.js @@ -0,0 +1,22 @@ +class base { + constructor() { } + test() { + return false; + } +} + +let standin = { test() { return true; } }; + +class derived extends base { + constructor() { super(); } + test() { + assertEq(super.test(), false); + Object.setPrototypeOf(derived.prototype, standin); + assertEq(super["test"](), true); + } +} + +new derived().test(); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superPropProxies.js b/js/src/tests/non262/class/superPropProxies.js new file mode 100644 index 0000000000..3ec43b279c --- /dev/null +++ b/js/src/tests/non262/class/superPropProxies.js @@ -0,0 +1,83 @@ +class base { + constructor() { } +} + +let midStaticHandler = { }; + +// We shouldn't use the |this.called| strategy here, since we have proxies +// snooping property accesses. +let getterCalled, setterCalled; + +class mid extends new Proxy(base, midStaticHandler) { + constructor() { super(); } + testSuperInProxy() { + super.prop = "looking"; + assertEq(setterCalled, true); + assertEq(super.prop, "found"); + assertEq(getterCalled, true); + } +} + +class child extends mid { + constructor() { super(); } + static testStaticLookups() { + // This funtion is called more than once. + this.called = false; + super.prop; + assertEq(this.called, true); + } +} + +let midInstance = new mid(); + +// Make sure proxies are searched properly on the prototype chain +let baseHandler = { + get(target, p, receiver) { + assertEq(receiver, midInstance); + getterCalled = true; + return "found"; + }, + + set(t,p,val,receiver) { + assertEq(receiver, midInstance); + assertEq(val, "looking"); + setterCalled = true; + return true; + } +} +Object.setPrototypeOf(base.prototype, new Proxy(Object.prototype, baseHandler)); + +// make sure subclasses are not searched on static or super lookups. +let childHandler = { + get() { throw "NO!"; }, + set() { throw "NO!"; } +} +Object.setPrototypeOf(child.prototype, new Proxy(mid.prototype, childHandler)); + +midInstance.testSuperInProxy(); + +// Don't do this earlier to avoid the lookup of .prototype during class creation +function midGet(target, p, receiver) { + assertEq(receiver, child); + receiver.called = true; +} +midStaticHandler.get = midGet; + +child.testStaticLookups(); + +// Hey does super work in a proxy? +assertEq(new Proxy(({ method() { return super.hasOwnProperty("method"); } }), {}).method(), true); + +// What about a CCW? +var g = newGlobal(); +var wrappedSuper = g.eval("({ method() { return super.hasOwnProperty('method'); } })"); +assertEq(wrappedSuper.method(), true); + +// With a CCW on the proto chain? +var wrappedBase = g.eval("({ method() { return this.__secretProp__; } })"); +var unwrappedDerived = { __secretProp__: 42, method() { return super.method(); } } +Object.setPrototypeOf(unwrappedDerived, wrappedBase); +assertEq(unwrappedDerived.method(), 42); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superPropSkips.js b/js/src/tests/non262/class/superPropSkips.js new file mode 100644 index 0000000000..c9587c72f1 --- /dev/null +++ b/js/src/tests/non262/class/superPropSkips.js @@ -0,0 +1,45 @@ +// Ensure that super lookups and sets skip over properties on the |this| object. +// That is, super lookups start with the superclass, not the current class. + +// The whole point: an empty superclass +class base { + constructor() { } +} + +class derived extends base { + constructor() { super(); this.prop = "flamingo"; } + + toString() { throw "No!"; } + + testSkipGet() { + assertEq(super.prop, undefined); + } + + testSkipDerivedOverrides() { + assertEq(super["toString"](), Object.prototype.toString.call(this)); + } + + testSkipSet() { + // since there's no prop on the chain, we should set the data property + // on the receiver, |this| + super.prop = "rat"; + assertEq(this.prop, "rat"); + + // Since the receiver is the instance, we can overwrite inherited + // properties of the instance, even non-writable ones, as they could be + // skipped in the super lookup. + assertEq(this.nonWritableProp, "pony"); + super.nonWritableProp = "bear"; + assertEq(this.nonWritableProp, "bear"); + } +} + +Object.defineProperty(derived.prototype, "nonWritableProp", { writable: false, value: "pony" }); + +let instance = new derived(); +instance.testSkipGet(); +instance.testSkipDerivedOverrides(); +instance.testSkipSet(); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superPropStatics.js b/js/src/tests/non262/class/superPropStatics.js new file mode 100644 index 0000000000..32624b5d28 --- /dev/null +++ b/js/src/tests/non262/class/superPropStatics.js @@ -0,0 +1,34 @@ +class base { + constructor() { } + static found() { + this.foundCalled = true; + } + static get accessor() { + assertEq(this, derived); + return 45; + } + notFound() { } +} + +class derived extends base { + constructor() { } + + static found() { throw "NO!"; } + static get accessor() { throw "NO!"; } + + static test() { + assertEq(super["notFound"], undefined); + super.found(); + + // foundCalled is set on |derived| specifically. + let calledDesc = Object.getOwnPropertyDescriptor(derived, "foundCalled"); + assertEq(calledDesc.value, true); + + assertEq(super.accessor, 45); + } +} + +derived.test(); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superPropStrictAssign.js b/js/src/tests/non262/class/superPropStrictAssign.js new file mode 100644 index 0000000000..4b5444a3cf --- /dev/null +++ b/js/src/tests/non262/class/superPropStrictAssign.js @@ -0,0 +1,23 @@ +// While |super| is common in classes, it also works in object litterals, +// where there is no guarantee of strict mode. Check that we do not somehow +// get strict mode semantics when they were not called for + +// |undefined|, writable: false +Object.defineProperty(Object.prototype, "prop", { writable: false }); + +class strictAssignmentTest { + constructor() { + // Strict mode. Throws. + super.prop = 14; + } +} + +assertThrowsInstanceOf(()=>new strictAssignmentTest(), TypeError); + +// Non-strict. Silent failure. +({ test() { super.prop = 14; } }).test(); + +assertEq(Object.prototype.prop, undefined); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/non262/class/superThisStrictNoBoxing.js b/js/src/tests/non262/class/superThisStrictNoBoxing.js new file mode 100644 index 0000000000..f479ac036a --- /dev/null +++ b/js/src/tests/non262/class/superThisStrictNoBoxing.js @@ -0,0 +1,31 @@ +class C { + get prop_this() { return this; } +} + +var g_prop_this = 'prop_this'; +class D extends C { + super_prop() { return super.prop_this; } + super_elem() { return super[g_prop_this]; } +} + +var barsym = Symbol("bar"); + +// Test that primitive |this| values are not boxed, and undefined/null are not +// globals for super.property. +assertEq(new D().super_prop.call(3), 3); +assertEq(new D().super_prop.call("foo"), "foo"); +assertEq(new D().super_prop.call(true), true); +assertEq(new D().super_prop.call(barsym), barsym); +assertEq(new D().super_prop.call(null), null); +assertEq(new D().super_prop.call(undefined), undefined); + +// Ditto for super[elem] +assertEq(new D().super_elem.call(3), 3); +assertEq(new D().super_elem.call("foo"), "foo"); +assertEq(new D().super_elem.call(true), true); +assertEq(new D().super_elem.call(barsym), barsym); +assertEq(new D().super_elem.call(null), null); +assertEq(new D().super_elem.call(undefined), undefined); + +if (typeof reportCompare === 'function') + reportCompare(0, 0); diff --git a/js/src/tests/non262/class/uninitializedThisError.js b/js/src/tests/non262/class/uninitializedThisError.js new file mode 100644 index 0000000000..658ef8002c --- /dev/null +++ b/js/src/tests/non262/class/uninitializedThisError.js @@ -0,0 +1,53 @@ +function checkErr(f) { + var expected = "must call super constructor before using 'this' in derived class constructor"; + try { + f(); + assertEq(0, 1); + } catch (e) { + assertEq(e.name, "ReferenceError"); + assertEq(e.message, expected); + } +} +class TestNormal extends class {} { + constructor() { this; } +} +checkErr(() => new TestNormal()); + +class TestEval extends class {} { + constructor() { eval("this") } +} +checkErr(() => new TestEval()); + +class TestNestedEval extends class {} { + constructor() { eval("eval('this')") } +} +checkErr(() => new TestNestedEval()); + +checkErr(() => { + new class extends class {} { + constructor() { eval("this") } + } +}); + +class TestArrow extends class {} { + constructor() { (() => this)(); } +} +checkErr(() => new TestArrow()); + +class TestArrowEval extends class {} { + constructor() { (() => eval("this"))(); } +} +checkErr(() => new TestArrowEval()); + +class TestEvalArrow extends class {} { + constructor() { eval("(() => this)()"); } +} +checkErr(() => new TestEvalArrow()); + +class TestTypeOf extends class {} { + constructor() { eval("typeof this"); } +} +checkErr(() => new TestTypeOf()); + +if (typeof reportCompare === 'function') + reportCompare(0, 0); |