diff --git a/test/language/expressions/class/err-field-delete-covered-err-delete-call-expression-private-method-async-gen.js b/test/language/expressions/class/err-field-delete-covered-err-delete-call-expression-private-method-async-gen.js new file mode 100644 index 0000000000..e0cd1449a3 --- /dev/null +++ b/test/language/expressions/class/err-field-delete-covered-err-delete-call-expression-private-method-async-gen.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-expr-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + g = this.f; + x = delete (g().#m); + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-field-delete-covered-err-delete-call-expression-private-method-async.js b/test/language/expressions/class/err-field-delete-covered-err-delete-call-expression-private-method-async.js new file mode 100644 index 0000000000..fe2c0144e7 --- /dev/null +++ b/test/language/expressions/class/err-field-delete-covered-err-delete-call-expression-private-method-async.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async.case +// - src/class-elements/delete-error/cls-expr-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + g = this.f; + x = delete (g().#m); + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-field-delete-covered-err-delete-call-expression-private-method-gen.js b/test/language/expressions/class/err-field-delete-covered-err-delete-call-expression-private-method-gen.js new file mode 100644 index 0000000000..2c2bf14b1f --- /dev/null +++ b/test/language/expressions/class/err-field-delete-covered-err-delete-call-expression-private-method-gen.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-expr-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + g = this.f; + x = delete (g().#m); + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-field-delete-covered-err-delete-call-expression-private-method.js b/test/language/expressions/class/err-field-delete-covered-err-delete-call-expression-private-method.js new file mode 100644 index 0000000000..81926aa80b --- /dev/null +++ b/test/language/expressions/class/err-field-delete-covered-err-delete-call-expression-private-method.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + g = this.f; + x = delete (g().#m); + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-field-delete-covered-err-delete-call-expression-privatename.js b/test/language/expressions/class/err-field-delete-covered-err-delete-call-expression-privatename.js new file mode 100644 index 0000000000..3a6beeebcb --- /dev/null +++ b/test/language/expressions/class/err-field-delete-covered-err-delete-call-expression-privatename.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + g = this.f; + x = delete (g().#x); + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-field-delete-covered-err-delete-member-expression-private-method-async-gen.js b/test/language/expressions/class/err-field-delete-covered-err-delete-member-expression-private-method-async-gen.js new file mode 100644 index 0000000000..1c4cbf5e96 --- /dev/null +++ b/test/language/expressions/class/err-field-delete-covered-err-delete-member-expression-private-method-async-gen.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-expr-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x = delete (this.#m +); + + +} diff --git a/test/language/expressions/class/err-field-delete-covered-err-delete-member-expression-private-method-async.js b/test/language/expressions/class/err-field-delete-covered-err-delete-member-expression-private-method-async.js new file mode 100644 index 0000000000..96ecc7e0e8 --- /dev/null +++ b/test/language/expressions/class/err-field-delete-covered-err-delete-member-expression-private-method-async.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async.case +// - src/class-elements/delete-error/cls-expr-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x = delete (this.#m +); + + +} diff --git a/test/language/expressions/class/err-field-delete-covered-err-delete-member-expression-private-method-gen.js b/test/language/expressions/class/err-field-delete-covered-err-delete-member-expression-private-method-gen.js new file mode 100644 index 0000000000..52482f8e48 --- /dev/null +++ b/test/language/expressions/class/err-field-delete-covered-err-delete-member-expression-private-method-gen.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-expr-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x = delete (this.#m +); + + +} diff --git a/test/language/expressions/class/err-field-delete-covered-err-delete-member-expression-private-method.js b/test/language/expressions/class/err-field-delete-covered-err-delete-member-expression-private-method.js new file mode 100644 index 0000000000..7bfa1f7a14 --- /dev/null +++ b/test/language/expressions/class/err-field-delete-covered-err-delete-member-expression-private-method.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x = delete (this.#m +); + + +} diff --git a/test/language/expressions/class/err-field-delete-covered-err-delete-member-expression-privatename.js b/test/language/expressions/class/err-field-delete-covered-err-delete-member-expression-privatename.js new file mode 100644 index 0000000000..35be85f9f4 --- /dev/null +++ b/test/language/expressions/class/err-field-delete-covered-err-delete-member-expression-privatename.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields-private, class, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x = delete (this.#x); + + +} diff --git a/test/language/expressions/class/err-field-delete-err-delete-call-expression-private-method-async-gen.js b/test/language/expressions/class/err-field-delete-err-delete-call-expression-private-method-async-gen.js new file mode 100644 index 0000000000..b967ea1a9f --- /dev/null +++ b/test/language/expressions/class/err-field-delete-err-delete-call-expression-private-method-async-gen.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + g = this.f; + x = delete g().#m; + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-field-delete-err-delete-call-expression-private-method-async.js b/test/language/expressions/class/err-field-delete-err-delete-call-expression-private-method-async.js new file mode 100644 index 0000000000..0f2fb4f559 --- /dev/null +++ b/test/language/expressions/class/err-field-delete-err-delete-call-expression-private-method-async.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + g = this.f; + x = delete g().#m; + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-field-delete-err-delete-call-expression-private-method-gen.js b/test/language/expressions/class/err-field-delete-err-delete-call-expression-private-method-gen.js new file mode 100644 index 0000000000..b45028a20a --- /dev/null +++ b/test/language/expressions/class/err-field-delete-err-delete-call-expression-private-method-gen.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + g = this.f; + x = delete g().#m; + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-field-delete-err-delete-call-expression-private-method.js b/test/language/expressions/class/err-field-delete-err-delete-call-expression-private-method.js new file mode 100644 index 0000000000..0354a71faf --- /dev/null +++ b/test/language/expressions/class/err-field-delete-err-delete-call-expression-private-method.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + g = this.f; + x = delete g().#m; + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-field-delete-err-delete-call-expression-privatename.js b/test/language/expressions/class/err-field-delete-err-delete-call-expression-privatename.js new file mode 100644 index 0000000000..b820cd3a75 --- /dev/null +++ b/test/language/expressions/class/err-field-delete-err-delete-call-expression-privatename.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + g = this.f; + x = delete g().#x; + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-field-delete-err-delete-member-expression-private-method-async-gen.js b/test/language/expressions/class/err-field-delete-err-delete-member-expression-private-method-async-gen.js new file mode 100644 index 0000000000..3483908500 --- /dev/null +++ b/test/language/expressions/class/err-field-delete-err-delete-member-expression-private-method-async-gen.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x = delete this.#m +; + + +} diff --git a/test/language/expressions/class/err-field-delete-err-delete-member-expression-private-method-async.js b/test/language/expressions/class/err-field-delete-err-delete-member-expression-private-method-async.js new file mode 100644 index 0000000000..7457e1ec20 --- /dev/null +++ b/test/language/expressions/class/err-field-delete-err-delete-member-expression-private-method-async.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x = delete this.#m +; + + +} diff --git a/test/language/expressions/class/err-field-delete-err-delete-member-expression-private-method-gen.js b/test/language/expressions/class/err-field-delete-err-delete-member-expression-private-method-gen.js new file mode 100644 index 0000000000..25da0aa632 --- /dev/null +++ b/test/language/expressions/class/err-field-delete-err-delete-member-expression-private-method-gen.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x = delete this.#m +; + + +} diff --git a/test/language/expressions/class/err-field-delete-err-delete-member-expression-private-method.js b/test/language/expressions/class/err-field-delete-err-delete-member-expression-private-method.js new file mode 100644 index 0000000000..9b7522a093 --- /dev/null +++ b/test/language/expressions/class/err-field-delete-err-delete-member-expression-private-method.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x = delete this.#m +; + + +} diff --git a/test/language/expressions/class/err-field-delete-err-delete-member-expression-privatename.js b/test/language/expressions/class/err-field-delete-err-delete-member-expression-privatename.js new file mode 100644 index 0000000000..7e0d67d406 --- /dev/null +++ b/test/language/expressions/class/err-field-delete-err-delete-member-expression-privatename.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields-private, class, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x = delete this.#x; + + +} diff --git a/test/language/expressions/class/err-field-delete-twice-covered-err-delete-call-expression-private-method-async-gen.js b/test/language/expressions/class/err-field-delete-twice-covered-err-delete-call-expression-private-method-async-gen.js new file mode 100644 index 0000000000..498d88ab98 --- /dev/null +++ b/test/language/expressions/class/err-field-delete-twice-covered-err-delete-call-expression-private-method-async-gen.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-expr-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + g = this.f; + x = delete ((g().#m)); + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-field-delete-twice-covered-err-delete-call-expression-private-method-async.js b/test/language/expressions/class/err-field-delete-twice-covered-err-delete-call-expression-private-method-async.js new file mode 100644 index 0000000000..dfa9029085 --- /dev/null +++ b/test/language/expressions/class/err-field-delete-twice-covered-err-delete-call-expression-private-method-async.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async.case +// - src/class-elements/delete-error/cls-expr-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + g = this.f; + x = delete ((g().#m)); + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-field-delete-twice-covered-err-delete-call-expression-private-method-gen.js b/test/language/expressions/class/err-field-delete-twice-covered-err-delete-call-expression-private-method-gen.js new file mode 100644 index 0000000000..31b0644207 --- /dev/null +++ b/test/language/expressions/class/err-field-delete-twice-covered-err-delete-call-expression-private-method-gen.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-expr-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + g = this.f; + x = delete ((g().#m)); + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-field-delete-twice-covered-err-delete-call-expression-private-method.js b/test/language/expressions/class/err-field-delete-twice-covered-err-delete-call-expression-private-method.js new file mode 100644 index 0000000000..b51df544a2 --- /dev/null +++ b/test/language/expressions/class/err-field-delete-twice-covered-err-delete-call-expression-private-method.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + g = this.f; + x = delete ((g().#m)); + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-field-delete-twice-covered-err-delete-call-expression-privatename.js b/test/language/expressions/class/err-field-delete-twice-covered-err-delete-call-expression-privatename.js new file mode 100644 index 0000000000..428b6c3ec5 --- /dev/null +++ b/test/language/expressions/class/err-field-delete-twice-covered-err-delete-call-expression-privatename.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + g = this.f; + x = delete ((g().#x)); + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-field-delete-twice-covered-err-delete-member-expression-private-method-async-gen.js b/test/language/expressions/class/err-field-delete-twice-covered-err-delete-member-expression-private-method-async-gen.js new file mode 100644 index 0000000000..b27f8f40ba --- /dev/null +++ b/test/language/expressions/class/err-field-delete-twice-covered-err-delete-member-expression-private-method-async-gen.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-expr-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x = delete ((this.#m +)); + + +} diff --git a/test/language/expressions/class/err-field-delete-twice-covered-err-delete-member-expression-private-method-async.js b/test/language/expressions/class/err-field-delete-twice-covered-err-delete-member-expression-private-method-async.js new file mode 100644 index 0000000000..50f049337a --- /dev/null +++ b/test/language/expressions/class/err-field-delete-twice-covered-err-delete-member-expression-private-method-async.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async.case +// - src/class-elements/delete-error/cls-expr-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x = delete ((this.#m +)); + + +} diff --git a/test/language/expressions/class/err-field-delete-twice-covered-err-delete-member-expression-private-method-gen.js b/test/language/expressions/class/err-field-delete-twice-covered-err-delete-member-expression-private-method-gen.js new file mode 100644 index 0000000000..693b77792c --- /dev/null +++ b/test/language/expressions/class/err-field-delete-twice-covered-err-delete-member-expression-private-method-gen.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-expr-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x = delete ((this.#m +)); + + +} diff --git a/test/language/expressions/class/err-field-delete-twice-covered-err-delete-member-expression-private-method.js b/test/language/expressions/class/err-field-delete-twice-covered-err-delete-member-expression-private-method.js new file mode 100644 index 0000000000..42b33c457e --- /dev/null +++ b/test/language/expressions/class/err-field-delete-twice-covered-err-delete-member-expression-private-method.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x = delete ((this.#m +)); + + +} diff --git a/test/language/expressions/class/err-field-delete-twice-covered-err-delete-member-expression-privatename.js b/test/language/expressions/class/err-field-delete-twice-covered-err-delete-member-expression-privatename.js new file mode 100644 index 0000000000..1db6d3b16c --- /dev/null +++ b/test/language/expressions/class/err-field-delete-twice-covered-err-delete-member-expression-privatename.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields-private, class, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x = delete ((this.#x)); + + +} diff --git a/test/language/expressions/class/err-method-delete-covered-err-delete-call-expression-private-method-async-gen.js b/test/language/expressions/class/err-method-delete-covered-err-delete-call-expression-private-method-async-gen.js new file mode 100644 index 0000000000..fe565e2a8f --- /dev/null +++ b/test/language/expressions/class/err-method-delete-covered-err-delete-call-expression-private-method-async-gen.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-expr-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + var g = this.f; + delete (g().#m); + } + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-method-delete-covered-err-delete-call-expression-private-method-async.js b/test/language/expressions/class/err-method-delete-covered-err-delete-call-expression-private-method-async.js new file mode 100644 index 0000000000..859936f4c8 --- /dev/null +++ b/test/language/expressions/class/err-method-delete-covered-err-delete-call-expression-private-method-async.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async.case +// - src/class-elements/delete-error/cls-expr-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + var g = this.f; + delete (g().#m); + } + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-method-delete-covered-err-delete-call-expression-private-method-gen.js b/test/language/expressions/class/err-method-delete-covered-err-delete-call-expression-private-method-gen.js new file mode 100644 index 0000000000..0a614f5f54 --- /dev/null +++ b/test/language/expressions/class/err-method-delete-covered-err-delete-call-expression-private-method-gen.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-expr-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + var g = this.f; + delete (g().#m); + } + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-method-delete-covered-err-delete-call-expression-private-method.js b/test/language/expressions/class/err-method-delete-covered-err-delete-call-expression-private-method.js new file mode 100644 index 0000000000..9d0a1d1ebe --- /dev/null +++ b/test/language/expressions/class/err-method-delete-covered-err-delete-call-expression-private-method.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + var g = this.f; + delete (g().#m); + } + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-method-delete-covered-err-delete-call-expression-privatename.js b/test/language/expressions/class/err-method-delete-covered-err-delete-call-expression-privatename.js new file mode 100644 index 0000000000..a3617ff2b1 --- /dev/null +++ b/test/language/expressions/class/err-method-delete-covered-err-delete-call-expression-privatename.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + var g = this.f; + delete (g().#x); + } + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-method-delete-covered-err-delete-member-expression-private-method-async-gen.js b/test/language/expressions/class/err-method-delete-covered-err-delete-member-expression-private-method-async-gen.js new file mode 100644 index 0000000000..e4a942d60f --- /dev/null +++ b/test/language/expressions/class/err-method-delete-covered-err-delete-member-expression-private-method-async-gen.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-expr-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + + delete (this.#m +); + } + + +} diff --git a/test/language/expressions/class/err-method-delete-covered-err-delete-member-expression-private-method-async.js b/test/language/expressions/class/err-method-delete-covered-err-delete-member-expression-private-method-async.js new file mode 100644 index 0000000000..25b2565ac0 --- /dev/null +++ b/test/language/expressions/class/err-method-delete-covered-err-delete-member-expression-private-method-async.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async.case +// - src/class-elements/delete-error/cls-expr-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + + delete (this.#m +); + } + + +} diff --git a/test/language/expressions/class/err-method-delete-covered-err-delete-member-expression-private-method-gen.js b/test/language/expressions/class/err-method-delete-covered-err-delete-member-expression-private-method-gen.js new file mode 100644 index 0000000000..1bd77a6137 --- /dev/null +++ b/test/language/expressions/class/err-method-delete-covered-err-delete-member-expression-private-method-gen.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-expr-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + + delete (this.#m +); + } + + +} diff --git a/test/language/expressions/class/err-method-delete-covered-err-delete-member-expression-private-method.js b/test/language/expressions/class/err-method-delete-covered-err-delete-member-expression-private-method.js new file mode 100644 index 0000000000..3cd2e4c6d1 --- /dev/null +++ b/test/language/expressions/class/err-method-delete-covered-err-delete-member-expression-private-method.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + + delete (this.#m +); + } + + +} diff --git a/test/language/expressions/class/err-method-delete-covered-err-delete-member-expression-privatename.js b/test/language/expressions/class/err-method-delete-covered-err-delete-member-expression-privatename.js new file mode 100644 index 0000000000..b83515b19b --- /dev/null +++ b/test/language/expressions/class/err-method-delete-covered-err-delete-member-expression-privatename.js @@ -0,0 +1,43 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + + delete (this.#x); + } + + +} diff --git a/test/language/expressions/class/err-method-delete-err-delete-call-expression-private-method-async-gen.js b/test/language/expressions/class/err-method-delete-err-delete-call-expression-private-method-async-gen.js new file mode 100644 index 0000000000..a78ddb0648 --- /dev/null +++ b/test/language/expressions/class/err-method-delete-err-delete-call-expression-private-method-async-gen.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + var g = this.f; + delete g().#m; + } + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-method-delete-err-delete-call-expression-private-method-async.js b/test/language/expressions/class/err-method-delete-err-delete-call-expression-private-method-async.js new file mode 100644 index 0000000000..f44d0c0dea --- /dev/null +++ b/test/language/expressions/class/err-method-delete-err-delete-call-expression-private-method-async.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + var g = this.f; + delete g().#m; + } + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-method-delete-err-delete-call-expression-private-method-gen.js b/test/language/expressions/class/err-method-delete-err-delete-call-expression-private-method-gen.js new file mode 100644 index 0000000000..a9450d49d5 --- /dev/null +++ b/test/language/expressions/class/err-method-delete-err-delete-call-expression-private-method-gen.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + var g = this.f; + delete g().#m; + } + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-method-delete-err-delete-call-expression-private-method.js b/test/language/expressions/class/err-method-delete-err-delete-call-expression-private-method.js new file mode 100644 index 0000000000..ff17918f57 --- /dev/null +++ b/test/language/expressions/class/err-method-delete-err-delete-call-expression-private-method.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + var g = this.f; + delete g().#m; + } + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-method-delete-err-delete-call-expression-privatename.js b/test/language/expressions/class/err-method-delete-err-delete-call-expression-privatename.js new file mode 100644 index 0000000000..4d6459aa04 --- /dev/null +++ b/test/language/expressions/class/err-method-delete-err-delete-call-expression-privatename.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + var g = this.f; + delete g().#x; + } + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-method-delete-err-delete-member-expression-private-method-async-gen.js b/test/language/expressions/class/err-method-delete-err-delete-member-expression-private-method-async-gen.js new file mode 100644 index 0000000000..5b100cee0e --- /dev/null +++ b/test/language/expressions/class/err-method-delete-err-delete-member-expression-private-method-async-gen.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + + delete this.#m +; + } + + +} diff --git a/test/language/expressions/class/err-method-delete-err-delete-member-expression-private-method-async.js b/test/language/expressions/class/err-method-delete-err-delete-member-expression-private-method-async.js new file mode 100644 index 0000000000..5cab49c52e --- /dev/null +++ b/test/language/expressions/class/err-method-delete-err-delete-member-expression-private-method-async.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + + delete this.#m +; + } + + +} diff --git a/test/language/expressions/class/err-method-delete-err-delete-member-expression-private-method-gen.js b/test/language/expressions/class/err-method-delete-err-delete-member-expression-private-method-gen.js new file mode 100644 index 0000000000..350332223b --- /dev/null +++ b/test/language/expressions/class/err-method-delete-err-delete-member-expression-private-method-gen.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + + delete this.#m +; + } + + +} diff --git a/test/language/expressions/class/err-method-delete-err-delete-member-expression-private-method.js b/test/language/expressions/class/err-method-delete-err-delete-member-expression-private-method.js new file mode 100644 index 0000000000..f5fbdaa6be --- /dev/null +++ b/test/language/expressions/class/err-method-delete-err-delete-member-expression-private-method.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + + delete this.#m +; + } + + +} diff --git a/test/language/expressions/class/err-method-delete-err-delete-member-expression-privatename.js b/test/language/expressions/class/err-method-delete-err-delete-member-expression-privatename.js new file mode 100644 index 0000000000..b115b91add --- /dev/null +++ b/test/language/expressions/class/err-method-delete-err-delete-member-expression-privatename.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + + delete this.#x; + } + + +} diff --git a/test/language/expressions/class/err-method-delete-twice-covered-err-delete-call-expression-private-method-async-gen.js b/test/language/expressions/class/err-method-delete-twice-covered-err-delete-call-expression-private-method-async-gen.js new file mode 100644 index 0000000000..15ba93738b --- /dev/null +++ b/test/language/expressions/class/err-method-delete-twice-covered-err-delete-call-expression-private-method-async-gen.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-expr-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + var g = this.f; + delete ((g().#m)); + } + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-method-delete-twice-covered-err-delete-call-expression-private-method-async.js b/test/language/expressions/class/err-method-delete-twice-covered-err-delete-call-expression-private-method-async.js new file mode 100644 index 0000000000..5b9a044c9e --- /dev/null +++ b/test/language/expressions/class/err-method-delete-twice-covered-err-delete-call-expression-private-method-async.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async.case +// - src/class-elements/delete-error/cls-expr-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + var g = this.f; + delete ((g().#m)); + } + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-method-delete-twice-covered-err-delete-call-expression-private-method-gen.js b/test/language/expressions/class/err-method-delete-twice-covered-err-delete-call-expression-private-method-gen.js new file mode 100644 index 0000000000..753d3145e7 --- /dev/null +++ b/test/language/expressions/class/err-method-delete-twice-covered-err-delete-call-expression-private-method-gen.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-expr-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + var g = this.f; + delete ((g().#m)); + } + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-method-delete-twice-covered-err-delete-call-expression-private-method.js b/test/language/expressions/class/err-method-delete-twice-covered-err-delete-call-expression-private-method.js new file mode 100644 index 0000000000..f51adde5f6 --- /dev/null +++ b/test/language/expressions/class/err-method-delete-twice-covered-err-delete-call-expression-private-method.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + var g = this.f; + delete ((g().#m)); + } + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-method-delete-twice-covered-err-delete-call-expression-privatename.js b/test/language/expressions/class/err-method-delete-twice-covered-err-delete-call-expression-privatename.js new file mode 100644 index 0000000000..d38b568071 --- /dev/null +++ b/test/language/expressions/class/err-method-delete-twice-covered-err-delete-call-expression-privatename.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + var g = this.f; + delete ((g().#x)); + } + + f() { + return this; + } +} diff --git a/test/language/expressions/class/err-method-delete-twice-covered-err-delete-member-expression-private-method-async-gen.js b/test/language/expressions/class/err-method-delete-twice-covered-err-delete-member-expression-private-method-async-gen.js new file mode 100644 index 0000000000..9ed9ddf0d5 --- /dev/null +++ b/test/language/expressions/class/err-method-delete-twice-covered-err-delete-member-expression-private-method-async-gen.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-expr-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + + delete ((this.#m +)); + } + + +} diff --git a/test/language/expressions/class/err-method-delete-twice-covered-err-delete-member-expression-private-method-async.js b/test/language/expressions/class/err-method-delete-twice-covered-err-delete-member-expression-private-method-async.js new file mode 100644 index 0000000000..bda94fa753 --- /dev/null +++ b/test/language/expressions/class/err-method-delete-twice-covered-err-delete-member-expression-private-method-async.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async.case +// - src/class-elements/delete-error/cls-expr-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + + delete ((this.#m +)); + } + + +} diff --git a/test/language/expressions/class/err-method-delete-twice-covered-err-delete-member-expression-private-method-gen.js b/test/language/expressions/class/err-method-delete-twice-covered-err-delete-member-expression-private-method-gen.js new file mode 100644 index 0000000000..d854d47538 --- /dev/null +++ b/test/language/expressions/class/err-method-delete-twice-covered-err-delete-member-expression-private-method-gen.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-expr-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + + delete ((this.#m +)); + } + + +} diff --git a/test/language/expressions/class/err-method-delete-twice-covered-err-delete-member-expression-private-method.js b/test/language/expressions/class/err-method-delete-twice-covered-err-delete-member-expression-private-method.js new file mode 100644 index 0000000000..1b56bfdf55 --- /dev/null +++ b/test/language/expressions/class/err-method-delete-twice-covered-err-delete-member-expression-private-method.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + + delete ((this.#m +)); + } + + +} diff --git a/test/language/expressions/class/err-method-delete-twice-covered-err-delete-member-expression-privatename.js b/test/language/expressions/class/err-method-delete-twice-covered-err-delete-member-expression-privatename.js new file mode 100644 index 0000000000..ba1409305b --- /dev/null +++ b/test/language/expressions/class/err-method-delete-twice-covered-err-delete-member-expression-privatename.js @@ -0,0 +1,43 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +var C = class { + #x; + + x() { + + delete ((this.#x)); + } + + +} diff --git a/test/language/statements/class/err-field-delete-covered-err-delete-call-expression-private-method-async-gen.js b/test/language/statements/class/err-field-delete-covered-err-delete-call-expression-private-method-async-gen.js new file mode 100644 index 0000000000..dc41395c8b --- /dev/null +++ b/test/language/statements/class/err-field-delete-covered-err-delete-call-expression-private-method-async-gen.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-decl-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + g = this.f; + x = delete (g().#m); + f() { + return this; + } +} diff --git a/test/language/statements/class/err-field-delete-covered-err-delete-call-expression-private-method-async.js b/test/language/statements/class/err-field-delete-covered-err-delete-call-expression-private-method-async.js new file mode 100644 index 0000000000..84a5677abb --- /dev/null +++ b/test/language/statements/class/err-field-delete-covered-err-delete-call-expression-private-method-async.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async.case +// - src/class-elements/delete-error/cls-decl-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + g = this.f; + x = delete (g().#m); + f() { + return this; + } +} diff --git a/test/language/statements/class/err-field-delete-covered-err-delete-call-expression-private-method-gen.js b/test/language/statements/class/err-field-delete-covered-err-delete-call-expression-private-method-gen.js new file mode 100644 index 0000000000..9f67675420 --- /dev/null +++ b/test/language/statements/class/err-field-delete-covered-err-delete-call-expression-private-method-gen.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-decl-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + g = this.f; + x = delete (g().#m); + f() { + return this; + } +} diff --git a/test/language/statements/class/err-field-delete-covered-err-delete-call-expression-private-method.js b/test/language/statements/class/err-field-delete-covered-err-delete-call-expression-private-method.js new file mode 100644 index 0000000000..507fb4bccd --- /dev/null +++ b/test/language/statements/class/err-field-delete-covered-err-delete-call-expression-private-method.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method.case +// - src/class-elements/delete-error/cls-decl-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + g = this.f; + x = delete (g().#m); + f() { + return this; + } +} diff --git a/test/language/statements/class/err-field-delete-covered-err-delete-call-expression-privatename.js b/test/language/statements/class/err-field-delete-covered-err-delete-call-expression-privatename.js new file mode 100644 index 0000000000..527bd983ee --- /dev/null +++ b/test/language/statements/class/err-field-delete-covered-err-delete-call-expression-privatename.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-privatename.case +// - src/class-elements/delete-error/cls-decl-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + g = this.f; + x = delete (g().#x); + f() { + return this; + } +} diff --git a/test/language/statements/class/err-field-delete-covered-err-delete-member-expression-private-method-async-gen.js b/test/language/statements/class/err-field-delete-covered-err-delete-member-expression-private-method-async-gen.js new file mode 100644 index 0000000000..92bd8fb324 --- /dev/null +++ b/test/language/statements/class/err-field-delete-covered-err-delete-member-expression-private-method-async-gen.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-decl-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x = delete (this.#m +); + +} diff --git a/test/language/statements/class/err-field-delete-covered-err-delete-member-expression-private-method-async.js b/test/language/statements/class/err-field-delete-covered-err-delete-member-expression-private-method-async.js new file mode 100644 index 0000000000..7706ee76aa --- /dev/null +++ b/test/language/statements/class/err-field-delete-covered-err-delete-member-expression-private-method-async.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async.case +// - src/class-elements/delete-error/cls-decl-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x = delete (this.#m +); + +} diff --git a/test/language/statements/class/err-field-delete-covered-err-delete-member-expression-private-method-gen.js b/test/language/statements/class/err-field-delete-covered-err-delete-member-expression-private-method-gen.js new file mode 100644 index 0000000000..75470c8324 --- /dev/null +++ b/test/language/statements/class/err-field-delete-covered-err-delete-member-expression-private-method-gen.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-decl-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x = delete (this.#m +); + +} diff --git a/test/language/statements/class/err-field-delete-covered-err-delete-member-expression-private-method.js b/test/language/statements/class/err-field-delete-covered-err-delete-member-expression-private-method.js new file mode 100644 index 0000000000..4a6f0ea927 --- /dev/null +++ b/test/language/statements/class/err-field-delete-covered-err-delete-member-expression-private-method.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method.case +// - src/class-elements/delete-error/cls-decl-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x = delete (this.#m +); + +} diff --git a/test/language/statements/class/err-field-delete-covered-err-delete-member-expression-privatename.js b/test/language/statements/class/err-field-delete-covered-err-delete-member-expression-privatename.js new file mode 100644 index 0000000000..87598e0898 --- /dev/null +++ b/test/language/statements/class/err-field-delete-covered-err-delete-member-expression-privatename.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-privatename.case +// - src/class-elements/delete-error/cls-decl-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields-private, class, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x = delete (this.#x); + +} diff --git a/test/language/statements/class/err-field-delete-err-delete-call-expression-private-method-async-gen.js b/test/language/statements/class/err-field-delete-err-delete-call-expression-private-method-async-gen.js new file mode 100644 index 0000000000..65dfa3a196 --- /dev/null +++ b/test/language/statements/class/err-field-delete-err-delete-call-expression-private-method-async-gen.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-decl-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + g = this.f; + x = delete g().#m; + f() { + return this; + } +} diff --git a/test/language/statements/class/err-field-delete-err-delete-call-expression-private-method-async.js b/test/language/statements/class/err-field-delete-err-delete-call-expression-private-method-async.js new file mode 100644 index 0000000000..eaff833586 --- /dev/null +++ b/test/language/statements/class/err-field-delete-err-delete-call-expression-private-method-async.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async.case +// - src/class-elements/delete-error/cls-decl-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + g = this.f; + x = delete g().#m; + f() { + return this; + } +} diff --git a/test/language/statements/class/err-field-delete-err-delete-call-expression-private-method-gen.js b/test/language/statements/class/err-field-delete-err-delete-call-expression-private-method-gen.js new file mode 100644 index 0000000000..c91489364a --- /dev/null +++ b/test/language/statements/class/err-field-delete-err-delete-call-expression-private-method-gen.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-decl-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + g = this.f; + x = delete g().#m; + f() { + return this; + } +} diff --git a/test/language/statements/class/err-field-delete-err-delete-call-expression-private-method.js b/test/language/statements/class/err-field-delete-err-delete-call-expression-private-method.js new file mode 100644 index 0000000000..59970b651f --- /dev/null +++ b/test/language/statements/class/err-field-delete-err-delete-call-expression-private-method.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method.case +// - src/class-elements/delete-error/cls-decl-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + g = this.f; + x = delete g().#m; + f() { + return this; + } +} diff --git a/test/language/statements/class/err-field-delete-err-delete-call-expression-privatename.js b/test/language/statements/class/err-field-delete-err-delete-call-expression-privatename.js new file mode 100644 index 0000000000..1fb46f0584 --- /dev/null +++ b/test/language/statements/class/err-field-delete-err-delete-call-expression-privatename.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-privatename.case +// - src/class-elements/delete-error/cls-decl-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + g = this.f; + x = delete g().#x; + f() { + return this; + } +} diff --git a/test/language/statements/class/err-field-delete-err-delete-member-expression-private-method-async-gen.js b/test/language/statements/class/err-field-delete-err-delete-member-expression-private-method-async-gen.js new file mode 100644 index 0000000000..233b8eb4ae --- /dev/null +++ b/test/language/statements/class/err-field-delete-err-delete-member-expression-private-method-async-gen.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-decl-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x = delete this.#m +; + +} diff --git a/test/language/statements/class/err-field-delete-err-delete-member-expression-private-method-async.js b/test/language/statements/class/err-field-delete-err-delete-member-expression-private-method-async.js new file mode 100644 index 0000000000..f7f114f098 --- /dev/null +++ b/test/language/statements/class/err-field-delete-err-delete-member-expression-private-method-async.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async.case +// - src/class-elements/delete-error/cls-decl-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x = delete this.#m +; + +} diff --git a/test/language/statements/class/err-field-delete-err-delete-member-expression-private-method-gen.js b/test/language/statements/class/err-field-delete-err-delete-member-expression-private-method-gen.js new file mode 100644 index 0000000000..c707ace238 --- /dev/null +++ b/test/language/statements/class/err-field-delete-err-delete-member-expression-private-method-gen.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-decl-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x = delete this.#m +; + +} diff --git a/test/language/statements/class/err-field-delete-err-delete-member-expression-private-method.js b/test/language/statements/class/err-field-delete-err-delete-member-expression-private-method.js new file mode 100644 index 0000000000..c3980c9bf7 --- /dev/null +++ b/test/language/statements/class/err-field-delete-err-delete-member-expression-private-method.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method.case +// - src/class-elements/delete-error/cls-decl-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x = delete this.#m +; + +} diff --git a/test/language/statements/class/err-field-delete-err-delete-member-expression-privatename.js b/test/language/statements/class/err-field-delete-err-delete-member-expression-privatename.js new file mode 100644 index 0000000000..b141545b42 --- /dev/null +++ b/test/language/statements/class/err-field-delete-err-delete-member-expression-privatename.js @@ -0,0 +1,33 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-privatename.case +// - src/class-elements/delete-error/cls-decl-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields-private, class, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x = delete this.#x; + +} diff --git a/test/language/statements/class/err-field-delete-twice-covered-err-delete-call-expression-private-method-async-gen.js b/test/language/statements/class/err-field-delete-twice-covered-err-delete-call-expression-private-method-async-gen.js new file mode 100644 index 0000000000..8871ce46a0 --- /dev/null +++ b/test/language/statements/class/err-field-delete-twice-covered-err-delete-call-expression-private-method-async-gen.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-decl-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + g = this.f; + x = delete ((g().#m)); + + f() { + return this; + } +} diff --git a/test/language/statements/class/err-field-delete-twice-covered-err-delete-call-expression-private-method-async.js b/test/language/statements/class/err-field-delete-twice-covered-err-delete-call-expression-private-method-async.js new file mode 100644 index 0000000000..13f15a1407 --- /dev/null +++ b/test/language/statements/class/err-field-delete-twice-covered-err-delete-call-expression-private-method-async.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async.case +// - src/class-elements/delete-error/cls-decl-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + g = this.f; + x = delete ((g().#m)); + + f() { + return this; + } +} diff --git a/test/language/statements/class/err-field-delete-twice-covered-err-delete-call-expression-private-method-gen.js b/test/language/statements/class/err-field-delete-twice-covered-err-delete-call-expression-private-method-gen.js new file mode 100644 index 0000000000..186528c21b --- /dev/null +++ b/test/language/statements/class/err-field-delete-twice-covered-err-delete-call-expression-private-method-gen.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-decl-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + g = this.f; + x = delete ((g().#m)); + + f() { + return this; + } +} diff --git a/test/language/statements/class/err-field-delete-twice-covered-err-delete-call-expression-private-method.js b/test/language/statements/class/err-field-delete-twice-covered-err-delete-call-expression-private-method.js new file mode 100644 index 0000000000..50b84c0f91 --- /dev/null +++ b/test/language/statements/class/err-field-delete-twice-covered-err-delete-call-expression-private-method.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method.case +// - src/class-elements/delete-error/cls-decl-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + g = this.f; + x = delete ((g().#m)); + + f() { + return this; + } +} diff --git a/test/language/statements/class/err-field-delete-twice-covered-err-delete-call-expression-privatename.js b/test/language/statements/class/err-field-delete-twice-covered-err-delete-call-expression-privatename.js new file mode 100644 index 0000000000..04af0074f1 --- /dev/null +++ b/test/language/statements/class/err-field-delete-twice-covered-err-delete-call-expression-privatename.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-privatename.case +// - src/class-elements/delete-error/cls-decl-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + g = this.f; + x = delete ((g().#x)); + + f() { + return this; + } +} diff --git a/test/language/statements/class/err-field-delete-twice-covered-err-delete-member-expression-private-method-async-gen.js b/test/language/statements/class/err-field-delete-twice-covered-err-delete-member-expression-private-method-async-gen.js new file mode 100644 index 0000000000..1ed22bbf44 --- /dev/null +++ b/test/language/statements/class/err-field-delete-twice-covered-err-delete-member-expression-private-method-async-gen.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-decl-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x = delete ((this.#m +)); + + +} diff --git a/test/language/statements/class/err-field-delete-twice-covered-err-delete-member-expression-private-method-async.js b/test/language/statements/class/err-field-delete-twice-covered-err-delete-member-expression-private-method-async.js new file mode 100644 index 0000000000..a5bf66a854 --- /dev/null +++ b/test/language/statements/class/err-field-delete-twice-covered-err-delete-member-expression-private-method-async.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async.case +// - src/class-elements/delete-error/cls-decl-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x = delete ((this.#m +)); + + +} diff --git a/test/language/statements/class/err-field-delete-twice-covered-err-delete-member-expression-private-method-gen.js b/test/language/statements/class/err-field-delete-twice-covered-err-delete-member-expression-private-method-gen.js new file mode 100644 index 0000000000..7b85917b38 --- /dev/null +++ b/test/language/statements/class/err-field-delete-twice-covered-err-delete-member-expression-private-method-gen.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-decl-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x = delete ((this.#m +)); + + +} diff --git a/test/language/statements/class/err-field-delete-twice-covered-err-delete-member-expression-private-method.js b/test/language/statements/class/err-field-delete-twice-covered-err-delete-member-expression-private-method.js new file mode 100644 index 0000000000..174eacf25f --- /dev/null +++ b/test/language/statements/class/err-field-delete-twice-covered-err-delete-member-expression-private-method.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method.case +// - src/class-elements/delete-error/cls-decl-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x = delete ((this.#m +)); + + +} diff --git a/test/language/statements/class/err-field-delete-twice-covered-err-delete-member-expression-privatename.js b/test/language/statements/class/err-field-delete-twice-covered-err-delete-member-expression-privatename.js new file mode 100644 index 0000000000..0aeafc533a --- /dev/null +++ b/test/language/statements/class/err-field-delete-twice-covered-err-delete-member-expression-privatename.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-privatename.case +// - src/class-elements/delete-error/cls-decl-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields-private, class, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x = delete ((this.#x)); + + +} diff --git a/test/language/statements/class/err-method-delete-covered-err-delete-call-expression-private-method-async-gen.js b/test/language/statements/class/err-method-delete-covered-err-delete-call-expression-private-method-async-gen.js new file mode 100644 index 0000000000..e4e4914e9f --- /dev/null +++ b/test/language/statements/class/err-method-delete-covered-err-delete-call-expression-private-method-async-gen.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-decl-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + var g = this.f; + delete (g().#m); + } + + f() { + return this; + } +} diff --git a/test/language/statements/class/err-method-delete-covered-err-delete-call-expression-private-method-async.js b/test/language/statements/class/err-method-delete-covered-err-delete-call-expression-private-method-async.js new file mode 100644 index 0000000000..b4317e1678 --- /dev/null +++ b/test/language/statements/class/err-method-delete-covered-err-delete-call-expression-private-method-async.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async.case +// - src/class-elements/delete-error/cls-decl-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + var g = this.f; + delete (g().#m); + } + + f() { + return this; + } +} diff --git a/test/language/statements/class/err-method-delete-covered-err-delete-call-expression-private-method-gen.js b/test/language/statements/class/err-method-delete-covered-err-delete-call-expression-private-method-gen.js new file mode 100644 index 0000000000..489cd25cb1 --- /dev/null +++ b/test/language/statements/class/err-method-delete-covered-err-delete-call-expression-private-method-gen.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-decl-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + var g = this.f; + delete (g().#m); + } + + f() { + return this; + } +} diff --git a/test/language/statements/class/err-method-delete-covered-err-delete-call-expression-private-method.js b/test/language/statements/class/err-method-delete-covered-err-delete-call-expression-private-method.js new file mode 100644 index 0000000000..c1c56d3923 --- /dev/null +++ b/test/language/statements/class/err-method-delete-covered-err-delete-call-expression-private-method.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method.case +// - src/class-elements/delete-error/cls-decl-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + var g = this.f; + delete (g().#m); + } + + f() { + return this; + } +} diff --git a/test/language/statements/class/err-method-delete-covered-err-delete-call-expression-privatename.js b/test/language/statements/class/err-method-delete-covered-err-delete-call-expression-privatename.js new file mode 100644 index 0000000000..083d02edf1 --- /dev/null +++ b/test/language/statements/class/err-method-delete-covered-err-delete-call-expression-privatename.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-privatename.case +// - src/class-elements/delete-error/cls-decl-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + var g = this.f; + delete (g().#x); + } + + f() { + return this; + } +} diff --git a/test/language/statements/class/err-method-delete-covered-err-delete-member-expression-private-method-async-gen.js b/test/language/statements/class/err-method-delete-covered-err-delete-member-expression-private-method-async-gen.js new file mode 100644 index 0000000000..d3c617c9a2 --- /dev/null +++ b/test/language/statements/class/err-method-delete-covered-err-delete-member-expression-private-method-async-gen.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-decl-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + + delete (this.#m +); + } + + +} diff --git a/test/language/statements/class/err-method-delete-covered-err-delete-member-expression-private-method-async.js b/test/language/statements/class/err-method-delete-covered-err-delete-member-expression-private-method-async.js new file mode 100644 index 0000000000..80d81b2fec --- /dev/null +++ b/test/language/statements/class/err-method-delete-covered-err-delete-member-expression-private-method-async.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async.case +// - src/class-elements/delete-error/cls-decl-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + + delete (this.#m +); + } + + +} diff --git a/test/language/statements/class/err-method-delete-covered-err-delete-member-expression-private-method-gen.js b/test/language/statements/class/err-method-delete-covered-err-delete-member-expression-private-method-gen.js new file mode 100644 index 0000000000..f79318e282 --- /dev/null +++ b/test/language/statements/class/err-method-delete-covered-err-delete-member-expression-private-method-gen.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-decl-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + + delete (this.#m +); + } + + +} diff --git a/test/language/statements/class/err-method-delete-covered-err-delete-member-expression-private-method.js b/test/language/statements/class/err-method-delete-covered-err-delete-member-expression-private-method.js new file mode 100644 index 0000000000..2d17acb3f0 --- /dev/null +++ b/test/language/statements/class/err-method-delete-covered-err-delete-member-expression-private-method.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method.case +// - src/class-elements/delete-error/cls-decl-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + + delete (this.#m +); + } + + +} diff --git a/test/language/statements/class/err-method-delete-covered-err-delete-member-expression-privatename.js b/test/language/statements/class/err-method-delete-covered-err-delete-member-expression-privatename.js new file mode 100644 index 0000000000..7bc210d933 --- /dev/null +++ b/test/language/statements/class/err-method-delete-covered-err-delete-member-expression-privatename.js @@ -0,0 +1,43 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-privatename.case +// - src/class-elements/delete-error/cls-decl-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + + delete (this.#x); + } + + +} diff --git a/test/language/statements/class/err-method-delete-err-delete-call-expression-private-method-async-gen.js b/test/language/statements/class/err-method-delete-err-delete-call-expression-private-method-async-gen.js new file mode 100644 index 0000000000..1ab0d9ec14 --- /dev/null +++ b/test/language/statements/class/err-method-delete-err-delete-call-expression-private-method-async-gen.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-decl-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + var g = this.f; + delete g().#m; + } + + f() { + return this; + } +} diff --git a/test/language/statements/class/err-method-delete-err-delete-call-expression-private-method-async.js b/test/language/statements/class/err-method-delete-err-delete-call-expression-private-method-async.js new file mode 100644 index 0000000000..8be5dabcd9 --- /dev/null +++ b/test/language/statements/class/err-method-delete-err-delete-call-expression-private-method-async.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async.case +// - src/class-elements/delete-error/cls-decl-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + var g = this.f; + delete g().#m; + } + + f() { + return this; + } +} diff --git a/test/language/statements/class/err-method-delete-err-delete-call-expression-private-method-gen.js b/test/language/statements/class/err-method-delete-err-delete-call-expression-private-method-gen.js new file mode 100644 index 0000000000..55b4d53587 --- /dev/null +++ b/test/language/statements/class/err-method-delete-err-delete-call-expression-private-method-gen.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-decl-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + var g = this.f; + delete g().#m; + } + + f() { + return this; + } +} diff --git a/test/language/statements/class/err-method-delete-err-delete-call-expression-private-method.js b/test/language/statements/class/err-method-delete-err-delete-call-expression-private-method.js new file mode 100644 index 0000000000..ecc7f9b202 --- /dev/null +++ b/test/language/statements/class/err-method-delete-err-delete-call-expression-private-method.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method.case +// - src/class-elements/delete-error/cls-decl-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + var g = this.f; + delete g().#m; + } + + f() { + return this; + } +} diff --git a/test/language/statements/class/err-method-delete-err-delete-call-expression-privatename.js b/test/language/statements/class/err-method-delete-err-delete-call-expression-privatename.js new file mode 100644 index 0000000000..b421f815ed --- /dev/null +++ b/test/language/statements/class/err-method-delete-err-delete-call-expression-privatename.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-privatename.case +// - src/class-elements/delete-error/cls-decl-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + var g = this.f; + delete g().#x; + } + + f() { + return this; + } +} diff --git a/test/language/statements/class/err-method-delete-err-delete-member-expression-private-method-async-gen.js b/test/language/statements/class/err-method-delete-err-delete-member-expression-private-method-async-gen.js new file mode 100644 index 0000000000..5134a0f20f --- /dev/null +++ b/test/language/statements/class/err-method-delete-err-delete-member-expression-private-method-async-gen.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-decl-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + + delete this.#m +; + } + + +} diff --git a/test/language/statements/class/err-method-delete-err-delete-member-expression-private-method-async.js b/test/language/statements/class/err-method-delete-err-delete-member-expression-private-method-async.js new file mode 100644 index 0000000000..93ee42b635 --- /dev/null +++ b/test/language/statements/class/err-method-delete-err-delete-member-expression-private-method-async.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async.case +// - src/class-elements/delete-error/cls-decl-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + + delete this.#m +; + } + + +} diff --git a/test/language/statements/class/err-method-delete-err-delete-member-expression-private-method-gen.js b/test/language/statements/class/err-method-delete-err-delete-member-expression-private-method-gen.js new file mode 100644 index 0000000000..89778cdb82 --- /dev/null +++ b/test/language/statements/class/err-method-delete-err-delete-member-expression-private-method-gen.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-decl-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + + delete this.#m +; + } + + +} diff --git a/test/language/statements/class/err-method-delete-err-delete-member-expression-private-method.js b/test/language/statements/class/err-method-delete-err-delete-member-expression-private-method.js new file mode 100644 index 0000000000..fb80c5dab0 --- /dev/null +++ b/test/language/statements/class/err-method-delete-err-delete-member-expression-private-method.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method.case +// - src/class-elements/delete-error/cls-decl-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + + delete this.#m +; + } + + +} diff --git a/test/language/statements/class/err-method-delete-err-delete-member-expression-privatename.js b/test/language/statements/class/err-method-delete-err-delete-member-expression-privatename.js new file mode 100644 index 0000000000..be5718eea8 --- /dev/null +++ b/test/language/statements/class/err-method-delete-err-delete-member-expression-privatename.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-privatename.case +// - src/class-elements/delete-error/cls-decl-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + + delete this.#x; + } + + +} diff --git a/test/language/statements/class/err-method-delete-twice-covered-err-delete-call-expression-private-method-async-gen.js b/test/language/statements/class/err-method-delete-twice-covered-err-delete-call-expression-private-method-async-gen.js new file mode 100644 index 0000000000..40395fc2e4 --- /dev/null +++ b/test/language/statements/class/err-method-delete-twice-covered-err-delete-call-expression-private-method-async-gen.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-decl-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + var g = this.f; + delete ((g().#m)); + } + + f() { + return this; + } +} diff --git a/test/language/statements/class/err-method-delete-twice-covered-err-delete-call-expression-private-method-async.js b/test/language/statements/class/err-method-delete-twice-covered-err-delete-call-expression-private-method-async.js new file mode 100644 index 0000000000..aa05660900 --- /dev/null +++ b/test/language/statements/class/err-method-delete-twice-covered-err-delete-call-expression-private-method-async.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async.case +// - src/class-elements/delete-error/cls-decl-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + var g = this.f; + delete ((g().#m)); + } + + f() { + return this; + } +} diff --git a/test/language/statements/class/err-method-delete-twice-covered-err-delete-call-expression-private-method-gen.js b/test/language/statements/class/err-method-delete-twice-covered-err-delete-call-expression-private-method-gen.js new file mode 100644 index 0000000000..90b4f748ce --- /dev/null +++ b/test/language/statements/class/err-method-delete-twice-covered-err-delete-call-expression-private-method-gen.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-decl-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + var g = this.f; + delete ((g().#m)); + } + + f() { + return this; + } +} diff --git a/test/language/statements/class/err-method-delete-twice-covered-err-delete-call-expression-private-method.js b/test/language/statements/class/err-method-delete-twice-covered-err-delete-call-expression-private-method.js new file mode 100644 index 0000000000..be245a2f20 --- /dev/null +++ b/test/language/statements/class/err-method-delete-twice-covered-err-delete-call-expression-private-method.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method.case +// - src/class-elements/delete-error/cls-decl-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + var g = this.f; + delete ((g().#m)); + } + + f() { + return this; + } +} diff --git a/test/language/statements/class/err-method-delete-twice-covered-err-delete-call-expression-privatename.js b/test/language/statements/class/err-method-delete-twice-covered-err-delete-call-expression-privatename.js new file mode 100644 index 0000000000..2c5dfccc53 --- /dev/null +++ b/test/language/statements/class/err-method-delete-twice-covered-err-delete-call-expression-privatename.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-privatename.case +// - src/class-elements/delete-error/cls-decl-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-fields-public] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + var g = this.f; + delete ((g().#x)); + } + + f() { + return this; + } +} diff --git a/test/language/statements/class/err-method-delete-twice-covered-err-delete-member-expression-private-method-async-gen.js b/test/language/statements/class/err-method-delete-twice-covered-err-delete-member-expression-private-method-async-gen.js new file mode 100644 index 0000000000..acf546aeb2 --- /dev/null +++ b/test/language/statements/class/err-method-delete-twice-covered-err-delete-member-expression-private-method-async-gen.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-decl-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + + delete ((this.#m +)); + } + + +} diff --git a/test/language/statements/class/err-method-delete-twice-covered-err-delete-member-expression-private-method-async.js b/test/language/statements/class/err-method-delete-twice-covered-err-delete-member-expression-private-method-async.js new file mode 100644 index 0000000000..14cb0d8dad --- /dev/null +++ b/test/language/statements/class/err-method-delete-twice-covered-err-delete-member-expression-private-method-async.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async.case +// - src/class-elements/delete-error/cls-decl-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + + delete ((this.#m +)); + } + + +} diff --git a/test/language/statements/class/err-method-delete-twice-covered-err-delete-member-expression-private-method-gen.js b/test/language/statements/class/err-method-delete-twice-covered-err-delete-member-expression-private-method-gen.js new file mode 100644 index 0000000000..31d38e2a13 --- /dev/null +++ b/test/language/statements/class/err-method-delete-twice-covered-err-delete-member-expression-private-method-gen.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-decl-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + + delete ((this.#m +)); + } + + +} diff --git a/test/language/statements/class/err-method-delete-twice-covered-err-delete-member-expression-private-method.js b/test/language/statements/class/err-method-delete-twice-covered-err-delete-member-expression-private-method.js new file mode 100644 index 0000000000..9434bec4e0 --- /dev/null +++ b/test/language/statements/class/err-method-delete-twice-covered-err-delete-member-expression-private-method.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method.case +// - src/class-elements/delete-error/cls-decl-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + + delete ((this.#m +)); + } + + +} diff --git a/test/language/statements/class/err-method-delete-twice-covered-err-delete-member-expression-privatename.js b/test/language/statements/class/err-method-delete-twice-covered-err-delete-member-expression-privatename.js new file mode 100644 index 0000000000..4d4678d440 --- /dev/null +++ b/test/language/statements/class/err-method-delete-twice-covered-err-delete-member-expression-privatename.js @@ -0,0 +1,43 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-privatename.case +// - src/class-elements/delete-error/cls-decl-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +throw "Test262: This statement should not be evaluated."; + +class C { + #x; + + x() { + + delete ((this.#x)); + } + + +}