From d3c7e1a13a82f6808cb65edf5099e75409fe0f03 Mon Sep 17 00:00:00 2001 From: Valerie R Young Date: Tue, 17 Oct 2017 17:51:13 -0400 Subject: [PATCH] generate files --- ...lds-arrow-fnc-init-err-contains-boolean.js | 34 ++++++++++++++++++ ...ields-arrow-fnc-init-err-contains-super.js | 27 ++++++++++++++ ...lds-comp-name-init-err-contains-boolean.js | 35 +++++++++++++++++++ ...ields-comp-name-init-err-contains-super.js | 28 +++++++++++++++ ...elds-equality-init-err-contains-boolean.js | 34 ++++++++++++++++++ ...fields-equality-init-err-contains-super.js | 27 ++++++++++++++ ...-literal-name-init-err-contains-boolean.js | 34 ++++++++++++++++++ ...ds-literal-name-init-err-contains-super.js | 27 ++++++++++++++ ...tic-comp-name-init-err-contains-boolean.js | 35 +++++++++++++++++++ ...tatic-comp-name-init-err-contains-super.js | 28 +++++++++++++++ ...tatic-literal-init-err-contains-boolean.js | 34 ++++++++++++++++++ ...-static-literal-init-err-contains-super.js | 27 ++++++++++++++ ...-literal-name-init-err-contains-boolean.js | 34 ++++++++++++++++++ ...ng-literal-name-init-err-contains-super.js | 27 ++++++++++++++ ...-literal-name-init-err-contains-boolean.js | 34 ++++++++++++++++++ ...ng-literal-name-init-err-contains-super.js | 27 ++++++++++++++ ...ields-ternary-init-err-contains-boolean.js | 34 ++++++++++++++++++ .../fields-ternary-init-err-contains-super.js | 27 ++++++++++++++ ...fields-typeof-init-err-contains-boolean.js | 34 ++++++++++++++++++ .../fields-typeof-init-err-contains-super.js | 27 ++++++++++++++ ...lds-arrow-fnc-init-err-contains-boolean.js | 34 ++++++++++++++++++ ...ields-arrow-fnc-init-err-contains-super.js | 27 ++++++++++++++ ...lds-comp-name-init-err-contains-boolean.js | 35 +++++++++++++++++++ ...ields-comp-name-init-err-contains-super.js | 28 +++++++++++++++ ...elds-equality-init-err-contains-boolean.js | 34 ++++++++++++++++++ ...fields-equality-init-err-contains-super.js | 27 ++++++++++++++ ...-literal-name-init-err-contains-boolean.js | 34 ++++++++++++++++++ ...ds-literal-name-init-err-contains-super.js | 27 ++++++++++++++ ...tic-comp-name-init-err-contains-boolean.js | 35 +++++++++++++++++++ ...tatic-comp-name-init-err-contains-super.js | 28 +++++++++++++++ ...tatic-literal-init-err-contains-boolean.js | 34 ++++++++++++++++++ ...-static-literal-init-err-contains-super.js | 27 ++++++++++++++ ...-literal-name-init-err-contains-boolean.js | 34 ++++++++++++++++++ ...ng-literal-name-init-err-contains-super.js | 27 ++++++++++++++ ...-literal-name-init-err-contains-boolean.js | 34 ++++++++++++++++++ ...ng-literal-name-init-err-contains-super.js | 27 ++++++++++++++ ...ields-ternary-init-err-contains-boolean.js | 34 ++++++++++++++++++ .../fields-ternary-init-err-contains-super.js | 27 ++++++++++++++ ...fields-typeof-init-err-contains-boolean.js | 34 ++++++++++++++++++ .../fields-typeof-init-err-contains-super.js | 27 ++++++++++++++ 40 files changed, 1228 insertions(+) create mode 100644 test/language/expressions/class/fields-arrow-fnc-init-err-contains-boolean.js create mode 100644 test/language/expressions/class/fields-arrow-fnc-init-err-contains-super.js create mode 100644 test/language/expressions/class/fields-comp-name-init-err-contains-boolean.js create mode 100644 test/language/expressions/class/fields-comp-name-init-err-contains-super.js create mode 100644 test/language/expressions/class/fields-equality-init-err-contains-boolean.js create mode 100644 test/language/expressions/class/fields-equality-init-err-contains-super.js create mode 100644 test/language/expressions/class/fields-literal-name-init-err-contains-boolean.js create mode 100644 test/language/expressions/class/fields-literal-name-init-err-contains-super.js create mode 100644 test/language/expressions/class/fields-static-comp-name-init-err-contains-boolean.js create mode 100644 test/language/expressions/class/fields-static-comp-name-init-err-contains-super.js create mode 100644 test/language/expressions/class/fields-static-literal-init-err-contains-boolean.js create mode 100644 test/language/expressions/class/fields-static-literal-init-err-contains-super.js create mode 100644 test/language/expressions/class/fields-static-string-literal-name-init-err-contains-boolean.js create mode 100644 test/language/expressions/class/fields-static-string-literal-name-init-err-contains-super.js create mode 100644 test/language/expressions/class/fields-string-literal-name-init-err-contains-boolean.js create mode 100644 test/language/expressions/class/fields-string-literal-name-init-err-contains-super.js create mode 100644 test/language/expressions/class/fields-ternary-init-err-contains-boolean.js create mode 100644 test/language/expressions/class/fields-ternary-init-err-contains-super.js create mode 100644 test/language/expressions/class/fields-typeof-init-err-contains-boolean.js create mode 100644 test/language/expressions/class/fields-typeof-init-err-contains-super.js create mode 100644 test/language/statements/class/fields-arrow-fnc-init-err-contains-boolean.js create mode 100644 test/language/statements/class/fields-arrow-fnc-init-err-contains-super.js create mode 100644 test/language/statements/class/fields-comp-name-init-err-contains-boolean.js create mode 100644 test/language/statements/class/fields-comp-name-init-err-contains-super.js create mode 100644 test/language/statements/class/fields-equality-init-err-contains-boolean.js create mode 100644 test/language/statements/class/fields-equality-init-err-contains-super.js create mode 100644 test/language/statements/class/fields-literal-name-init-err-contains-boolean.js create mode 100644 test/language/statements/class/fields-literal-name-init-err-contains-super.js create mode 100644 test/language/statements/class/fields-static-comp-name-init-err-contains-boolean.js create mode 100644 test/language/statements/class/fields-static-comp-name-init-err-contains-super.js create mode 100644 test/language/statements/class/fields-static-literal-init-err-contains-boolean.js create mode 100644 test/language/statements/class/fields-static-literal-init-err-contains-super.js create mode 100644 test/language/statements/class/fields-static-string-literal-name-init-err-contains-boolean.js create mode 100644 test/language/statements/class/fields-static-string-literal-name-init-err-contains-super.js create mode 100644 test/language/statements/class/fields-string-literal-name-init-err-contains-boolean.js create mode 100644 test/language/statements/class/fields-string-literal-name-init-err-contains-super.js create mode 100644 test/language/statements/class/fields-ternary-init-err-contains-boolean.js create mode 100644 test/language/statements/class/fields-ternary-init-err-contains-super.js create mode 100644 test/language/statements/class/fields-typeof-init-err-contains-boolean.js create mode 100644 test/language/statements/class/fields-typeof-init-err-contains-super.js diff --git a/test/language/expressions/class/fields-arrow-fnc-init-err-contains-boolean.js b/test/language/expressions/class/fields-arrow-fnc-init-err-contains-boolean.js new file mode 100644 index 0000000000..9fc6f0ff5e --- /dev/null +++ b/test/language/expressions/class/fields-arrow-fnc-init-err-contains-boolean.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-boolean.case +// - src/class-fields/initializer-error/cls-expr-fields-arrow-fnc.template +/*--- +description: Syntax error if `arguments` used in class field (arrow function expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields, arrow-function] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + x = () => arguments; +} diff --git a/test/language/expressions/class/fields-arrow-fnc-init-err-contains-super.js b/test/language/expressions/class/fields-arrow-fnc-init-err-contains-super.js new file mode 100644 index 0000000000..b746929920 --- /dev/null +++ b/test/language/expressions/class/fields-arrow-fnc-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-super.case +// - src/class-fields/initializer-error/cls-expr-fields-arrow-fnc.template +/*--- +description: Syntax error if `super()` used in class field (arrow function expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields, arrow-function] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + x = () => super(); +} diff --git a/test/language/expressions/class/fields-comp-name-init-err-contains-boolean.js b/test/language/expressions/class/fields-comp-name-init-err-contains-boolean.js new file mode 100644 index 0000000000..0feb910d79 --- /dev/null +++ b/test/language/expressions/class/fields-comp-name-init-err-contains-boolean.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-boolean.case +// - src/class-fields/initializer-error/cls-expr-fields-comp-name.template +/*--- +description: Syntax error if `arguments` used in class field (computed ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var x = "string"; +var C = class { + [x] = arguments; +} diff --git a/test/language/expressions/class/fields-comp-name-init-err-contains-super.js b/test/language/expressions/class/fields-comp-name-init-err-contains-super.js new file mode 100644 index 0000000000..b3716d81f6 --- /dev/null +++ b/test/language/expressions/class/fields-comp-name-init-err-contains-super.js @@ -0,0 +1,28 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-super.case +// - src/class-fields/initializer-error/cls-expr-fields-comp-name.template +/*--- +description: Syntax error if `super()` used in class field (computed ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var x = "string"; +var C = class { + [x] = super(); +} diff --git a/test/language/expressions/class/fields-equality-init-err-contains-boolean.js b/test/language/expressions/class/fields-equality-init-err-contains-boolean.js new file mode 100644 index 0000000000..16f6f86668 --- /dev/null +++ b/test/language/expressions/class/fields-equality-init-err-contains-boolean.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-boolean.case +// - src/class-fields/initializer-error/cls-expr-fields-equality.template +/*--- +description: Syntax error if `arguments` used in class field (equality expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + x = {} == arguments; +} diff --git a/test/language/expressions/class/fields-equality-init-err-contains-super.js b/test/language/expressions/class/fields-equality-init-err-contains-super.js new file mode 100644 index 0000000000..356043abff --- /dev/null +++ b/test/language/expressions/class/fields-equality-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-super.case +// - src/class-fields/initializer-error/cls-expr-fields-equality.template +/*--- +description: Syntax error if `super()` used in class field (equality expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + x = {} == super(); +} diff --git a/test/language/expressions/class/fields-literal-name-init-err-contains-boolean.js b/test/language/expressions/class/fields-literal-name-init-err-contains-boolean.js new file mode 100644 index 0000000000..f876b3f123 --- /dev/null +++ b/test/language/expressions/class/fields-literal-name-init-err-contains-boolean.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-boolean.case +// - src/class-fields/initializer-error/cls-expr-fields-literal-name.template +/*--- +description: Syntax error if `arguments` used in class field (literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + x = arguments; +} diff --git a/test/language/expressions/class/fields-literal-name-init-err-contains-super.js b/test/language/expressions/class/fields-literal-name-init-err-contains-super.js new file mode 100644 index 0000000000..ea7f5af0ae --- /dev/null +++ b/test/language/expressions/class/fields-literal-name-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-super.case +// - src/class-fields/initializer-error/cls-expr-fields-literal-name.template +/*--- +description: Syntax error if `super()` used in class field (literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + x = super(); +} diff --git a/test/language/expressions/class/fields-static-comp-name-init-err-contains-boolean.js b/test/language/expressions/class/fields-static-comp-name-init-err-contains-boolean.js new file mode 100644 index 0000000000..067fd7e556 --- /dev/null +++ b/test/language/expressions/class/fields-static-comp-name-init-err-contains-boolean.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-boolean.case +// - src/class-fields/initializer-error/cls-expr-fields-static-comp-name.template +/*--- +description: Syntax error if `arguments` used in class field (static computed ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var x = "string"; +var C = class { + static [x] = arguments; +} diff --git a/test/language/expressions/class/fields-static-comp-name-init-err-contains-super.js b/test/language/expressions/class/fields-static-comp-name-init-err-contains-super.js new file mode 100644 index 0000000000..8869bc253c --- /dev/null +++ b/test/language/expressions/class/fields-static-comp-name-init-err-contains-super.js @@ -0,0 +1,28 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-super.case +// - src/class-fields/initializer-error/cls-expr-fields-static-comp-name.template +/*--- +description: Syntax error if `super()` used in class field (static computed ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var x = "string"; +var C = class { + static [x] = super(); +} diff --git a/test/language/expressions/class/fields-static-literal-init-err-contains-boolean.js b/test/language/expressions/class/fields-static-literal-init-err-contains-boolean.js new file mode 100644 index 0000000000..a7a0b9b030 --- /dev/null +++ b/test/language/expressions/class/fields-static-literal-init-err-contains-boolean.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-boolean.case +// - src/class-fields/initializer-error/cls-expr-fields-static-literal-name.template +/*--- +description: Syntax error if `arguments` used in class field (static literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + static x = arguments; +} diff --git a/test/language/expressions/class/fields-static-literal-init-err-contains-super.js b/test/language/expressions/class/fields-static-literal-init-err-contains-super.js new file mode 100644 index 0000000000..3d2bcd3985 --- /dev/null +++ b/test/language/expressions/class/fields-static-literal-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-super.case +// - src/class-fields/initializer-error/cls-expr-fields-static-literal-name.template +/*--- +description: Syntax error if `super()` used in class field (static literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + static x = super(); +} diff --git a/test/language/expressions/class/fields-static-string-literal-name-init-err-contains-boolean.js b/test/language/expressions/class/fields-static-string-literal-name-init-err-contains-boolean.js new file mode 100644 index 0000000000..e3027d802d --- /dev/null +++ b/test/language/expressions/class/fields-static-string-literal-name-init-err-contains-boolean.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-boolean.case +// - src/class-fields/initializer-error/cls-expr-fields-static-string-literal-name.template +/*--- +description: Syntax error if `arguments` used in class field (static string literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + static 'x' = arguments; +} diff --git a/test/language/expressions/class/fields-static-string-literal-name-init-err-contains-super.js b/test/language/expressions/class/fields-static-string-literal-name-init-err-contains-super.js new file mode 100644 index 0000000000..5ec19a80c6 --- /dev/null +++ b/test/language/expressions/class/fields-static-string-literal-name-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-super.case +// - src/class-fields/initializer-error/cls-expr-fields-static-string-literal-name.template +/*--- +description: Syntax error if `super()` used in class field (static string literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + static 'x' = super(); +} diff --git a/test/language/expressions/class/fields-string-literal-name-init-err-contains-boolean.js b/test/language/expressions/class/fields-string-literal-name-init-err-contains-boolean.js new file mode 100644 index 0000000000..1fd354365a --- /dev/null +++ b/test/language/expressions/class/fields-string-literal-name-init-err-contains-boolean.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-boolean.case +// - src/class-fields/initializer-error/cls-expr-fields-string-literal-name.template +/*--- +description: Syntax error if `arguments` used in class field (string literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + 'x' = arguments; +} diff --git a/test/language/expressions/class/fields-string-literal-name-init-err-contains-super.js b/test/language/expressions/class/fields-string-literal-name-init-err-contains-super.js new file mode 100644 index 0000000000..90dbfc87e9 --- /dev/null +++ b/test/language/expressions/class/fields-string-literal-name-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-super.case +// - src/class-fields/initializer-error/cls-expr-fields-string-literal-name.template +/*--- +description: Syntax error if `super()` used in class field (string literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + 'x' = super(); +} diff --git a/test/language/expressions/class/fields-ternary-init-err-contains-boolean.js b/test/language/expressions/class/fields-ternary-init-err-contains-boolean.js new file mode 100644 index 0000000000..b6bea67105 --- /dev/null +++ b/test/language/expressions/class/fields-ternary-init-err-contains-boolean.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-boolean.case +// - src/class-fields/initializer-error/cls-expr-fields-ternary.template +/*--- +description: Syntax error if `arguments` used in class field (ternary expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + x = true ? {} : arguments; +} diff --git a/test/language/expressions/class/fields-ternary-init-err-contains-super.js b/test/language/expressions/class/fields-ternary-init-err-contains-super.js new file mode 100644 index 0000000000..7ecd82fe25 --- /dev/null +++ b/test/language/expressions/class/fields-ternary-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-super.case +// - src/class-fields/initializer-error/cls-expr-fields-ternary.template +/*--- +description: Syntax error if `super()` used in class field (ternary expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + x = true ? {} : super(); +} diff --git a/test/language/expressions/class/fields-typeof-init-err-contains-boolean.js b/test/language/expressions/class/fields-typeof-init-err-contains-boolean.js new file mode 100644 index 0000000000..7e40384075 --- /dev/null +++ b/test/language/expressions/class/fields-typeof-init-err-contains-boolean.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-boolean.case +// - src/class-fields/initializer-error/cls-expr-fields-typeof.template +/*--- +description: Syntax error if `arguments` used in class field (typeof expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + x = typeof arguments; +} diff --git a/test/language/expressions/class/fields-typeof-init-err-contains-super.js b/test/language/expressions/class/fields-typeof-init-err-contains-super.js new file mode 100644 index 0000000000..0ad4a74ebb --- /dev/null +++ b/test/language/expressions/class/fields-typeof-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-super.case +// - src/class-fields/initializer-error/cls-expr-fields-typeof.template +/*--- +description: Syntax error if `super()` used in class field (typeof expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + x = typeof super(); +} diff --git a/test/language/statements/class/fields-arrow-fnc-init-err-contains-boolean.js b/test/language/statements/class/fields-arrow-fnc-init-err-contains-boolean.js new file mode 100644 index 0000000000..a234a89f58 --- /dev/null +++ b/test/language/statements/class/fields-arrow-fnc-init-err-contains-boolean.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-boolean.case +// - src/class-fields/initializer-error/cls-decl-fields-arrow-fnc.template +/*--- +description: Syntax error if `arguments` used in class field (arrow function expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields, arrow-function] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + x = () => arguments; +} diff --git a/test/language/statements/class/fields-arrow-fnc-init-err-contains-super.js b/test/language/statements/class/fields-arrow-fnc-init-err-contains-super.js new file mode 100644 index 0000000000..e1f0941e03 --- /dev/null +++ b/test/language/statements/class/fields-arrow-fnc-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-super.case +// - src/class-fields/initializer-error/cls-decl-fields-arrow-fnc.template +/*--- +description: Syntax error if `super()` used in class field (arrow function expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields, arrow-function] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + x = () => super(); +} diff --git a/test/language/statements/class/fields-comp-name-init-err-contains-boolean.js b/test/language/statements/class/fields-comp-name-init-err-contains-boolean.js new file mode 100644 index 0000000000..ce800b3ba6 --- /dev/null +++ b/test/language/statements/class/fields-comp-name-init-err-contains-boolean.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-boolean.case +// - src/class-fields/initializer-error/cls-decl-fields-comp-name.template +/*--- +description: Syntax error if `arguments` used in class field (computed ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var x = "string"; +class C { + static [x] = arguments; +} diff --git a/test/language/statements/class/fields-comp-name-init-err-contains-super.js b/test/language/statements/class/fields-comp-name-init-err-contains-super.js new file mode 100644 index 0000000000..7622021508 --- /dev/null +++ b/test/language/statements/class/fields-comp-name-init-err-contains-super.js @@ -0,0 +1,28 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-super.case +// - src/class-fields/initializer-error/cls-decl-fields-comp-name.template +/*--- +description: Syntax error if `super()` used in class field (computed ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var x = "string"; +class C { + static [x] = super(); +} diff --git a/test/language/statements/class/fields-equality-init-err-contains-boolean.js b/test/language/statements/class/fields-equality-init-err-contains-boolean.js new file mode 100644 index 0000000000..2d8f85536c --- /dev/null +++ b/test/language/statements/class/fields-equality-init-err-contains-boolean.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-boolean.case +// - src/class-fields/initializer-error/cls-decl-fields-equality.template +/*--- +description: Syntax error if `arguments` used in class field (equality expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + x = {} == arguments; +} diff --git a/test/language/statements/class/fields-equality-init-err-contains-super.js b/test/language/statements/class/fields-equality-init-err-contains-super.js new file mode 100644 index 0000000000..32a55253c3 --- /dev/null +++ b/test/language/statements/class/fields-equality-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-super.case +// - src/class-fields/initializer-error/cls-decl-fields-equality.template +/*--- +description: Syntax error if `super()` used in class field (equality expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + x = {} == super(); +} diff --git a/test/language/statements/class/fields-literal-name-init-err-contains-boolean.js b/test/language/statements/class/fields-literal-name-init-err-contains-boolean.js new file mode 100644 index 0000000000..f40f586dab --- /dev/null +++ b/test/language/statements/class/fields-literal-name-init-err-contains-boolean.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-boolean.case +// - src/class-fields/initializer-error/cls-decl-fields-literal-name.template +/*--- +description: Syntax error if `arguments` used in class field (literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + x = arguments; +} diff --git a/test/language/statements/class/fields-literal-name-init-err-contains-super.js b/test/language/statements/class/fields-literal-name-init-err-contains-super.js new file mode 100644 index 0000000000..e1da665e4f --- /dev/null +++ b/test/language/statements/class/fields-literal-name-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-super.case +// - src/class-fields/initializer-error/cls-decl-fields-literal-name.template +/*--- +description: Syntax error if `super()` used in class field (literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + x = super(); +} diff --git a/test/language/statements/class/fields-static-comp-name-init-err-contains-boolean.js b/test/language/statements/class/fields-static-comp-name-init-err-contains-boolean.js new file mode 100644 index 0000000000..fcc3d58c65 --- /dev/null +++ b/test/language/statements/class/fields-static-comp-name-init-err-contains-boolean.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-boolean.case +// - src/class-fields/initializer-error/cls-decl-fields-static-comp-name.template +/*--- +description: Syntax error if `arguments` used in class field (static computed ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var x = "string"; +class C { + static [x] = arguments; +} diff --git a/test/language/statements/class/fields-static-comp-name-init-err-contains-super.js b/test/language/statements/class/fields-static-comp-name-init-err-contains-super.js new file mode 100644 index 0000000000..99b7820ddf --- /dev/null +++ b/test/language/statements/class/fields-static-comp-name-init-err-contains-super.js @@ -0,0 +1,28 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-super.case +// - src/class-fields/initializer-error/cls-decl-fields-static-comp-name.template +/*--- +description: Syntax error if `super()` used in class field (static computed ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var x = "string"; +class C { + static [x] = super(); +} diff --git a/test/language/statements/class/fields-static-literal-init-err-contains-boolean.js b/test/language/statements/class/fields-static-literal-init-err-contains-boolean.js new file mode 100644 index 0000000000..867daaeb6c --- /dev/null +++ b/test/language/statements/class/fields-static-literal-init-err-contains-boolean.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-boolean.case +// - src/class-fields/initializer-error/cls-decl-fields-static-literal-name.template +/*--- +description: Syntax error if `arguments` used in class field (static literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + static x = arguments; +} diff --git a/test/language/statements/class/fields-static-literal-init-err-contains-super.js b/test/language/statements/class/fields-static-literal-init-err-contains-super.js new file mode 100644 index 0000000000..daf539141e --- /dev/null +++ b/test/language/statements/class/fields-static-literal-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-super.case +// - src/class-fields/initializer-error/cls-decl-fields-static-literal-name.template +/*--- +description: Syntax error if `super()` used in class field (static literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + static x = super(); +} diff --git a/test/language/statements/class/fields-static-string-literal-name-init-err-contains-boolean.js b/test/language/statements/class/fields-static-string-literal-name-init-err-contains-boolean.js new file mode 100644 index 0000000000..1731f8a8d4 --- /dev/null +++ b/test/language/statements/class/fields-static-string-literal-name-init-err-contains-boolean.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-boolean.case +// - src/class-fields/initializer-error/cls-decl-fields-static-string-literal-name.template +/*--- +description: Syntax error if `arguments` used in class field (static string literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + static 'x' = arguments; +} diff --git a/test/language/statements/class/fields-static-string-literal-name-init-err-contains-super.js b/test/language/statements/class/fields-static-string-literal-name-init-err-contains-super.js new file mode 100644 index 0000000000..4a1f84c10b --- /dev/null +++ b/test/language/statements/class/fields-static-string-literal-name-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-super.case +// - src/class-fields/initializer-error/cls-decl-fields-static-string-literal-name.template +/*--- +description: Syntax error if `super()` used in class field (static string literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + static 'x' = super(); +} diff --git a/test/language/statements/class/fields-string-literal-name-init-err-contains-boolean.js b/test/language/statements/class/fields-string-literal-name-init-err-contains-boolean.js new file mode 100644 index 0000000000..9f5de255f3 --- /dev/null +++ b/test/language/statements/class/fields-string-literal-name-init-err-contains-boolean.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-boolean.case +// - src/class-fields/initializer-error/cls-decl-fields-string-literal-name.template +/*--- +description: Syntax error if `arguments` used in class field (string literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + 'x' = arguments; +} diff --git a/test/language/statements/class/fields-string-literal-name-init-err-contains-super.js b/test/language/statements/class/fields-string-literal-name-init-err-contains-super.js new file mode 100644 index 0000000000..b92f9e8dab --- /dev/null +++ b/test/language/statements/class/fields-string-literal-name-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-super.case +// - src/class-fields/initializer-error/cls-decl-fields-string-literal-name.template +/*--- +description: Syntax error if `super()` used in class field (string literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + 'x' = super(); +} diff --git a/test/language/statements/class/fields-ternary-init-err-contains-boolean.js b/test/language/statements/class/fields-ternary-init-err-contains-boolean.js new file mode 100644 index 0000000000..45cdb53d16 --- /dev/null +++ b/test/language/statements/class/fields-ternary-init-err-contains-boolean.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-boolean.case +// - src/class-fields/initializer-error/cls-decl-fields-ternary.template +/*--- +description: Syntax error if `arguments` used in class field (ternary expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + x = false ? {} : arguments; +} diff --git a/test/language/statements/class/fields-ternary-init-err-contains-super.js b/test/language/statements/class/fields-ternary-init-err-contains-super.js new file mode 100644 index 0000000000..2fd60ab02a --- /dev/null +++ b/test/language/statements/class/fields-ternary-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-super.case +// - src/class-fields/initializer-error/cls-decl-fields-ternary.template +/*--- +description: Syntax error if `super()` used in class field (ternary expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + x = false ? {} : super(); +} diff --git a/test/language/statements/class/fields-typeof-init-err-contains-boolean.js b/test/language/statements/class/fields-typeof-init-err-contains-boolean.js new file mode 100644 index 0000000000..54cb091677 --- /dev/null +++ b/test/language/statements/class/fields-typeof-init-err-contains-boolean.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-boolean.case +// - src/class-fields/initializer-error/cls-decl-fields-typeof.template +/*--- +description: Syntax error if `arguments` used in class field (typeof expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + x = typeof arguments; +} diff --git a/test/language/statements/class/fields-typeof-init-err-contains-super.js b/test/language/statements/class/fields-typeof-init-err-contains-super.js new file mode 100644 index 0000000000..71896312c1 --- /dev/null +++ b/test/language/statements/class/fields-typeof-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-fields/init-err-contains-super.case +// - src/class-fields/initializer-error/cls-decl-fields-typeof.template +/*--- +description: Syntax error if `super()` used in class field (typeof expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields] +flags: [generated] +negative: + phase: early + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + x = typeof super(); +}