Invalid flags in a RegExp literal should be an early SyntaxError
[WebKit-https.git] / JSTests / stress / arrowfunction-lexical-bind-superproperty.js
1 //@ defaultNoNoLLIntRun if $architecture == "arm"
2
3 var testCase = function (actual, expected, message) {
4     if (actual !== expected) {
5         throw message + ". Expected '" + expected + "', but was '" + actual + "'";
6     }
7 };
8
9 var testValue  = 'test-value';
10
11 var A = class A {
12     constructor() {
13         this.value = testValue;
14     }
15     getConstValue () {
16         return testValue;
17     }
18     getValue () {
19         return this.value;
20     }
21     setValue (value) {
22         this.value = value;
23     }
24 };
25
26 var B = class B extends A {
27     getParentValue() {
28         var arrow  = () => super.getValue();
29         return arrow();
30     }
31 };
32
33 var C = class C {
34     constructor() {
35         this.value = testValue;
36     }
37     static getStaticValue() {
38         return testValue;
39     }
40 };
41
42 var D = class D extends C {
43     static getParentStaticValue() {
44         var arrow  = () => super.getStaticValue();
45         return arrow();
46     }
47 };
48
49 var E = class E extends A {
50      constructor() {
51          super();
52      }
53      get prop() {
54          var arrow = () => super.getConstValue() + '-' + this.value;
55          return arrow();
56      }
57      set prop(value) {
58          var arrow = (newVal) => super.setValue(newVal);
59          arrow(value);
60      }
61      setInitValue() {
62        this.value = testValue;
63      }
64  };
65
66 var b = new B();
67 for (var i = 0; i < 10000; i++) {
68     testCase(b.getParentValue(), testValue, i);
69 }
70
71 for (var i = 0; i < 10000; i++) {
72     testCase(D.getParentStaticValue(), testValue, i);
73 }
74
75 var e = new E();
76 for (var i = 0; i < 10000; i++) {
77      e.setInitValue();
78      testCase(e.prop, testValue+'-'+testValue, i);
79      e.prop = 'new-test-value';
80      testCase(e.prop, testValue+'-new-test-value', i);
81 }
82
83 var F  = class F extends A {
84     newMethod() {
85         var arrow  = () => eval('super.getValue()');
86         var r = arrow();
87         return r;
88     }
89 };
90
91 var f = new F();
92 for (var i=0; i < 10000; i++) {
93     try {
94         var result = f.newMethod();
95         testCase(result, testValue, i);
96      } catch(e) {
97         if (!(e instanceof SyntaxError))
98            throw e;
99      }
100 }
101
102 var G = class G extends A {
103      constructor() {
104          super();
105      }
106      get prop() {
107          var arrow = () => () => super.getConstValue() + '-' + this.value;
108          return arrow()();
109      }
110      set prop(value) {
111          var arrow =  () => (newVal) => this.value = newVal;
112          arrow()(value);
113      }
114      setInitValue() {
115          this.value = testValue;
116      }
117      getValueCB() {
118          var arrow  = () => super.getValue();
119          return arrow;
120      }
121      setValueCB() {
122          var arrow =  (newVal) => this.value = newVal;
123          return arrow;
124      }
125      getParentValue() {
126          return super.getValue();
127      }
128
129      getValueBlockScope() {
130          if (true) {
131              var someValue ='';
132              if (true) {
133                  return () => {
134                     if (true) {
135                         let internalValue = '';
136                         return super.getValue();
137                     }
138                  }
139              }
140          }
141      }
142      *genGetParentValue() {
143          let arr = () => super.getValue();
144          yield arr();
145      }
146      *genGetParentValueDeepArrow() {
147          let arr = () => () => () => super.getValue();
148          yield arr()()();
149      }
150  };
151
152  var g = new G();
153  for (var i = 0; i < 10000; i++) {
154     g.setInitValue();
155     testCase(g.prop, testValue + '-' + testValue, 'Error: Some problem with using arrow and "super" inside of the method');
156     g.prop = 'new-test-value';
157     testCase(g.prop, testValue + '-new-test-value', 'Error: Some problem with using arrow and "super" inside of the getter and setter');
158  }
159
160 var g1 = new G();
161 for (var i = 0; i < 10000; i++) {
162     g1.setInitValue();
163     let getValue = g1.getValueCB();
164     testCase(getValue(), testValue,  'Error: Some problem with using arrow and "super" inside of the method that retun arrow function');
165     let setValue = g1.setValueCB();
166     setValue('new-value');
167     testCase(getValue(), 'new-value', 'Error: Some problem with using arrow and "super" inside of the method that retun arrow function');
168     getValue = g1.getValueBlockScope();
169     testCase(getValue(), 'new-value',  'Error: Some problem with using arrow and "super" with deep nesting inside of the method that retun arrow function');
170     testCase(g1.genGetParentValue().next().value, 'new-value',  'Error: Some problem with using arrow and "super" with deep nesting inside of the generator method that retun arrow function');
171     testCase(g1.genGetParentValueDeepArrow().next().value, 'new-value',  'Error: Some problem with using arrow and "super" with deep nesting inside of the generator method that retun arrow function');
172 }
173
174 var H = class H extends A {
175     constructor() {
176         var arrow = () => () => super.getValue();
177         super();
178         this.newValue  = arrow()();
179     }
180 };
181
182 for (var i = 0; i < 10000; i++) {
183     let h = new H();
184     testCase(h.newValue, testValue, 'Error: Some problem with using "super" inside of the constructor');
185 }
186
187 var I = class I extends A {
188     constructor (beforeSuper) {
189         var arrow = () => super.getValue();
190         if (beforeSuper)  {
191             this._value = arrow();
192             super();
193         } else {
194             super();
195             this._value = arrow();
196         }
197     }
198 }
199
200 var J = class J extends A {
201     constructor (beforeSuper) {
202         var _value;
203         var arrow = () => super.getConstValue();
204         if (beforeSuper)  {
205             _value = arrow();
206             super();
207          } else {
208             super();
209             _value = arrow();
210         }
211         this._value = _value;
212     }
213 }
214
215 for (var i = 0; i < 10000; i++) {
216     let i = new I(false);
217     testCase(i._value, testValue, 'Error: Some problem with using "super" inside of the constructor');
218     let j = new J(false);
219     testCase(j._value, testValue, 'Error: Some problem with using "super" inside of the constructor');
220
221     // FIXME: Problem with access to the super before super() in constructor
222     // https://bugs.webkit.org/show_bug.cgi?id=152108
223     //let j2 = new J(true);
224     //testCase(j2._value, testValue, 'Error: Some problem with using "super" inside of the constructor');
225     error = false;
226     try {
227         new I(true);
228     } catch (e) {
229         error = e instanceof ReferenceError;
230     }
231     testCase(error, true, 'Error: using "super" property before super() should lead to error');
232 }
233
234 class K extends A {
235     newMethodArrowEval() {
236         var arrow = () => eval('super.getValue()');
237         var r = arrow();
238         return r;
239     }
240     newMethodArrowDoubleEval() {
241       var arrow = () => eval("eval('super.getValue()')");
242       var r = arrow();
243       return r;
244     }
245     newMethodArrowEvalEvalArrow() {
246       var arrow = () => eval("eval('(() => super.getValue())()')");
247       var r = arrow();
248       return r;
249     }
250     newMethodArrowEvalEvalArrowEval() {
251       var arrow  = () => eval("eval('(() => eval(\"super.getValue()\"))()')");
252       var r = arrow();
253       return r;
254     }
255     newMethodEval() {
256         var r = eval("super.getValue()");
257         return r;
258     }
259     newMethodEvalEval() {
260         var r = eval("eval('super.getValue()')");
261         return r;
262     }
263     newMethodEvalArrow() {
264         var r = eval("(() => super.getValue())()");
265         return r;
266     }
267     newMethodEvalEvalArrow() {
268         var r = eval("eval('(() => super.getValue())()')");
269         return r;
270     }
271     newMethodEvalEvalArrowEval() {
272         var r = eval("eval('(() => eval(\"(super.getValue())\"))()')");
273         return r;
274     }
275 }
276
277 var k = new K();
278
279 for (var i = 0; i < 1000; i++) {
280     testCase(k.newMethodArrowEval() , testValue, 'Error: Error in lexical bind with eval and arrow function #1');
281     testCase(k.newMethodArrowDoubleEval() , testValue, 'Error: Error in lexical bind with eval and arrow function #2');
282     testCase(k.newMethodArrowEvalEvalArrow() , testValue, 'Error: Error in lexical bind with eval and arrow function #3');
283     testCase(k.newMethodArrowEvalEvalArrowEval() , testValue, 'Error: Error in lexical bind with eval and arrow function #4');
284
285     testCase(k.newMethodEval() , testValue, 'Error: Error in lexical bind with eval and arrow function #5');
286     testCase(k.newMethodEvalEval() , testValue, 'Error: Error in lexical bind with eval and arrow function #6');
287     testCase(k.newMethodEvalArrow() , testValue, 'Error: Error in lexical bind with eval and arrow function #7');
288     testCase(k.newMethodEvalEvalArrow() , testValue, 'Error: Error in lexical bind with eval and arrow function 8');
289     testCase(k.newMethodEvalEvalArrowEval() , testValue, 'Error: Error in lexical bind with eval and arrow function #9');
290 }