chore: add class static block tests

it was copied from test262
refs: tc39/test262@afe217b

tests/fixtures/ecma-version/13/class-static-blocks/expressions-arrow-function-static-init-await-binding.src.js

@@ -0,0 +1,5 @@
+class C {
+  static {
+    (await => 0);
+  }
+}

tests/fixtures/ecma-version/13/class-static-blocks/expressions-arrow-function-static-init-await-reference.src.js

@@ -0,0 +1,5 @@
+class C {
+  static {
+    ((x = await) => 0);
+  }
+}

tests/fixtures/ecma-version/13/class-static-blocks/expressions-class-static-init-await-binding.src.js

@@ -0,0 +1,5 @@
+class C {
+  static {
+    (class await {});
+  }
+}

tests/fixtures/ecma-version/13/class-static-blocks/expressions-class-static-init-await-reference.src.js

@@ -0,0 +1,17 @@
+
+
+var await = 0;
+var fromParam, fromBody;
+
+class C {
+  static {
+    new (class {
+      constructor(x = fromParam = await) {
+        fromBody = await;
+      }
+    });
+  }
+}
+
+assert.sameValue(fromParam, 0, 'from parameter');
+assert.sameValue(fromBody, 0, 'from body');

tests/fixtures/ecma-version/13/class-static-blocks/expressions-function-static-init-await-binding.src.js

@@ -0,0 +1,7 @@
+
+
+class C {
+  static {
+    (function await(await) {});
+  }
+}

tests/fixtures/ecma-version/13/class-static-blocks/expressions-function-static-init-await-reference.src.js

@@ -0,0 +1,15 @@
+
+
+var await = 0;
+var fromParam, fromBody;
+
+class C {
+  static {
+    (function (x = fromParam = await) {
+      fromBody = await;
+    })();
+  }
+}
+
+assert.sameValue(fromParam, 0, 'from parameter');
+assert.sameValue(fromBody, 0, 'from body');

tests/fixtures/ecma-version/13/class-static-blocks/expressions-generators-static-init-await-binding.src.js

@@ -0,0 +1,7 @@
+
+
+class C {
+  static {
+    (function * await (await) {});
+  }
+}

tests/fixtures/ecma-version/13/class-static-blocks/expressions-generators-static-init-await-reference.src.js

@@ -0,0 +1,15 @@
+
+
+var await = 0;
+var fromParam, fromBody;
+
+class C {
+  static {
+    (function * (x = fromParam = await) {
+      fromBody = await;
+    })().next();
+  }
+}
+
+assert.sameValue(fromParam, 0, 'from parameter');
+assert.sameValue(fromBody, 0, 'from body');

tests/fixtures/ecma-version/13/class-static-blocks/expressions-object-ident-name-prop-name-literal-await-static-init.src.js

@@ -0,0 +1,8 @@
+
+
+class C {
+  static {
+    ({ await: 0 });
+  }
+}
+

tests/fixtures/ecma-version/13/class-static-blocks/expressions-object-identifier-shorthand-static-init-await-invalid.src.js

@@ -0,0 +1,6 @@
+class C {
+  static {
+    ({ await });
+  }
+}
+

tests/fixtures/ecma-version/13/class-static-blocks/expressions-object-identifier-shorthand-static-init-await-valid.src.js

@@ -0,0 +1,7 @@
+
+
+class C {
+  static {
+    (() => ({ await }));
+  }
+}

tests/fixtures/ecma-version/13/class-static-blocks/expressions-object-method-definition-static-init-await-binding-accessor.src.js

@@ -0,0 +1,7 @@
+
+
+class C {
+  static {
+    ({set accessor(await) {}});
+  }
+}

tests/fixtures/ecma-version/13/class-static-blocks/expressions-object-method-definition-static-init-await-binding-generator.src.js

@@ -0,0 +1,7 @@
+
+
+class C {
+  static {
+    ({*method(await) {}});
+  }
+}

tests/fixtures/ecma-version/13/class-static-blocks/expressions-object-method-definition-static-init-await-binding-normal.src.js

@@ -0,0 +1,7 @@
+
+
+class C {
+  static {
+    ({method(await) {}});
+  }
+}

tests/fixtures/ecma-version/13/class-static-blocks/expressions-object-method-definition-static-init-await-reference-accessor.src.js

@@ -0,0 +1,17 @@
+
+
+var await = 0;
+var fromParam, fromBody;
+
+class C {
+  static {
+    ({
+      set accessor(x = fromParam = await) {
+        fromBody = await;
+      }
+    }).accessor = undefined;
+  }
+}
+
+assert.sameValue(fromParam, 0, 'from parameter');
+assert.sameValue(fromBody, 0, 'from body');

tests/fixtures/ecma-version/13/class-static-blocks/expressions-object-method-definition-static-init-await-reference-generator.src.js

@@ -0,0 +1,17 @@
+
+
+var await = 0;
+var fromParam, fromBody;
+
+class C {
+  static {
+    ({
+      *method(x = fromParam = await) {
+        fromBody = await;
+      }
+    }).method().next();
+  }
+}
+
+assert.sameValue(fromParam, 0, 'from parameter');
+assert.sameValue(fromBody, 0, 'from body');

tests/fixtures/ecma-version/13/class-static-blocks/expressions-object-method-definition-static-init-await-reference-normal.src.js

@@ -0,0 +1,17 @@
+
+
+var await = 0;
+var fromParam, fromBody;
+
+class C {
+  static {
+    ({
+      method(x = fromParam = await) {
+        fromBody = await;
+      }
+    }).method();
+  }
+}
+
+assert.sameValue(fromParam, 0, 'from parameter');
+assert.sameValue(fromBody, 0, 'from body');

tests/fixtures/ecma-version/13/class-static-blocks/identifier-resolution-static-init-invalid-await.src.js

@@ -0,0 +1,5 @@
+class C {
+  static {
+    await;
+  }
+}

tests/fixtures/ecma-version/13/class-static-blocks/statements-break-static-init-without-label.src.js

@@ -0,0 +1,7 @@
+label: while(false) {
+  class C {
+    static {
+      break;
+    }
+  }
+}

tests/fixtures/ecma-version/13/class-static-blocks/statements-class-static-init-abrupt.src.js

@@ -0,0 +1,27 @@
+
+
+var thrown = new Test262Error();
+var caught;
+var sameBlock = false;
+var subsequentField = false;
+var subsequentBlock = false;
+
+try {
+  class C {
+    static {
+      throw thrown;
+      sameBlock = true;
+    }
+    static x = subsequentField = true;
+    static {
+      subsequentBlock = true;
+    }
+  }
+} catch (error) {
+  caught = error;
+}
+
+assert.sameValue(caught, thrown);
+assert.sameValue(sameBlock, false, 'same block');
+assert.sameValue(subsequentField, false, 'subsequent field');
+assert.sameValue(subsequentBlock, false, 'subsequent block');

tests/fixtures/ecma-version/13/class-static-blocks/statements-class-static-init-arguments-functions.src.js

@@ -0,0 +1,28 @@
+
+
+var fn, fnParam;
+var gen, genParam;
+var asyncFn, asyncFnParam;
+
+class C {
+  static {
+    (function({test262 = fnParam = arguments}) {
+      fn = arguments;
+    })('function');
+
+    (function * ({test262 = genParam = arguments}) {
+      gen = arguments;
+    })('generator function').next();
+
+    (async function ({test262 = asyncFnParam = arguments}) {
+      asyncFn = arguments;
+    })('async function');
+  }
+}
+
+assert(compareArray(['function'], fn), 'body');
+assert(compareArray(['function'], fnParam), 'parameter');
+assert(compareArray(['generator function'], gen), 'body');
+assert(compareArray(['generator function'], genParam), 'parameter');
+assert(compareArray(['async function'], asyncFn), 'body');
+assert(compareArray(['async function'], asyncFnParam), 'parameter');

tests/fixtures/ecma-version/13/class-static-blocks/statements-class-static-init-arguments-methods.src.js

@@ -0,0 +1,46 @@
+
+
+var instance;
+var method, methodParam;
+var getter;
+var setter, setterParam;
+var genMethod, genMethodParam;
+var asyncMethod, asyncMethodParam;
+
+class C {
+  static {
+    instance = new class {
+      method({test262 = methodParam = arguments}) {
+        method = arguments;
+      }
+      get accessor() {
+        getter = arguments;
+      }
+      set accessor({test262 = setterParam = arguments}) {
+        setter = arguments;
+      }
+      *gen({test262 = genMethodParam = arguments}) {
+        genMethod = arguments;
+      }
+      async async({test262 = asyncMethodParam = arguments}) {
+        asyncMethod = arguments;
+      }
+    }();
+  }
+}
+
+instance.method('method');
+instance.accessor;
+instance.accessor = 'setter';
+instance.gen('generator method').next();
+instance.async('async method');
+
+assert(compareArray(['method'], method), 'body');
+assert(compareArray(['method'], methodParam), 'parameter');
+assert(compareArray([], getter), 'body');
+assert(compareArray(['setter'], setter), 'body');
+assert(compareArray(['setter'], setterParam), 'parameter');
+assert(compareArray(['generator method'], genMethod), 'body');
+assert(compareArray(['generator method'], genMethodParam), 'parameter');
+assert(compareArray(['async method'], asyncMethod), 'body');
+assert(compareArray(['async method'], asyncMethodParam), 'parameter');

tests/fixtures/ecma-version/13/class-static-blocks/statements-class-static-init-await-binding-invalid.src.js

@@ -0,0 +1,5 @@
+class C {
+  static {
+    class await {}
+  }
+}

tests/fixtures/ecma-version/13/class-static-blocks/statements-class-static-init-await-binding-valid.src.js

@@ -0,0 +1,7 @@
+
+
+class C {
+  static {
+    (() => { class await {} });
+  }
+}

tests/fixtures/ecma-version/13/class-static-blocks/statements-class-static-init-expr-new-target.src.js

@@ -0,0 +1,11 @@
+
+
+var value = null;
+
+class C {
+  static {
+    value = new.target;
+  }
+}
+
+assert.sameValue(value, undefined);

tests/fixtures/ecma-version/13/class-static-blocks/statements-class-static-init-expr-this.src.js

@@ -0,0 +1,11 @@
+
+
+var value;
+
+class C {
+  static {
+    value = this;
+  }
+}
+
+assert.sameValue(value, C);

tests/fixtures/ecma-version/13/class-static-blocks/statements-class-static-init-invalid-arguments.src.js

@@ -0,0 +1,5 @@
+class C {
+  static {
+    (class { [argument\u0073]() {} });
+  }
+}

tests/fixtures/ecma-version/13/class-static-blocks/statements-class-static-init-invalid-await.src.js

@@ -0,0 +1,7 @@
+async function f() {
+  class C {
+    static {
+      await 0;
+    }
+  }
+}

tests/fixtures/ecma-version/13/class-static-blocks/statements-class-static-init-invalid-label-dup.src.js

@@ -0,0 +1,6 @@
+class C {
+  static {
+    x: x: 0;
+  }
+}
+

tests/fixtures/ecma-version/13/class-static-blocks/statements-class-static-init-invalid-lex-dup.src.js

@@ -0,0 +1,6 @@
+class C {
+  static {
+    let x;
+    let x;
+  }
+}

tests/fixtures/ecma-version/13/class-static-blocks/statements-class-static-init-invalid-lex-var.src.js

@@ -0,0 +1,6 @@
+class C {
+  static {
+    let x;
+    var x;
+  }
+}

tests/fixtures/ecma-version/13/class-static-blocks/statements-class-static-init-invalid-return.src.js

@@ -0,0 +1,7 @@
+function f() {
+  class C {
+    static {
+      return;
+    }
+  }
+}

tests/fixtures/ecma-version/13/class-static-blocks/statements-class-static-init-invalid-super-call.src.js

@@ -0,0 +1,5 @@
+class C {
+  static {
+    super();
+  }
+}

tests/fixtures/ecma-version/13/class-static-blocks/statements-class-static-init-invalid-undefined-break-target.src.js

@@ -0,0 +1,7 @@
+class C {
+  static {
+    x: while (false) {
+      break y;
+    }
+  }
+}