Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 551 insertions, 0 deletions

diff --git a/js/src/tests/non262/reflect-parse/classes.js b/js/src/tests/non262/reflect-parse/classes.js
new file mode 100644
index 0000000000..b855c5d741
--- /dev/null
+++ b/js/src/tests/non262/reflect-parse/classes.js
@@ -0,0 +1,551 @@
+// |reftest| slow skip-if(!xulRuntime.shell)
+// Classes
+function testClasses() {
+    function methodFun(id, kind, generator, args, body = []) {
+        assertEq(generator && kind === "method", generator);
+        assertEq(typeof id === 'string' || id === null, true);
+        let methodName;
+        switch (kind) {
+            case "method":
+                methodName = typeof id === 'string' ? ident(id) : null;
+                break;
+            case "get":
+            case "set":
+                methodName = ident(`${kind} ${typeof id === 'string' ? id : ""}`);
+                break;
+            default:
+                methodName = null;
+                break;
+        }
+        return generator
+            ? genFunExpr("es6", methodName, args.map(ident), blockStmt(body))
+            : funExpr(methodName, args.map(ident), blockStmt(body));
+    }
+
+    function simpleMethod(id, kind, generator, args = [], isStatic = false) {
+        return classMethod(ident(id),
+            methodFun(id, kind, generator, args),
+            kind, isStatic);
+    }
+    function ctorWithName(id, body = []) {
+        return classMethod(ident("constructor"),
+            methodFun(id, "method", false, [], body),
+            "method", false);
+    }
+    function emptyCPNMethod(id, isStatic) {
+        return classMethod(computedName(lit(id)),
+            funExpr(null, [], blockStmt([])),
+            "method", isStatic);
+    }
+
+    function assertClassExpr(str, methods, heritage = null, name = null) {
+        let template = classExpr(name, heritage, methods);
+        assertExpr("(" + str + ")", template);
+    }
+
+    // FunctionExpression of constructor has class name as its id.
+    // FIXME: Implement ES6 function "name" property semantics (bug 883377).
+    let ctorPlaceholder = {};
+    function assertClass(str, methods, heritage = null, constructorBody = []) {
+        let namelessStr = str.replace("NAME", "");
+        let namedStr = str.replace("NAME", "Foo");
+        let namedCtor = ctorWithName("Foo", constructorBody);
+        let namelessCtor = ctorWithName(null, constructorBody);
+        let namelessMethods = methods.map(x => x == ctorPlaceholder ? namelessCtor : x);
+        let namedMethods = methods.map(x => x == ctorPlaceholder ? namedCtor : x);
+        assertClassExpr(namelessStr, namelessMethods, heritage);
+        assertClassExpr(namedStr, namedMethods, heritage, ident("Foo"));
+
+        let template = classStmt(ident("Foo"), heritage, namedMethods);
+        assertStmt(namedStr, template);
+    }
+    function assertNamedClassError(str, error) {
+        assertError(str, error);
+        assertError("(" + str + ")", error);
+    }
+    function assertClassError(str, error) {
+        assertNamedClassError(str, error);
+        assertError("(" + str.replace("NAME", "") + ")", error);
+    }
+
+    /* Trivial classes */
+    // Unnamed class statements are forbidden, but unnamed class expressions are
+    // just fine.
+    assertError("class { constructor() { } }", SyntaxError);
+    assertClass("class NAME { constructor() { } }", [ctorPlaceholder]);
+
+    // A class name must actually be a name
+    assertNamedClassError("class x.y { constructor() {} }", SyntaxError);
+    assertNamedClassError("class []  { constructor() {} }", SyntaxError);
+    assertNamedClassError("class {x} { constructor() {} }", SyntaxError);
+    assertNamedClassError("class for { constructor() {} }", SyntaxError);
+
+    // Allow methods and accessors
+    assertClass("class NAME { constructor() { } method() { } }",
+        [ctorPlaceholder, simpleMethod("method", "method", false)]);
+
+    assertClass("class NAME { constructor() { } get method() { } }",
+        [ctorPlaceholder, simpleMethod("method", "get", false)]);
+
+    assertClass("class NAME { constructor() { } set method(x) { } }",
+        [ctorPlaceholder, simpleMethod("method", "set", false, ["x"])]);
+
+    /* Static */
+    assertClass(`class NAME {
+                   constructor() { };
+                   static method() { };
+                   static *methodGen() { };
+                   static get getter() { };
+                   static set setter(x) { }
+                 }`,
+        [ctorPlaceholder,
+            simpleMethod("method", "method", false, [], true),
+            simpleMethod("methodGen", "method", true, [], true),
+            simpleMethod("getter", "get", false, [], true),
+            simpleMethod("setter", "set", false, ["x"], true)]);
+
+    // It's not an error to have a method named static, static, or not.
+    assertClass("class NAME { constructor() { } static() { } }",
+        [ctorPlaceholder, simpleMethod("static", "method", false)]);
+    assertClass("class NAME { static static() { }; constructor() { } }",
+        [simpleMethod("static", "method", false, [], true), ctorPlaceholder]);
+    assertClass("class NAME { static get static() { }; constructor() { } }",
+        [simpleMethod("static", "get", false, [], true), ctorPlaceholder]);
+    assertClass("class NAME { constructor() { }; static set static(x) { } }",
+        [ctorPlaceholder, simpleMethod("static", "set", false, ["x"], true)]);
+
+    // You do, however, have to put static in the right spot
+    assertClassError("class NAME { constructor() { }; get static foo() { } }", SyntaxError);
+
+    // Spec disallows "prototype" as a static member in a class, since that
+    // one's important to make the desugaring work
+    assertClassError("class NAME { constructor() { } static prototype() { } }", SyntaxError);
+    assertClassError("class NAME { constructor() { } static *prototype() { } }", SyntaxError);
+    assertClassError("class NAME { static get prototype() { }; constructor() { } }", SyntaxError);
+    assertClassError("class NAME { static set prototype(x) { }; constructor() { } }", SyntaxError);
+
+    // You are, however, allowed to have a CPN called prototype as a static
+    assertClass("class NAME { constructor() { }; static [\"prototype\"]() { } }",
+        [ctorPlaceholder, emptyCPNMethod("prototype", true)]);
+
+    /* Constructor */
+    // Allow default constructors
+    assertClass("class NAME { }", []);
+    assertClass("class NAME extends null { }", [], lit(null));
+
+    // Derived class constructor must have curly brackets
+    assertClassError("class NAME extends null {  constructor() 1 }", SyntaxError);
+
+    // It is an error to have two methods named constructor, but not other
+    // names, regardless if one is an accessor or a generator or static.
+    assertClassError("class NAME { constructor() { } constructor(a) { } }", SyntaxError);
+    let methods = [["method() { }", simpleMethod("method", "method", false)],
+    ["*method() { }", simpleMethod("method", "method", true)],
+    ["get method() { }", simpleMethod("method", "get", false)],
+    ["set method(x) { }", simpleMethod("method", "set", false, ["x"])],
+    ["static method() { }", simpleMethod("method", "method", false, [], true)],
+    ["static *method() { }", simpleMethod("method", "method", true, [], true)],
+    ["static get method() { }", simpleMethod("method", "get", false, [], true)],
+    ["static set method(x) { }", simpleMethod("method", "set", false, ["x"], true)]];
+    let i, j;
+    for (i = 0; i < methods.length; i++) {
+        for (j = 0; j < methods.length; j++) {
+            let str = "class NAME { constructor() { } " +
+                methods[i][0] + " " + methods[j][0] +
+                " }";
+            assertClass(str, [ctorPlaceholder, methods[i][1], methods[j][1]]);
+        }
+    }
+
+    // It is, however, not an error to have a constructor, and a method with a
+    // computed property name 'constructor'
+    assertClass("class NAME { constructor () { } [\"constructor\"] () { } }",
+        [ctorPlaceholder, emptyCPNMethod("constructor", false)]);
+
+    // It is an error to have a generator or accessor named constructor
+    assertClassError("class NAME { *constructor() { } }", SyntaxError);
+    assertClassError("class NAME { get constructor() { } }", SyntaxError);
+    assertClassError("class NAME { set constructor() { } }", SyntaxError);
+
+    /* Semicolons */
+    // Allow Semicolons in Class Definitions
+    assertClass("class NAME { constructor() { }; }", [ctorPlaceholder]);
+
+    // Allow more than one semicolon, even in otherwise trivial classses
+    assertClass("class NAME { ;;; constructor() { } }", [ctorPlaceholder]);
+
+    // Semicolons are optional, even if the methods share a line
+    assertClass("class NAME { method() { } constructor() { } }",
+        [simpleMethod("method", "method", false), ctorPlaceholder]);
+
+    /* Generators */
+    // No yield as a class name inside a generator
+    assertError(`function *foo() {
+                    class yield {
+                        constructor() { }
+                    }
+                 }`, SyntaxError);
+    assertError(`function *foo() {
+                    (class yield {
+                        constructor() { }
+                    })
+                 }`, SyntaxError);
+
+    // No legacy generators for methods.
+    assertClassError(`class NAME {
+                          constructor() { yield 2; }
+                      }`, SyntaxError);
+    assertClassError(`class NAME {
+                          method() { yield 2; }
+                      }`, SyntaxError);
+    assertClassError(`class NAME {
+                          get method() { yield 2; }
+                      }`, SyntaxError);
+    assertClassError(`class NAME {
+                          set method() { yield 2; }
+                      }`, SyntaxError);
+
+    // Methods may be generators, but not accessors
+    assertClassError("class NAME { constructor() { } *get foo() { } }", SyntaxError);
+    assertClassError("class NAME { constructor() { } *set foo() { } }", SyntaxError);
+
+    assertClass("class NAME { *method() { } constructor() { } }",
+        [simpleMethod("method", "method", true), ctorPlaceholder]);
+
+    /* Strictness */
+    // yield is a strict-mode keyword, and class definitions are always strict.
+    assertClassError("class NAME { constructor() { var yield; } }", SyntaxError);
+
+    // Beware of the strictness of computed property names. Here use bareword
+    // deletion (a deprecated action) to check.
+    assertClassError("class NAME { constructor() { } [delete bar]() { }}", SyntaxError);
+
+    /* Bindings */
+    // Class statements bind lexically, so they should collide with other
+    // in-block lexical bindings, but class expressions don't.
+    let FooCtor = ctorWithName("Foo");
+    assertError("{ let Foo; class Foo { constructor() { } } }", SyntaxError);
+    assertStmt("{ let Foo; (class Foo { constructor() { } }) }",
+        blockStmt([letDecl([{ id: ident("Foo"), init: null }]),
+        exprStmt(classExpr(ident("Foo"), null, [FooCtor]))]));
+    assertError("{ const Foo = 0; class Foo { constructor() { } } }", SyntaxError);
+    assertStmt("{ const Foo = 0; (class Foo { constructor() { } }) }",
+        blockStmt([constDecl([{ id: ident("Foo"), init: lit(0) }]),
+        exprStmt(classExpr(ident("Foo"), null, [FooCtor]))]));
+    assertError("{ class Foo { constructor() { } } class Foo { constructor() { } } }", SyntaxError);
+    assertStmt(`{
+                    (class Foo {
+                        constructor() { }
+                     },
+                     class Foo {
+                        constructor() { }
+                     });
+                }`,
+        blockStmt([exprStmt(seqExpr([classExpr(ident("Foo"), null, [FooCtor]),
+        classExpr(ident("Foo"), null, [FooCtor])]))]));
+    assertStmt(`{
+                    var x = class Foo { constructor() { } };
+                    class Foo { constructor() { } }
+                }`,
+        blockStmt([varDecl([{
+            id: ident("x"),
+            init: classExpr(ident("Foo"), null, [FooCtor])
+        }]),
+        classStmt(ident("Foo"), null, [FooCtor])]));
+
+
+    // Can't make a lexical binding without a block.
+    assertError("if (1) class Foo { constructor() { } }", SyntaxError);
+
+    /* Heritage Expressions */
+    // It's illegal to have things that look like "multiple inheritance":
+    // non-parenthesized comma expressions.
+    assertClassError("class NAME extends null, undefined { constructor() { } }", SyntaxError);
+
+    // Again check for strict-mode in heritage expressions
+    assertClassError("class NAME extends (delete x) { constructor() { } }", SyntaxError);
+
+    // You must specify an inheritance if you say "extends"
+    assertClassError("class NAME extends { constructor() { } }", SyntaxError);
+
+    // "extends" is still a valid name for a method
+    assertClass("class NAME { constructor() { }; extends() { } }",
+        [ctorPlaceholder, simpleMethod("extends", "method", false)]);
+
+    // Immediate expression
+    assertClass("class NAME extends null { constructor() { } }",
+        [ctorPlaceholder], lit(null));
+
+    // Sequence expresson
+    assertClass("class NAME extends (undefined, undefined) { constructor() { } }",
+        [ctorPlaceholder], seqExpr([ident("undefined"), ident("undefined")]));
+
+    // Function expression
+    let emptyFunction = funExpr(null, [], blockStmt([]));
+    assertClass("class NAME extends function(){ } { constructor() { } }",
+        [ctorPlaceholder], emptyFunction);
+
+    // New expression
+    assertClass("class NAME extends new function(){ }() { constructor() { } }",
+        [ctorPlaceholder], newExpr(emptyFunction, []));
+
+    // Call expression
+    assertClass("class NAME extends function(){ }() { constructor() { } }",
+        [ctorPlaceholder], callExpr(emptyFunction, []));
+
+    // Dot expression
+    assertClass("class NAME extends {}.foo { constructor() { } }",
+        [ctorPlaceholder], dotExpr(objExpr([]), ident("foo")));
+
+    // Member expression
+    assertClass("class NAME extends {}[foo] { constructor() { } }",
+        [ctorPlaceholder], memExpr(objExpr([]), ident("foo")));
+
+    // #constructor is an invalid private method name.
+    assertClassError("class NAME { #constructor() { } }", SyntaxError);
+
+    const method = ["#method() { }", simpleMethod("#method", "method", false)];
+    const generator = ["*#method() { }", simpleMethod("#method", "method", true)];
+    const getter = ["get #method() { }", simpleMethod("#method", "get", false)];
+    const setter = ["set #method(x) { }", simpleMethod("#method", "set", false, ["x"])];
+    for (const [source, parsed] of [method, generator, getter, setter]) {
+        assertClass(`class NAME { constructor() { } ${source} }`, [ctorPlaceholder, parsed]);
+    }
+
+    // Private getters and setters of the same name are allowed.
+    assertClass(`class NAME { constructor() { } ${getter[0]} ${setter[0]} }`,
+        [ctorPlaceholder, getter[1], setter[1]]);
+    assertClass(`class NAME { constructor() { } ${setter[0]} ${getter[0]} }`,
+        [ctorPlaceholder, setter[1], getter[1]]);
+
+    // Private method names can't be used multiple times, other than for a getter/setter pair.
+    for (const [source1, _] of [method, generator, getter, setter]) {
+        for (const [source2, _] of [method, generator]) {
+            assertClassError(`class NAME { constructor() { } ${source1} ${source2} }`, SyntaxError);
+        }
+    }
+
+    assertClassError(`class NAME { constructor() { } ${setter[0]} ${setter[0]} }`, SyntaxError);
+    assertClassError(`class NAME { constructor() { } ${getter[0]} ${getter[0]} }`, SyntaxError);
+
+
+    /* SuperProperty */
+    // NOTE: Some of these tests involve object literals, as SuperProperty is a
+    // valid production in any method definition, including in objectl
+    // litterals. These tests still fall here, as |super| is not implemented in
+    // any form without classes.
+
+    function assertValidSuperProps(assertion, makeStr, makeExpr, type, generator, args, static,
+        extending) {
+        let superProperty = superProp(ident("prop"));
+        let superMember = superElem(lit("prop"));
+
+        let situations = [
+            ["super.prop", superProperty],
+            ["super['prop']", superMember],
+            ["super.prop()", callExpr(superProperty, [])],
+            ["super['prop']()", callExpr(superMember, [])],
+            ["new super.prop()", newExpr(superProperty, [])],
+            ["new super['prop']()", newExpr(superMember, [])],
+            ["delete super.prop", unExpr("delete", superProperty)],
+            ["delete super['prop']", unExpr("delete", superMember)],
+            ["++super.prop", updExpr("++", superProperty, true)],
+            ["super['prop']--", updExpr("--", superMember, false)],
+            ["super.prop = 4", aExpr("=", superProperty, lit(4))],
+            ["super['prop'] = 4", aExpr("=", superMember, lit(4))],
+            ["super.prop += 4", aExpr("+=", superProperty, lit(4))],
+            ["super['prop'] += 4", aExpr("+=", superMember, lit(4))],
+            ["super.prop -= 4", aExpr("-=", superProperty, lit(4))],
+            ["super['prop'] -= 4", aExpr("-=", superMember, lit(4))],
+            ["super.prop *= 4", aExpr("*=", superProperty, lit(4))],
+            ["super['prop'] *= 4", aExpr("*=", superMember, lit(4))],
+            ["super.prop /= 4", aExpr("/=", superProperty, lit(4))],
+            ["super['prop'] /= 4", aExpr("/=", superMember, lit(4))],
+            ["super.prop %= 4", aExpr("%=", superProperty, lit(4))],
+            ["super['prop'] %= 4", aExpr("%=", superMember, lit(4))],
+            ["super.prop <<= 4", aExpr("<<=", superProperty, lit(4))],
+            ["super['prop'] <<= 4", aExpr("<<=", superMember, lit(4))],
+            ["super.prop >>= 4", aExpr(">>=", superProperty, lit(4))],
+            ["super['prop'] >>= 4", aExpr(">>=", superMember, lit(4))],
+            ["super.prop >>>= 4", aExpr(">>>=", superProperty, lit(4))],
+            ["super['prop'] >>>= 4", aExpr(">>>=", superMember, lit(4))],
+            ["super.prop |= 4", aExpr("|=", superProperty, lit(4))],
+            ["super['prop'] |= 4", aExpr("|=", superMember, lit(4))],
+            ["super.prop ^= 4", aExpr("^=", superProperty, lit(4))],
+            ["super['prop'] ^= 4", aExpr("^=", superMember, lit(4))],
+            ["super.prop &= 4", aExpr("&=", superProperty, lit(4))],
+            ["super['prop'] &= 4", aExpr("&=", superMember, lit(4))],
+
+            // We can also use super from inside arrow functions in method
+            // definitions
+            ["()=>super.prop", arrowExpr([], superProperty)],
+            ["()=>super['prop']", arrowExpr([], superMember)]];
+
+        for (let situation of situations) {
+            let sitStr = situation[0];
+            let sitExpr = situation[1];
+
+            let fun = methodFun("method", type, generator, args, [exprStmt(sitExpr)]);
+            let str = makeStr(sitStr, type, generator, args, static, extending);
+            assertion(str, makeExpr(fun, type, static), extending);
+        }
+    }
+
+    function assertValidSuperPropTypes(assertion, makeStr, makeExpr, static, extending) {
+        for (let type of ["method", "get", "set"]) {
+            if (type === "method") {
+                // methods can also be generators
+                assertValidSuperProps(assertion, makeStr, makeExpr, type, true, [], static, extending);
+                assertValidSuperProps(assertion, makeStr, makeExpr, type, false, [], static, extending);
+                continue;
+            }
+
+            // Setters require 1 argument, and getters require 0
+            assertValidSuperProps(assertion, makeStr, makeExpr, type, false,
+                type === "set" ? ["x"] : [], static, extending);
+        }
+    }
+
+    function makeSuperPropMethodStr(propStr, type, generator, args) {
+        return `${type === "method" ? "" : type} ${generator ? "*" : ""} method(${args.join(",")})
+                {
+                    ${propStr};
+                }`;
+    }
+
+    function makeClassSuperPropStr(propStr, type, generator, args, static, extending) {
+        return `class NAME ${extending ? "extends null" : ""} {
+                    constructor() { };
+                    ${static ? "static" : ""} ${makeSuperPropMethodStr(propStr, type, generator, args)}
+                }`;
+    }
+    function makeClassSuperPropExpr(fun, type, static) {
+        // We are going right into assertClass, so we don't have to build the
+        // entire statement.
+        return [ctorPlaceholder,
+            classMethod(ident("method"), fun, type, static)];
+    }
+    function doClassSuperPropAssert(str, expr, extending) {
+        assertClass(str, expr, extending ? lit(null) : null);
+    }
+    function assertValidClassSuperPropExtends(extending) {
+        // super.prop and super[prop] are valid, regardless of whether the
+        // method is static or not
+        assertValidSuperPropTypes(doClassSuperPropAssert, makeClassSuperPropStr, makeClassSuperPropExpr,
+            false, extending);
+        assertValidSuperPropTypes(doClassSuperPropAssert, makeClassSuperPropStr, makeClassSuperPropExpr,
+            true, extending);
+    }
+    function assertValidClassSuperProps() {
+        // super.prop and super[prop] are valid, regardless of class heritage
+        assertValidClassSuperPropExtends(false);
+        assertValidClassSuperPropExtends(true);
+    }
+
+    function makeOLSuperPropStr(propStr, type, generator, args) {
+        let str = `({ ${makeSuperPropMethodStr(propStr, type, generator, args)} })`;
+        return str;
+    }
+    function makeOLSuperPropExpr(fun) {
+        return objExpr([{ type: "Property", key: ident("method"), value: fun }]);
+    }
+    function assertValidOLSuperProps() {
+        assertValidSuperPropTypes(assertExpr, makeOLSuperPropStr, makeOLSuperPropExpr);
+    }
+
+
+    // Check all valid uses of SuperProperty
+    assertValidClassSuperProps();
+    assertValidOLSuperProps();
+
+    // SuperProperty is forbidden outside of method definitions.
+    assertError("function foo () { super.prop; }", SyntaxError);
+    assertError("(function () { super.prop; }", SyntaxError);
+    assertError("(()=>super.prop)", SyntaxError);
+    assertError("function *foo() { super.prop; }", SyntaxError);
+    assertError("super.prop", SyntaxError);
+    assertError("function foo () { super['prop']; }", SyntaxError);
+    assertError("(function () { super['prop']; }", SyntaxError);
+    assertError("(()=>super['prop'])", SyntaxError);
+    assertError("function *foo() { super['prop']; }", SyntaxError);
+    assertError("super['prop']", SyntaxError);
+
+    // Or inside functions inside method definitions...
+    assertClassError("class NAME { constructor() { function nested() { super.prop; }}}", SyntaxError);
+
+    // Bare super is forbidden
+    assertError("super", SyntaxError);
+
+    // Even where super is otherwise allowed
+    assertError("{ foo() { super } }", SyntaxError);
+    assertClassError("class NAME { constructor() { super; } }", SyntaxError);
+
+    /* SuperCall */
+
+    // SuperCall is invalid outside derived class constructors.
+    assertError("super()", SyntaxError);
+    assertError("(function() { super(); })", SyntaxError);
+
+
+    // Even in class constructors
+    assertClassError("class NAME { constructor() { super(); } }", SyntaxError);
+
+    function superConstructor(args) {
+        return classMethod(ident("constructor"),
+            methodFun("NAME", "method", false,
+                [], [exprStmt(superCallExpr(args))]),
+            "method", false);
+    }
+
+    function superCallBody(args) {
+        return [exprStmt(superCallExpr(args))];
+    }
+
+    // SuperCall works with various argument configurations.
+    assertClass("class NAME extends null { constructor() { super() } }",
+        [ctorPlaceholder], lit(null), superCallBody([]));
+    assertClass("class NAME extends null { constructor() { super(1) } }",
+        [ctorPlaceholder], lit(null), superCallBody([lit(1)]));
+    assertClass("class NAME extends null { constructor() { super(1, a) } }",
+        [ctorPlaceholder], lit(null), superCallBody([lit(1), ident("a")]));
+    assertClass("class NAME extends null { constructor() { super(...[]) } }",
+        [ctorPlaceholder], lit(null), superCallBody([spread(arrExpr([]))]));
+
+    /* EOF */
+    // Clipped classes should throw a syntax error
+    assertClassError("class NAME {", SyntaxError);
+    assertClassError("class NAME {;", SyntaxError);
+    assertClassError("class NAME { constructor", SyntaxError);
+    assertClassError("class NAME { constructor(", SyntaxError);
+    assertClassError("class NAME { constructor()", SyntaxError);
+    assertClassError("class NAME { constructor()", SyntaxError);
+    assertClassError("class NAME { constructor() {", SyntaxError);
+    assertClassError("class NAME { constructor() { }", SyntaxError);
+    assertClassError("class NAME { static", SyntaxError);
+    assertClassError("class NAME { static y", SyntaxError);
+    assertClassError("class NAME { static *", SyntaxError);
+    assertClassError("class NAME { static *y", SyntaxError);
+    assertClassError("class NAME { static get", SyntaxError);
+    assertClassError("class NAME { static get y", SyntaxError);
+    assertClassError("class NAME { static ;", SyntaxError);
+    assertClassError("class NAME extends", SyntaxError);
+    assertClassError("class NAME { constructor() { super", SyntaxError);
+    assertClassError("class NAME { constructor() { super.", SyntaxError);
+    assertClassError("class NAME { constructor() { super.x", SyntaxError);
+    assertClassError("class NAME { constructor() { super.m(", SyntaxError);
+    assertClassError("class NAME { constructor() { super[", SyntaxError);
+    assertClassError("class NAME { constructor() { super(", SyntaxError);
+
+    // Can not omit curly brackets
+    assertClassError("class NAME { constructor() ({}) }", SyntaxError);
+    assertClassError("class NAME { constructor() void 0 }", SyntaxError);
+    assertClassError("class NAME { constructor() 1 }", SyntaxError);
+    assertClassError("class NAME { constructor() false }", SyntaxError);
+    assertClassError("class NAME { constructor() {} a() ({}) }", SyntaxError);
+    assertClassError("class NAME { constructor() {} a() void 0 }", SyntaxError);
+    assertClassError("class NAME { constructor() {} a() 1 }", SyntaxError);
+    assertClassError("class NAME { constructor() {} a() false }", SyntaxError);
+
+}
+
+runtest(testClasses);