Invalid flags in a RegExp literal should be an early SyntaxError
[WebKit-https.git] / JSTests / stress / generator-syntax.js
1 function testSyntax(script) {
2     try {
3         eval(script);
4     } catch (error) {
5         if (error instanceof SyntaxError)
6             throw new Error("Bad error: " + String(error));
7     }
8 }
9
10 function testSyntaxError(script, message) {
11     var error = null;
12     try {
13         eval(script);
14     } catch (e) {
15         error = e;
16     }
17     if (!error)
18         throw new Error("Expected syntax error not thrown");
19
20     if (String(error) !== message)
21         throw new Error("Bad error: " + String(error));
22 }
23
24 testSyntaxError(`
25 class Hello {
26     get *gen() {
27     }
28 }
29 `, `SyntaxError: Unexpected token '*'. Expected an opening '(' before a method's parameter list.`);
30
31
32 testSyntaxError(`
33 class Hello {
34     set *gen(value) {
35     }
36 }
37 `, `SyntaxError: Unexpected token '*'. Expected an opening '(' before a method's parameter list.`);
38
39 testSyntaxError(`
40 function ** gen() { }
41 `, `SyntaxError: Unexpected token '**'`);
42
43 // "yield" is never a YieldExpression in a ConciseBody (per http://ecma-international.org/ecma-262/6.0/#sec-arrow-function-definitions
44 // and https://tc39.github.io/ecma262/#prod-ConciseBody)
45 testSyntax(`
46 var value = () => {
47     yield
48 }
49 `);
50
51 testSyntax(`
52 var value = (val = yield) => {
53 }
54 `);
55
56 // Confusingly, FormalParameters[~Yield] does not product a SyntaxError for "yield", even
57 // inside of a generator (https://tc39.github.io/ecma262/#prod-FunctionDeclaration),
58 // but instead resolves "yield" as a BindingIdentifier
59 testSyntax(`
60 function *gen() {
61     function ng(val = yield) {
62     }
63 }
64 `);
65
66 // Arrow formal parameters within Generators are parameterized with [+Yield], but are
67 // still forbidden from including YieldExpressions in ArrowFormalParameters.
68 // (https://tc39.github.io/ecma262/#prod-ArrowFormalParameters)
69 testSyntaxError(`
70 var yield;
71 function *gen() {
72     var ng = (val = yield) => {
73     }
74 }
75 `, `SyntaxError: Unexpected keyword 'yield'. Cannot use yield expression out of generator.`);
76
77 (function testYieldBindingIdentifier() {
78     var yield = "hello!";
79     function* gen() {
80         yield (function(x = yield) { return x; })();
81     }
82     var result = gen().next();
83     if (result.value !== "hello!")
84         throw new Error("Expected BindingIdentifier bound to 'hello!', but found " + JSON.stringify(result));
85 })();
86
87 testSyntax(`
88 function* gen() {
89     var ng = (it = function*() { yield 1; }) => {
90         return it().next();
91     }
92     yield ng();
93 }
94 `);
95
96 testSyntaxError(`
97 function* gen() {
98     var ng = (it = function() { yield 1; }) => {
99         return it().next();
100     }
101     yield ng();
102 }
103 `, `SyntaxError: Unexpected number '1'`);
104
105 testSyntax(`
106 function gen(val = yield) {
107 }
108 `);
109
110 // http://ecma-international.org/ecma-262/6.0/#sec-generator-function-definitions-static-semantics-early-errors
111 testSyntaxError(`
112 function *gen(val = yield) {
113 }
114 `, `SyntaxError: Unexpected keyword 'yield'. Cannot use yield expression within parameters.`);
115
116 testSyntaxError(`
117 function *gen(val = yield 20) {
118 }
119 `, `SyntaxError: Unexpected keyword 'yield'. Cannot use yield expression within parameters.`);
120
121 testSyntaxError(`
122 function *gen(val = yield * g) {
123 }
124 `, `SyntaxError: Unexpected keyword 'yield'. Cannot use yield expression within parameters.`);
125
126
127 testSyntax(`
128 function *gen(g = function *() { yield  }) {
129 }
130 `);
131
132 testSyntaxError(`
133 function* gen(arguments) {
134     "use strict";
135 }
136 `, `SyntaxError: Invalid parameters or function name in strict mode.`);
137
138 testSyntaxError(`
139 function* gen(eval) {
140     "use strict";
141 }
142 `, `SyntaxError: Invalid parameters or function name in strict mode.`);
143
144 testSyntaxError(`
145 function* arguments() {
146     "use strict";
147 }
148 `, `SyntaxError: 'arguments' is not a valid function name in strict mode.`);
149
150 testSyntaxError(`
151 function* eval() {
152     "use strict";
153 }
154 `, `SyntaxError: 'eval' is not a valid function name in strict mode.`);
155
156 testSyntaxError(`
157 function* gen(a) {
158     let a = 1;
159 }
160 `, `SyntaxError: Cannot declare a let variable twice: 'a'.`);
161
162 testSyntaxError(`
163 function* gen(b) {
164     const b = 1;
165 }
166 `, `SyntaxError: Cannot declare a const variable twice: 'b'.`);