Remove ES_NEXT macro (#4915)

- remove all '#JERRY_ESNEXT' macro - remove 5.1 build profile, update test runner accordingly (Note: all builtins are turn on by default) - move tests from tests/jerry/esnext into tests/jerry, concatenate files with same names - add skiplist to some snapshot tests that were supported only in 5.1 - fix doxygen issues that were hidden before (bc. of es.next macro) Co-authored-by: Martin Negyokru negyokru@inf.u-szeged.hu JerryScript-DCO-1.0-Signed-off-by: Adam Szilagyi aszilagy@inf.u-szeged.hu
2022-01-31 16:46:00 +01:00
parent 76403606d0
commit 4924f9fd31
973 changed files with 1902 additions and 8240 deletions
@@ -0,0 +1,345 @@
+/* Copyright JS Foundation and other contributors, http://js.foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function must_throw(str) {
+  try {
+    eval("switch (1) { default: " + str + "}");
+    assert(false);
+  } catch (e) {
+  }
+
+  try {
+    eval(str);
+    assert(false);
+  }
+  catch (e) {
+  }
+
+  must_throw_strict(str);
+}
+
+function must_throw_strict(str) {
+  try {
+    eval ("'use strict'; switch (1) { default: " + str + "}");
+    assert (false);
+  } catch (e) {
+  }
+
+  try {
+    eval("'use strict'; " + str);
+    assert(false);
+  } catch (e) {
+  }
+}
+
+must_throw("class {}");
+must_throw("class class {}");
+must_throw("class A { constructor() {} this.a = 5 }");
+must_throw("class A { constructor() {} constructor() {} }");
+must_throw("class A { static prototype() {} }");
+must_throw("class A { static get prototype() {} }");
+must_throw("class A { static set prototype() {} }");
+must_throw("class A { static prototyp\u{0065}() {} }");
+must_throw("class A { static get prototyp\u{0065}() {} }");
+must_throw("class A { static set prototyp\u{0065}() {} }");
+must_throw("class A { static 'prototype'() {} }");
+must_throw("class A { static get 'prototype'() {} }");
+must_throw("class A { static set 'prototype'() {} }");
+must_throw("class A { static 'prototyp\u{0065}'() {} }");
+must_throw("class A { static get 'prototyp\u{0065}'() {} }");
+must_throw("class A { static set 'prototyp\u{0065}'() {} }");
+must_throw("class A { get constructor() {} }");
+must_throw("class A { set constructor() {} }");
+must_throw("class A {}; A()");
+must_throw("class X {}; var o = {}; Object.defineProperty(o, 'p', { get: X, set: X }); o.p;");
+must_throw("var a = new A; class A {};");
+must_throw("class A { g\\u0065t e() {} }");
+must_throw('class A { "static" e() {} }');
+must_throw('class A { *constructor() {} }');
+
+assert(eval("class A {}") === undefined);
+assert(eval("var a = class A {}") === undefined);
+assert(eval("var a = class {}") === undefined);
+assert(eval("class A { ; ; ; ;;;;;;;;;;;; ; ; ;;;;;;;;;;;;;;;;;;;;;;;;; }") === undefined);
+assert(eval('class A {"constructor"() {} }') === undefined);
+assert(isNaN (eval('switch(1) { default: (class A{} % 1) }')));
+
+class A1 {
+  ["constructor"]() {
+    return 5;
+  }
+}
+
+assert ((new A1).constructor() === 5);
+
+class A2 {
+  *["constructor"]() {
+    yield 5;
+  }
+}
+
+assert ((new A2).constructor().next().value === 5);
+
+class B {
+}
+
+var b = new B;
+assert (typeof B  === "function");
+assert (typeof b === "object");
+assert (b.constructor === B);
+
+class C {
+  c1() {
+    return 5;
+  }
+
+  c2() {
+    return this._c;
+  }
+  3() {
+    return 3;
+  }
+
+  super() {
+    return 42;
+  }
+  return() {
+    return 43;
+  }
+
+  static *constructor() {
+    return 44;
+  }
+}
+
+var c = new C;
+assert (c.c1() === 5);
+assert (c.c2() === undefined);
+assert (c["3"]() === 3);
+assert (c.super() === 42);
+assert (c.return() === 43);
+assert (c.constructor === C);
+assert (C.constructor().next().value === 44);
+
+class D {
+  constructor(d) {
+    this._d = d;
+  }
+
+  d1() {
+    return this._d;
+  }
+}
+var d = new D(5);
+assert (d.d1() === 5);
+assert (d.constructor === D);
+
+class E {
+  constructor(e) {
+    this._e = e;
+  }
+
+  get e() {
+    return this._e;
+  }
+
+  set e(e) {
+    this._e = e;
+  }
+
+  get () {
+    return 11;
+  }
+
+  set () {
+    return 12;
+  }
+}
+var e = new E (5);
+assert (e.e === 5);
+e.e = 10;
+assert (e.e === 10);
+assert (e.get() === 11);
+assert (e.set() === 12);
+assert (e.constructor === E);
+
+var F = class ClassF {
+  constructor(f) {
+    this._f = f;
+  }
+
+  static f1() {
+    return this;
+  }
+
+  static f2() {
+    return this._f;
+  }
+
+  static f3(a, b) {
+    return a + b;
+  }
+
+  static constructor(a) {
+    return a;
+  }
+
+  static static(a) {
+    return a;
+  }
+
+  static 2 (a) {
+    return 2 * a;
+  }
+
+  static function(a) {
+    return 3 * a;
+  }
+}
+
+var f = new F(5);
+
+assert (f.f1 === undefined);
+assert (f.f2 === undefined);
+assert (F.f1() === F);
+assert (F.f2() === undefined);
+assert (F.f3(1, 1) === 2);
+assert (F.constructor(5) === 5);
+assert (F.static(5) === 5);
+assert (F["2"](5) === 10);
+assert (F.function(5) === 15);
+assert (f.constructor === F);
+
+var G = class {
+  static set a(a) {
+    this._a = a;
+  }
+  static get a() {
+    return this._a;
+  }
+  static set 1(a) {
+    this._a = a;
+  }
+  static get 1() {
+    return this._a;
+  }
+
+  static get() {
+    return 11;
+  }
+
+  static set() {
+    return 12;
+  }
+
+  static set constructor(a) {
+    this._a = a;
+  }
+  static get constructor() {
+    return this._a;
+  }
+
+  static g1() {
+    return 5;
+  }
+
+  static g1() {
+    return 10;
+  }
+}
+
+G.a = 10;
+assert (G.a === 10);
+assert (G.g1() === 10);
+G["1"] = 20;
+assert (G["1"] === 20);
+assert (G.get() == 11);
+assert (G.set() == 12);
+G.constructor = 30;
+assert (G.constructor === 30);
+
+class H {
+  method() { assert (typeof H === 'function'); return H; }
+}
+
+let H_original = H;
+var H_method = H.prototype.method;
+C = undefined;
+assert(C === undefined);
+C = H_method();
+assert(C === H_original);
+
+var I = class C {
+  method() { assert(typeof C === 'function'); return C; }
+}
+
+let I_original = I;
+var I_method = I.prototype.method;
+I = undefined;
+assert(I === undefined);
+I = I_method();
+assert(I == I_original);
+
+var J_method;
+class J {
+  static [(J_method = eval('(function() { return J; })'), "X")]() {}
+}
+var J_original = J;
+J = 6;
+assert (J_method() == J_original);
+
+var K_method;
+class K {
+  constructor () {
+    K_method = function() { return K; }
+  }
+}
+var K_original = K;
+new K;
+K = 6;
+assert (K_method() == K_original);
+
+var L_method;
+class L extends (L_method = function() { return L; }) {
+}
+var L_original = L;
+L = 6;
+assert (L_method() == L_original);
+
+/* Test cleanup class environment */
+try {
+  class A {
+    [d]() {}
+  }
+  let d;
+  assert(false);
+} catch (e) {
+  assert(e instanceof ReferenceError);
+}
+
+try {
+  class A extends d {}
+  let d;
+  assert(false);
+} catch (e) {
+  assert(e instanceof ReferenceError);
+}
+try {
+  var a = 1 + 2 * 3 >> class A extends d {};
+  let d;
+  assert(false);
+} catch (e) {
+  assert(e instanceof ReferenceError);
+}