1 files changed, 172 insertions, 0 deletions
diff --git a/js/src/jit-test/tests/decorators/syntax.js b/js/src/jit-test/tests/decorators/syntax.js
new file mode 100644
index 0000000000..635e30bf7b
--- /dev/null
+++ b/js/src/jit-test/tests/decorators/syntax.js
@@ -0,0 +1,172 @@
+// |jit-test| skip-if: !getBuildConfiguration("decorators")
+
+load(libdir + "asserts.js");
+
+Reflect.parse("class c {@dec1 field = false;}");
+Reflect.parse("class c {@dec1 @dec2 @dec3 field = false;}");
+Reflect.parse("class c {@dec1 @dec2 @dec3('a') static field = false;}");
+Reflect.parse("class c {@dec1 method() {};}");
+Reflect.parse("class c {@dec1 @dec2 @dec3 method() {};}");
+Reflect.parse("class c {@dec1 @dec2 @dec3 static method() {};}");
+Reflect.parse("class c {@dec1 @dec2('a') @dec3 method(...args) {};}");
+Reflect.parse("class c {@((a, b, c) => {}) method(a, b) {};}");
+Reflect.parse("class c {@((a, b, c) => {}) @dec2('a', 'b') @dec3 method(a, b) {};}");
+Reflect.parse("@dec1 class c {}");
+Reflect.parse("@dec1 @dec2 @dec3 class c {}");
+Reflect.parse("@dec1('a') @(() => {}) @dec3 class c {}");
+Reflect.parse("@dec1('a') @(() => {}) @dec3 class c {@((a, b, c) => {}) @dec2('a', 'b') @dec3 method(a, b) {};}");
+Reflect.parse("x = @dec class { #x }");
+Reflect.parse("x = (class A { }, @dec class { })");
+Reflect.parse("@dec1 class A extends @dec2 class B extends @dec3 class {} {} {}");
+Reflect.parse("class c {@dec1.dec2.dec3 method() {};}");
+Reflect.parse("class c {@dec1 @dec2.dec3.dec4 @dec5 method() {};}");
+Reflect.parse("class c {@dec1('a') @dec2.dec3.dec4 @dec5 method() {};}");
+Reflect.parse("class c {@dec1('a') @dec2.dec3.dec4('b', 'c') @dec5 method() {};}");
+Reflect.parse("class c {@dec1('a') @dec2.dec3.dec4('b', 'c') @dec5.dec6 method() {};}");
+Reflect.parse("@dec1.dec2 class c {}");
+Reflect.parse("@dec1.dec2 @dec3.dec4 @dec5 class c {}");
+Reflect.parse("@dec1.dec2('a') @(() => {}) @dec4 class c {}");
+Reflect.parse("@dec1.dec2('a') @(() => {}) @dec4 class c {@((a, b, c) => {}) @dec5.dec6('a', 'b') @dec7 method(a, b) {};}");
+Reflect.parse("class c {accessor field = false;}");
+Reflect.parse("class c {static accessor field = false;}");
+Reflect.parse("class c {@dec1 @dec2 accessor field = false;}");
+Reflect.parse("class c {@dec1 @dec2 @dec3 static accessor field = false;}");
+Reflect.parse("let accessor = false;");
+Reflect.parse("class accessor {accessor = false;}");
+Reflect.parse("class c {accessor = false;}");
+Reflect.parse("class c {accessor\n= false;}");
+Reflect.parse("class c {accessor\nfield = false;}");
+Reflect.parse("class C {accessor\n foo() {}}");
+Reflect.parse("class c {accessor; }");
+Reflect.parse("class c {accessor\nset field(a) {}}");
+Reflect.parse("class c {accessor\nasync field(a) {}}");
+Reflect.parse("class c {accessor\n* field(a) {}}");
+Reflect.parse("{accessor, field(a)}");
+Reflect.parse("class c {static accessor x = 1;}");
+Reflect.parse("class c {accessor #y = 2;}");
+Reflect.parse("class c {static dec1(){}; static {@c.dec1 class d{@c.dec1 field}}}");
+Reflect.parse("class c {static #dec1(){}; static {@c.#dec1 class d{@c.#dec1 field}}}");
+Reflect.parse("class c {@as field = false;}");
+Reflect.parse("class c {@accessor field = false;}");
+Reflect.parse("class c {@assert field = false;}");
+Reflect.parse("class c {@async field = false;}");
+Reflect.parse("class c {@await field = false;}");
+Reflect.parse("class c {@each field = false;}");
+Reflect.parse("class c {@from field = false;}");
+Reflect.parse("class c {@get field = false;}");
+Reflect.parse("class c {@meta field = false;}");
+Reflect.parse("class c {@of field = false;}");
+Reflect.parse("class c {@set field = false;}");
+Reflect.parse("class c {@target field = false;}");
+
+assertThrowsInstanceOf(() => Reflect.parse("class c {@ method() {};}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@((a, b, c => {}) method(a, b) {};}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@dec1 static @dec2 method(a, b) {};}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("@dec1 let x = 1"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("@dec1 f(a) {}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("@dec1 () => {}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("@class class { x; }"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("@for class { x; }"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@dec1. method() {};}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("@dec1. class c {method() {};}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("@dec1.(a) class c {method() {};}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {accessor method() {};}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {accessor @dec1 field = false;}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {accessor, }"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("({ accessor field: 10 })"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("({ accessor foo });"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("({ accessor foo = 10 } = {});"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {async accessor foo() {}}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {accessor set field(a) {}}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {accessor *field(a) {}}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {accessor *field(a) {}}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@dec[0] x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@new dec() x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@super x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@super() x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@super.dec() x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@import \"decorator\" x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@dec`template` x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@import.meta.url x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@new.target x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@obj.first?.second x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@class x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@function() x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@{} x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@[] x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@\"string\" x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@`string` x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@/[a-z]+/ x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@true x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@1n x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@this x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@null x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@... x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@let x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@static x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@yield x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@if x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@enum x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@implements x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@foo().bar.prop x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@foo.bar().prop x}"), SyntaxError);
+assertThrowsInstanceOf(() => Reflect.parse("class c {@foo.bar().prop() x}"), SyntaxError);
+
+// assert we have the right syntax tree
+const syntax = Reflect.parse("class c {}");
+assertEq(syntax.type, "Program");
+assertEq(syntax.body.length, 1);
+assertEq(syntax.body[0].type, "ClassStatement");
+assertEq(syntax.body[0].id.type, "Identifier");
+assertEq(syntax.body[0].id.name, "c");
+assertEq(syntax.body[0].decorators, null);
+
+// assert decrorators on a class
+const syntax2 = Reflect.parse("@dec @dec2 class c {}");
+assertEq(syntax2.type, "Program");
+assertEq(syntax2.body.length, 1);
+assertEq(syntax2.body[0].decorators.type, "SequenceExpression");
+assertEq(syntax2.body[0].decorators.expressions.length, 2);
+assertEq(syntax2.body[0].decorators.expressions[0].type, "Identifier");
+assertEq(syntax2.body[0].decorators.expressions[0].name, "dec");
+assertEq(syntax2.body[0].decorators.expressions[1].type, "Identifier");
+assertEq(syntax2.body[0].decorators.expressions[1].name, "dec2");
+
+// assert decorators on class fields
+const syntax3 = Reflect.parse("class c {@dec1 @dec2 field = false;}");
+assertEq(syntax3.type, "Program");
+assertEq(syntax3.body.length, 1);
+assertEq(syntax3.body[0].decorators, null);
+assertEq(syntax3.body[0].body[0].type, "ClassField");
+assertEq(syntax3.body[0].body[0].decorators.type, "SequenceExpression");
+assertEq(syntax3.body[0].body[0].decorators.expressions.length, 2);
+assertEq(syntax3.body[0].body[0].decorators.expressions[0].type, "Identifier");
+assertEq(syntax3.body[0].body[0].decorators.expressions[0].name, "dec1");
+assertEq(syntax3.body[0].body[0].decorators.expressions[1].type, "Identifier");
+assertEq(syntax3.body[0].body[0].decorators.expressions[1].name, "dec2");
+
+// assert decorators on accessors
+const syntax4 = Reflect.parse("class c {@dec1 @dec2 accessor field = false;}");
+assertEq(syntax3.type, "Program");
+assertEq(syntax3.body.length, 1);
+assertEq(syntax3.body[0].decorators, null);
+assertEq(syntax3.body[0].body[0].type, "ClassField");
+assertEq(syntax3.body[0].body[0].decorators.type, "SequenceExpression");
+assertEq(syntax3.body[0].body[0].decorators.expressions.length, 2);
+assertEq(syntax3.body[0].body[0].decorators.expressions[0].type, "Identifier");
+assertEq(syntax3.body[0].body[0].decorators.expressions[0].name, "dec1");
+assertEq(syntax3.body[0].body[0].decorators.expressions[1].type, "Identifier");
+assertEq(syntax3.body[0].body[0].decorators.expressions[1].name, "dec2");
+
+// assert decorators on methods
+const syntax5 = Reflect.parse("class c {@dec1 @dec2 method() {};}");
+assertEq(syntax5.type, "Program");
+assertEq(syntax5.body.length, 1);
+assertEq(syntax5.body[0].decorators, null);
+assertEq(syntax5.body[0].body[0].type, "ClassMethod");
+assertEq(syntax5.body[0].body[0].decorators.type, "SequenceExpression");
+assertEq(syntax5.body[0].body[0].decorators.expressions.length, 2);
+assertEq(syntax5.body[0].body[0].decorators.expressions[0].type, "Identifier");
+assertEq(syntax5.body[0].body[0].decorators.expressions[0].name, "dec1");
+assertEq(syntax5.body[0].body[0].decorators.expressions[1].type, "Identifier");
+assertEq(syntax5.body[0].body[0].decorators.expressions[1].name, "dec2");