Invalid flags in a RegExp literal should be an early SyntaxError
[WebKit-https.git] / JSTests / stress / async-arrow-functions-lexical-binding-in-class.js
1 function shouldBe(expected, actual, msg) {
2     if (msg === void 0)
3         msg = "";
4     else
5         msg = " for " + msg;
6     if (actual !== expected)
7         throw new Error("bad value" + msg + ": " + actual + ". Expected " + expected);
8 }
9
10 function shouldBeAsync(expected, run) {
11     let actual;
12     var hadError = false;
13     run().then(function(value) { actual = value; },
14                function(error) { hadError = true; actual = error; });
15     drainMicrotasks();
16
17     if (hadError)
18         throw actual;
19
20     shouldBe(expected, actual);
21 }
22
23 class BaseWrongClass {
24     baseClassValue() {
25         return "wrong #1";
26     }
27     get property() {
28         return "wrong #2";
29     }
30 }
31
32 function shouldBeAsyncAndStoreBind(expected, run) {
33     shouldBeAsync(expected, run);
34     shouldBeAsync(expected, run.bind({}));
35     shouldBeAsync(expected, run.bind(1));
36     shouldBeAsync(expected, run.bind(undefined));
37     const obj = { 
38         property : 'wrong value #1', 
39         baseClassValue : () => 'worng value #2'
40     };
41     shouldBeAsync(expected, run.bind(obj));
42     shouldBeAsync(expected, run.bind(new BaseWrongClass()));
43 }
44
45 class BaseClass {
46     baseClassValue() {
47         return "BaseClassValue";
48     }
49     get property() {
50         return "test!";
51     }
52 }
53
54 function runSomething(callback) {
55     callback();
56 }
57
58 class ChildClass extends BaseClass {
59     classValue() {
60         return "classValue";
61     }
62     get classProperty() {
63         return "classProperty";
64     }
65     asyncValueExp() {
66         return async x => 'value';
67     }
68     asyncValueBody() {
69         return async x => { return 'value'; };
70     }
71     asyncThisPropExp() {
72         return async x => this.classProperty;
73     }
74     asyncThisPropBody() {
75         return async x => { return this.classProperty; };
76     }
77     asyncThisPropWithAwaitBody() {
78         return async x => { 
79             var self = this.classProperty; 
80             self = await 'abc';  
81             return this.classProperty; 
82         };
83     }
84     asyncThisPropInEvalExp() {
85         return async x => eval('this.classProperty');
86     }
87     asyncThisPropInEvalBody() {
88         return async x => { return eval('this.classProperty'); };
89     }
90     asyncThisPropInEvalWithAwaitBody() {
91         return async x => { 
92             var self = eval('this.classProperty');
93             await 'abc';
94             return eval('this.classProperty'); 
95         };
96     }
97     asyncThisValueExp() {
98         return async x => this.classValue();
99     }
100     asyncThisValueBody() {
101         return async x => { return this.classValue(); };
102     }
103     asyncThisValueBodyWithAwait() {
104         return async x => { 
105             var self = this.classValue();
106             await 'self'; 
107             return this.classValue(); 
108         };
109     }
110     asyncThisValueInEvalExp() {
111         return async x => eval('this.classValue()');
112     }
113     asyncThisValueInEvalBody() {
114         return async x => { return eval('this.classValue()'); };
115     }
116     asyncThisValueInEvalWithAwaitBody() {
117         return async x => { 
118             var self = eval('this.classValue()');
119             await 'self'; 
120             return eval('this.classValue()'); 
121         };
122     }
123 }
124
125 shouldBeAsyncAndStoreBind("value", new ChildClass().asyncValueExp());
126 shouldBeAsyncAndStoreBind("value", new ChildClass().asyncValueBody());
127
128 shouldBeAsyncAndStoreBind("classProperty", new ChildClass().asyncThisPropExp());
129 shouldBeAsyncAndStoreBind("classProperty", new ChildClass().asyncThisPropBody());
130 shouldBeAsyncAndStoreBind("classProperty", new ChildClass().asyncThisPropWithAwaitBody());
131 shouldBeAsyncAndStoreBind("classProperty", new ChildClass().asyncThisPropWithAwaitBody());
132
133 shouldBeAsyncAndStoreBind("classProperty", new ChildClass().asyncThisPropInEvalExp());
134 shouldBeAsyncAndStoreBind("classProperty", new ChildClass().asyncThisPropInEvalBody());
135 shouldBeAsyncAndStoreBind("classProperty", new ChildClass().asyncThisPropInEvalWithAwaitBody());
136
137 shouldBeAsyncAndStoreBind("classValue", new ChildClass().asyncThisValueExp());
138 shouldBeAsyncAndStoreBind("classValue", new ChildClass().asyncThisValueBody());
139 shouldBeAsyncAndStoreBind("classValue", new ChildClass().asyncThisValueBodyWithAwait());
140
141 shouldBeAsyncAndStoreBind("classValue", new ChildClass().asyncThisValueInEvalExp());
142 shouldBeAsyncAndStoreBind("classValue", new ChildClass().asyncThisValueInEvalBody());
143 shouldBeAsyncAndStoreBind("classValue", new ChildClass().asyncThisValueInEvalWithAwaitBody());
144
145 class ChildClass2 extends BaseClass {
146     constructor() {
147         super();
148         this.value = 'internalValue';
149         return async () => this.classValue() + ' ' + this.classProperty;
150     }
151     classStaticValue() {
152         return "classStaticValue";
153     }
154     classValue() {
155         return this.value;
156     }
157     get classProperty() {
158         return "classProperty";
159     }
160 }
161
162 shouldBeAsyncAndStoreBind("internalValue classProperty", new ChildClass2());
163
164 class ChildClass3 extends BaseClass {
165     constructor() {
166         super();
167         this.internalValue = 'internalValue';
168         return async () => {
169             var self = this.classValue() + ' ' + this.classProperty;
170             await 'self';
171             return this.classValue() + ' ' + this.classProperty;
172         }
173     }
174     classValue() {
175         return "classValue";
176     }
177     get classProperty() {
178         return "classProperty";
179     }
180 }
181
182 shouldBeAsyncAndStoreBind("classValue classProperty", new ChildClass3());
183
184 var promiseHolder = {};
185 var promise = new Promise((resolve, reject) => {
186     promiseHolder.resolve = resolve;
187     promiseHolder.reject = reject;
188 });
189
190 class ChildClass4 extends BaseClass {
191     constructor() {
192         var arr = async () => {
193             var doSomeStaff = () => {};
194             doSomeStaff();
195             await promise;
196             return this.classValue() + ' ' + this.classProperty;
197         };
198         arr();
199         super();
200         this.internalValue = 'internalValue';
201         return async () => {
202             await 'await';
203             promiseHolder.resolve();
204             return this.classValue() + ' ' + this.classProperty;;
205         };
206     }
207     classValue() {
208         return "classValue";
209     }
210     get classProperty() {
211         return "classProperty";
212     }
213 }
214
215 shouldBeAsyncAndStoreBind("classValue classProperty", new ChildClass4());
216
217 class ChildClass5 extends BaseClass {
218     constructor(result) {
219         const arr = async () => this.id;
220         arr().then(()=>{}, e => { result.error = e; });
221     }
222 }
223
224 class ChildClass6 extends BaseClass {
225     constructor(result) {
226         const arr = async () => { 
227             let z = this.id;
228         };
229         arr().then(()=>{}, e => { result.error = e; });
230         super();
231     }
232 }
233
234 class ChildClass7 extends BaseClass {
235     constructor(result) {
236         const arr = async () => this.id;
237         arr().then(()=>{}, e => { result.error = e; });
238         super();
239     }
240 }
241
242 class ChildClass8 extends BaseClass {
243     constructor(result) {
244         const arr = async () => { let i  = this.id; super(); };
245         arr().then(()=>{}, e => { result.error = e; });
246     }
247 }
248
249 function checkTDZDuringCreate(klass) {
250     let asyncError = {};
251     try {
252         var c = new klass(asyncError);
253     } catch(e) {
254         // We do not care about this error
255     }
256     drainMicrotasks();
257     const error = asyncError.error instanceof ReferenceError && asyncError.error.toString() === 'ReferenceError: Cannot access uninitialized variable.';
258     if (!error) throw new Error('TDZ error is expected, but appeared:' + asyncError.error);
259 }
260
261 checkTDZDuringCreate(ChildClass5);
262 checkTDZDuringCreate(ChildClass6);
263 checkTDZDuringCreate(ChildClass7);
264 checkTDZDuringCreate(ChildClass8);