From 72945e041275eed1d9ba40a96ecf0a9d24d1a617 Mon Sep 17 00:00:00 2001 From: Caio Lima Date: Wed, 22 May 2019 18:58:09 +0200 Subject: [PATCH] Adding test cases to cover usage of private methods and accessors on inner classes. (#2150) --- .../private-getter-on-nested-class.case | 33 ++++++++++++ ...ter-shadowed-by-field-on-nested-class.case | 41 +++++++++++++++ ...er-shadowed-by-getter-on-nested-class.case | 41 +++++++++++++++ ...er-shadowed-by-method-on-nested-class.case | 38 ++++++++++++++ ...er-shadowed-by-setter-on-nested-class.case | 46 +++++++++++++++++ .../private-method-on-nested-class.case | 33 ++++++++++++ ...hod-shadowed-by-field-on-nested-class.case | 41 +++++++++++++++ ...od-shadowed-by-getter-on-nested-class.case | 41 +++++++++++++++ ...od-shadowed-by-setter-on-nested-class.case | 46 +++++++++++++++++ ...ivate-method-shadowed-on-nested-class.case | 35 +++++++++++++ .../private-setter-on-nested-class.case | 34 +++++++++++++ ...ter-shadowed-by-field-on-nested-class.case | 48 +++++++++++++++++ ...er-shadowed-by-getter-on-nested-class.case | 47 +++++++++++++++++ ...er-shadowed-by-method-on-nested-class.case | 47 +++++++++++++++++ ...er-shadowed-by-setter-on-nested-class.case | 46 +++++++++++++++++ .../private-getter-on-nested-class.js | 36 +++++++++++++ ...etter-shadowed-by-field-on-nested-class.js | 44 ++++++++++++++++ ...tter-shadowed-by-getter-on-nested-class.js | 44 ++++++++++++++++ ...tter-shadowed-by-method-on-nested-class.js | 41 +++++++++++++++ ...tter-shadowed-by-setter-on-nested-class.js | 49 ++++++++++++++++++ .../private-method-on-nested-class.js | 36 +++++++++++++ ...ethod-shadowed-by-field-on-nested-class.js | 44 ++++++++++++++++ ...thod-shadowed-by-getter-on-nested-class.js | 44 ++++++++++++++++ ...thod-shadowed-by-setter-on-nested-class.js | 49 ++++++++++++++++++ ...private-method-shadowed-on-nested-class.js | 38 ++++++++++++++ .../private-setter-on-nested-class.js | 37 ++++++++++++++ ...etter-shadowed-by-field-on-nested-class.js | 51 +++++++++++++++++++ ...tter-shadowed-by-getter-on-nested-class.js | 50 ++++++++++++++++++ ...tter-shadowed-by-method-on-nested-class.js | 50 ++++++++++++++++++ ...tter-shadowed-by-setter-on-nested-class.js | 49 ++++++++++++++++++ .../private-getter-on-nested-class.js | 36 +++++++++++++ ...etter-shadowed-by-field-on-nested-class.js | 44 ++++++++++++++++ ...tter-shadowed-by-getter-on-nested-class.js | 44 ++++++++++++++++ ...tter-shadowed-by-method-on-nested-class.js | 41 +++++++++++++++ ...tter-shadowed-by-setter-on-nested-class.js | 49 ++++++++++++++++++ .../private-method-on-nested-class.js | 36 +++++++++++++ ...ethod-shadowed-by-field-on-nested-class.js | 44 ++++++++++++++++ ...thod-shadowed-by-getter-on-nested-class.js | 44 ++++++++++++++++ ...thod-shadowed-by-setter-on-nested-class.js | 49 ++++++++++++++++++ ...private-method-shadowed-on-nested-class.js | 38 ++++++++++++++ .../private-setter-on-nested-class.js | 37 ++++++++++++++ ...etter-shadowed-by-field-on-nested-class.js | 51 +++++++++++++++++++ ...tter-shadowed-by-getter-on-nested-class.js | 50 ++++++++++++++++++ ...tter-shadowed-by-method-on-nested-class.js | 50 ++++++++++++++++++ ...tter-shadowed-by-setter-on-nested-class.js | 49 ++++++++++++++++++ 45 files changed, 1941 insertions(+) create mode 100644 src/class-elements/private-getter-on-nested-class.case create mode 100644 src/class-elements/private-getter-shadowed-by-field-on-nested-class.case create mode 100644 src/class-elements/private-getter-shadowed-by-getter-on-nested-class.case create mode 100644 src/class-elements/private-getter-shadowed-by-method-on-nested-class.case create mode 100644 src/class-elements/private-getter-shadowed-by-setter-on-nested-class.case create mode 100644 src/class-elements/private-method-on-nested-class.case create mode 100644 src/class-elements/private-method-shadowed-by-field-on-nested-class.case create mode 100644 src/class-elements/private-method-shadowed-by-getter-on-nested-class.case create mode 100644 src/class-elements/private-method-shadowed-by-setter-on-nested-class.case create mode 100644 src/class-elements/private-method-shadowed-on-nested-class.case create mode 100644 src/class-elements/private-setter-on-nested-class.case create mode 100644 src/class-elements/private-setter-shadowed-by-field-on-nested-class.case create mode 100644 src/class-elements/private-setter-shadowed-by-getter-on-nested-class.case create mode 100644 src/class-elements/private-setter-shadowed-by-method-on-nested-class.case create mode 100644 src/class-elements/private-setter-shadowed-by-setter-on-nested-class.case create mode 100644 test/language/expressions/class/elements/private-getter-on-nested-class.js create mode 100644 test/language/expressions/class/elements/private-getter-shadowed-by-field-on-nested-class.js create mode 100644 test/language/expressions/class/elements/private-getter-shadowed-by-getter-on-nested-class.js create mode 100644 test/language/expressions/class/elements/private-getter-shadowed-by-method-on-nested-class.js create mode 100644 test/language/expressions/class/elements/private-getter-shadowed-by-setter-on-nested-class.js create mode 100644 test/language/expressions/class/elements/private-method-on-nested-class.js create mode 100644 test/language/expressions/class/elements/private-method-shadowed-by-field-on-nested-class.js create mode 100644 test/language/expressions/class/elements/private-method-shadowed-by-getter-on-nested-class.js create mode 100644 test/language/expressions/class/elements/private-method-shadowed-by-setter-on-nested-class.js create mode 100644 test/language/expressions/class/elements/private-method-shadowed-on-nested-class.js create mode 100644 test/language/expressions/class/elements/private-setter-on-nested-class.js create mode 100644 test/language/expressions/class/elements/private-setter-shadowed-by-field-on-nested-class.js create mode 100644 test/language/expressions/class/elements/private-setter-shadowed-by-getter-on-nested-class.js create mode 100644 test/language/expressions/class/elements/private-setter-shadowed-by-method-on-nested-class.js create mode 100644 test/language/expressions/class/elements/private-setter-shadowed-by-setter-on-nested-class.js create mode 100644 test/language/statements/class/elements/private-getter-on-nested-class.js create mode 100644 test/language/statements/class/elements/private-getter-shadowed-by-field-on-nested-class.js create mode 100644 test/language/statements/class/elements/private-getter-shadowed-by-getter-on-nested-class.js create mode 100644 test/language/statements/class/elements/private-getter-shadowed-by-method-on-nested-class.js create mode 100644 test/language/statements/class/elements/private-getter-shadowed-by-setter-on-nested-class.js create mode 100644 test/language/statements/class/elements/private-method-on-nested-class.js create mode 100644 test/language/statements/class/elements/private-method-shadowed-by-field-on-nested-class.js create mode 100644 test/language/statements/class/elements/private-method-shadowed-by-getter-on-nested-class.js create mode 100644 test/language/statements/class/elements/private-method-shadowed-by-setter-on-nested-class.js create mode 100644 test/language/statements/class/elements/private-method-shadowed-on-nested-class.js create mode 100644 test/language/statements/class/elements/private-setter-on-nested-class.js create mode 100644 test/language/statements/class/elements/private-setter-shadowed-by-field-on-nested-class.js create mode 100644 test/language/statements/class/elements/private-setter-shadowed-by-getter-on-nested-class.js create mode 100644 test/language/statements/class/elements/private-setter-shadowed-by-method-on-nested-class.js create mode 100644 test/language/statements/class/elements/private-setter-shadowed-by-setter-on-nested-class.js diff --git a/src/class-elements/private-getter-on-nested-class.case b/src/class-elements/private-getter-on-nested-class.case new file mode 100644 index 0000000000..6f5a58a9e0 --- /dev/null +++ b/src/class-elements/private-getter-on-nested-class.case @@ -0,0 +1,33 @@ +// Copyright (C) 2019 Caio Lima (Igalia SL). All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +desc: PrivateName of private getter is available on inner classes +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +template: default +features: [class-methods-private, class-fields-public] +---*/ + +//- elements +get #m() { return 'test262'; } + +B = class { + method(o) { + return o.#m; + } +} +//- assertions +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(c), 'test262'); diff --git a/src/class-elements/private-getter-shadowed-by-field-on-nested-class.case b/src/class-elements/private-getter-shadowed-by-field-on-nested-class.case new file mode 100644 index 0000000000..f2531298eb --- /dev/null +++ b/src/class-elements/private-getter-shadowed-by-field-on-nested-class.case @@ -0,0 +1,41 @@ +// Copyright (C) 2019 Caio Lima (Igalia SL). All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +desc: PrivateName of private getter can be shadowed on inner classes by a private field +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +template: default +features: [class-methods-private, class-fields-private, class-fields-public] +---*/ + +//- elements +get #m() { return 'outer class'; } + +method() { return this.#m; } + +B = class { + method(o) { + return o.#m; + } + + #m = 'test262'; +} +//- assertions +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(innerB), 'test262'); +assert.sameValue(c.method(), 'outer class'); +assert.throws(TypeError, function() { + innerB.method(c); +}, 'accessed inner class field from an object of outer class'); diff --git a/src/class-elements/private-getter-shadowed-by-getter-on-nested-class.case b/src/class-elements/private-getter-shadowed-by-getter-on-nested-class.case new file mode 100644 index 0000000000..1e234fb706 --- /dev/null +++ b/src/class-elements/private-getter-shadowed-by-getter-on-nested-class.case @@ -0,0 +1,41 @@ +// Copyright (C) 2019 Caio Lima (Igalia SL). All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +desc: PrivateName of private getter can be shadowed on inner classes by a private getter +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +template: default +features: [class-methods-private, class-fields-public] +---*/ + +//- elements +get #m() { return 'outer class'; } + +method() { return this.#m; } + +B = class { + method(o) { + return o.#m; + } + + get #m() { return 'test262'; } +} +//- assertions +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(innerB), 'test262'); +assert.sameValue(c.method(), 'outer class'); +assert.throws(TypeError, function() { + innerB.method(c); +}, 'accessed inner class getter from an object of outer class'); diff --git a/src/class-elements/private-getter-shadowed-by-method-on-nested-class.case b/src/class-elements/private-getter-shadowed-by-method-on-nested-class.case new file mode 100644 index 0000000000..73332488a5 --- /dev/null +++ b/src/class-elements/private-getter-shadowed-by-method-on-nested-class.case @@ -0,0 +1,38 @@ +// Copyright (C) 2019 Caio Lima (Igalia SL). All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +desc: PrivateName of private getter can be shadowed on inner class by a private method +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +template: default +features: [class-methods-private, class-fields-public] +---*/ + +//- elements +get #m() { throw new Test262Error(); } + +B = class { + method(o) { + return o.#m(); + } + + #m() { return 'test262'; } +} +//- assertions +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(innerB), 'test262'); +assert.throws(TypeError, function() { + innerB.method(c); +}, 'accessed inner class method from an object of outer class'); diff --git a/src/class-elements/private-getter-shadowed-by-setter-on-nested-class.case b/src/class-elements/private-getter-shadowed-by-setter-on-nested-class.case new file mode 100644 index 0000000000..2229fab76b --- /dev/null +++ b/src/class-elements/private-getter-shadowed-by-setter-on-nested-class.case @@ -0,0 +1,46 @@ +// Copyright (C) 2019 Caio Lima (Igalia SL). All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +desc: PrivateName of private getter can be shadowed on inner classes by a private setter +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +template: default +features: [class-methods-private, class-fields-public] +---*/ + +//- elements +get #m() { return 'outer class'; } + +method() { return this.#m; } + +B = class { + method(o) { + return o.#m; + } + + set #m(v) { this._v = v; } +} +//- assertions +let c = new C(); +let innerB = new c.B(); + +assert.throws(TypeError, function() { + innerB.method(innerB); +}, '[[Get]] operation of an accessor without getter'); + +assert.sameValue(c.method(), 'outer class'); + +assert.throws(TypeError, function() { + innerB.method(c); +}, 'access of inner class accessor from an object of outer class'); diff --git a/src/class-elements/private-method-on-nested-class.case b/src/class-elements/private-method-on-nested-class.case new file mode 100644 index 0000000000..73bfe056cf --- /dev/null +++ b/src/class-elements/private-method-on-nested-class.case @@ -0,0 +1,33 @@ +// Copyright (C) 2019 Caio Lima (Igalia SL). All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +desc: PrivateName of private method is available on inner classes +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +template: default +features: [class-methods-private, class-fields-public] +---*/ + +//- elements +#m() { return 'test262'; } + +B = class { + method(o) { + return o.#m(); + } +} +//- assertions +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(c), 'test262'); diff --git a/src/class-elements/private-method-shadowed-by-field-on-nested-class.case b/src/class-elements/private-method-shadowed-by-field-on-nested-class.case new file mode 100644 index 0000000000..3088e3b1d1 --- /dev/null +++ b/src/class-elements/private-method-shadowed-by-field-on-nested-class.case @@ -0,0 +1,41 @@ +// Copyright (C) 2019 Caio Lima (Igalia SL). All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +desc: PrivateName of private method can be shadowed on inner classes by a private field +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +template: default +features: [class-methods-private, class-fields-private, class-fields-public] +---*/ + +//- elements +#m() { return 'outer class'; } + +method() { return this.#m(); } + +B = class { + method(o) { + return o.#m; + } + + #m = 'test262'; +} +//- assertions +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(innerB), 'test262'); +assert.sameValue(c.method(), 'outer class'); +assert.throws(TypeError, function() { + innerB.method(c); +}, 'accessed inner class field from an object of outer class'); diff --git a/src/class-elements/private-method-shadowed-by-getter-on-nested-class.case b/src/class-elements/private-method-shadowed-by-getter-on-nested-class.case new file mode 100644 index 0000000000..2a839cf836 --- /dev/null +++ b/src/class-elements/private-method-shadowed-by-getter-on-nested-class.case @@ -0,0 +1,41 @@ +// Copyright (C) 2019 Caio Lima (Igalia SL). All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +desc: PrivateName of private method can be shadowed on inner classes by a private getter +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +template: default +features: [class-methods-private, class-fields-public] +---*/ + +//- elements +#m() { return 'outer class'; } + +method() { return this.#m(); } + +B = class { + method(o) { + return o.#m; + } + + get #m() { return 'test262'; } +} +//- assertions +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(innerB), 'test262'); +assert.sameValue(c.method(), 'outer class'); +assert.throws(TypeError, function() { + innerB.method(c); +}, 'accessed inner class getter from an object of outer class'); diff --git a/src/class-elements/private-method-shadowed-by-setter-on-nested-class.case b/src/class-elements/private-method-shadowed-by-setter-on-nested-class.case new file mode 100644 index 0000000000..111db68bf6 --- /dev/null +++ b/src/class-elements/private-method-shadowed-by-setter-on-nested-class.case @@ -0,0 +1,46 @@ +// Copyright (C) 2019 Caio Lima (Igalia SL). All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +desc: PrivateName of private method can be shadowed on inner classes by a private setter +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +template: default +features: [class-methods-private, class-fields-public] +---*/ + +//- elements +#m() { return 'outer class'; } + +method() { return this.#m(); } + +B = class { + method(o) { + return o.#m; + } + + set #m(v) { this._v = v; } +} +//- assertions +let c = new C(); +let innerB = new c.B(); + +assert.throws(TypeError, function() { + innerB.method(innerB); +}, '[[Get]] operation of an accessor without getter'); + +assert.sameValue(c.method(), 'outer class'); + +assert.throws(TypeError, function() { + innerB.method(c); +}, 'access of inner class accessor from an object of outer class'); diff --git a/src/class-elements/private-method-shadowed-on-nested-class.case b/src/class-elements/private-method-shadowed-on-nested-class.case new file mode 100644 index 0000000000..aecd0e50ec --- /dev/null +++ b/src/class-elements/private-method-shadowed-on-nested-class.case @@ -0,0 +1,35 @@ +// Copyright (C) 2019 Caio Lima (Igalia SL). All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +desc: PrivateName of private method can be shadowed by inner class private method +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +template: default +features: [class-methods-private, class-fields-public] +---*/ + +//- elements +#m() { throw new Test262Error(); } + +B = class { + method() { + return this.#m(); + } + + #m() { return 'test262'; } +} +//- assertions +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(), 'test262'); diff --git a/src/class-elements/private-setter-on-nested-class.case b/src/class-elements/private-setter-on-nested-class.case new file mode 100644 index 0000000000..7de1ed4e45 --- /dev/null +++ b/src/class-elements/private-setter-on-nested-class.case @@ -0,0 +1,34 @@ +// Copyright (C) 2019 Caio Lima (Igalia SL). All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +desc: PrivateName of private setter is available on inner classes +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +template: default +features: [class-methods-private, class-fields-public] +---*/ + +//- elements +set #m(v) { this._v = v; } + +B = class { + method(o, v) { + o.#m = v; + } +} +//- assertions +let c = new C(); +let innerB = new c.B(); +innerB.method(c, 'test262'); +assert.sameValue(c._v, 'test262'); diff --git a/src/class-elements/private-setter-shadowed-by-field-on-nested-class.case b/src/class-elements/private-setter-shadowed-by-field-on-nested-class.case new file mode 100644 index 0000000000..8c5c00dc21 --- /dev/null +++ b/src/class-elements/private-setter-shadowed-by-field-on-nested-class.case @@ -0,0 +1,48 @@ +// Copyright (C) 2019 Caio Lima (Igalia SL). All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +desc: PrivateName of private setter can be shadowed on inner classes by a private field +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +template: default +features: [class-methods-private, class-fields-private, class-fields-public] +---*/ + +//- elements +set #m(v) { this._v = v; } + +method(v) { this.#m = v; } + +B = class { + method(o, v) { + o.#m = v; + } + + get m() { return this.#m; } + + #m; +} +//- assertions +let c = new C(); +let innerB = new c.B(); + +innerB.method(innerB, 'test262'); +assert.sameValue(innerB.m, 'test262'); + +c.method('outer class'); +assert.sameValue(c._v, 'outer class'); + +assert.throws(TypeError, function() { + innerB.method(c, 'foo'); +}, 'accessed inner class field from an object of outer class'); diff --git a/src/class-elements/private-setter-shadowed-by-getter-on-nested-class.case b/src/class-elements/private-setter-shadowed-by-getter-on-nested-class.case new file mode 100644 index 0000000000..0ee5b6bdb8 --- /dev/null +++ b/src/class-elements/private-setter-shadowed-by-getter-on-nested-class.case @@ -0,0 +1,47 @@ +// Copyright (C) 2019 Caio Lima (Igalia SL). All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +desc: PrivateName of private setter can be shadowed on inner classes by a private getter +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +template: default +features: [class-methods-private, class-fields-public] +---*/ + +//- elements +set #m(v) { this._v = v; } + +method(v) { this.#m = v; } + +B = class { + method(o, v) { + o.#m = v; + } + + get #m() { return 'test262'; } +} +//- assertions +let c = new C(); +let innerB = new c.B(); + +assert.throws(TypeError, function() { + innerB.method(innerB); +}, 'invalid [[Set]] of an acessor without setter'); + +c.method('outer class'); +assert.sameValue(c._v, 'outer class'); + +assert.throws(TypeError, function() { + innerB.method(c); +}, 'invalid access of inner class getter from an object of outer class'); diff --git a/src/class-elements/private-setter-shadowed-by-method-on-nested-class.case b/src/class-elements/private-setter-shadowed-by-method-on-nested-class.case new file mode 100644 index 0000000000..931167e92a --- /dev/null +++ b/src/class-elements/private-setter-shadowed-by-method-on-nested-class.case @@ -0,0 +1,47 @@ +// Copyright (C) 2019 Caio Lima (Igalia SL). All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +desc: PrivateName of private setter can be shadowed on inner class by a private method +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +template: default +features: [class-methods-private, class-fields-public] +---*/ + +//- elements +set #m(v) { this._v = v; } + +method(v) { this.#m = v; } + +B = class { + method(o, v) { + o.#m = v; + } + + #m() { return 'test262'; } +} +//- assertions +let c = new C(); +let innerB = new c.B(); + +assert.throws(TypeError, function() { + innerB.method(innerB, 'foo'); +}, 'invalid [[Set]] operation in a private method'); + +c.method('outer class'); +assert.sameValue(c._v, 'outer class'); + +assert.throws(TypeError, function() { + innerB.method(c); +}, 'invalid access of inner class method from an object of outer class'); diff --git a/src/class-elements/private-setter-shadowed-by-setter-on-nested-class.case b/src/class-elements/private-setter-shadowed-by-setter-on-nested-class.case new file mode 100644 index 0000000000..40a6b89618 --- /dev/null +++ b/src/class-elements/private-setter-shadowed-by-setter-on-nested-class.case @@ -0,0 +1,46 @@ +// Copyright (C) 2019 Caio Lima (Igalia SL). All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +desc: PrivateName of private setter can be shadowed on inner classes by a private setter +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +template: default +features: [class-methods-private, class-fields-public] +---*/ + +//- elements +set #m(v) { this._v = v; } + +method(v) { this.#m = v; } + +B = class { + method(o, v) { + o.#m = v; + } + + set #m(v) { this._v = v; } +} +//- assertions +let c = new C(); +let innerB = new c.B(); + +innerB.method(innerB, 'test262'); +assert.sameValue(innerB._v, 'test262'); + +c.method('outer class'); +assert.sameValue(c._v, 'outer class'); + +assert.throws(TypeError, function() { + innerB.method(c, 'foo'); +}, 'access of inner class accessor from an object of outer class'); diff --git a/test/language/expressions/class/elements/private-getter-on-nested-class.js b/test/language/expressions/class/elements/private-getter-on-nested-class.js new file mode 100644 index 0000000000..8ae98d9a9d --- /dev/null +++ b/test/language/expressions/class/elements/private-getter-on-nested-class.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-getter-on-nested-class.case +// - src/class-elements/default/cls-expr.template +/*--- +description: PrivateName of private getter is available on inner classes (field definitions in a class expression) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +var C = class { + get #m() { return 'test262'; } + + B = class { + method(o) { + return o.#m; + } + } +} + +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(c), 'test262'); diff --git a/test/language/expressions/class/elements/private-getter-shadowed-by-field-on-nested-class.js b/test/language/expressions/class/elements/private-getter-shadowed-by-field-on-nested-class.js new file mode 100644 index 0000000000..44853d1a13 --- /dev/null +++ b/test/language/expressions/class/elements/private-getter-shadowed-by-field-on-nested-class.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-getter-shadowed-by-field-on-nested-class.case +// - src/class-elements/default/cls-expr.template +/*--- +description: PrivateName of private getter can be shadowed on inner classes by a private field (field definitions in a class expression) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +var C = class { + get #m() { return 'outer class'; } + + method() { return this.#m; } + + B = class { + method(o) { + return o.#m; + } + + #m = 'test262'; + } +} + +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(innerB), 'test262'); +assert.sameValue(c.method(), 'outer class'); +assert.throws(TypeError, function() { + innerB.method(c); +}, 'accessed inner class field from an object of outer class'); diff --git a/test/language/expressions/class/elements/private-getter-shadowed-by-getter-on-nested-class.js b/test/language/expressions/class/elements/private-getter-shadowed-by-getter-on-nested-class.js new file mode 100644 index 0000000000..d6822fc25d --- /dev/null +++ b/test/language/expressions/class/elements/private-getter-shadowed-by-getter-on-nested-class.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-getter-shadowed-by-getter-on-nested-class.case +// - src/class-elements/default/cls-expr.template +/*--- +description: PrivateName of private getter can be shadowed on inner classes by a private getter (field definitions in a class expression) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +var C = class { + get #m() { return 'outer class'; } + + method() { return this.#m; } + + B = class { + method(o) { + return o.#m; + } + + get #m() { return 'test262'; } + } +} + +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(innerB), 'test262'); +assert.sameValue(c.method(), 'outer class'); +assert.throws(TypeError, function() { + innerB.method(c); +}, 'accessed inner class getter from an object of outer class'); diff --git a/test/language/expressions/class/elements/private-getter-shadowed-by-method-on-nested-class.js b/test/language/expressions/class/elements/private-getter-shadowed-by-method-on-nested-class.js new file mode 100644 index 0000000000..899db7a5fd --- /dev/null +++ b/test/language/expressions/class/elements/private-getter-shadowed-by-method-on-nested-class.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-getter-shadowed-by-method-on-nested-class.case +// - src/class-elements/default/cls-expr.template +/*--- +description: PrivateName of private getter can be shadowed on inner class by a private method (field definitions in a class expression) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +var C = class { + get #m() { throw new Test262Error(); } + + B = class { + method(o) { + return o.#m(); + } + + #m() { return 'test262'; } + } +} + +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(innerB), 'test262'); +assert.throws(TypeError, function() { + innerB.method(c); +}, 'accessed inner class method from an object of outer class'); diff --git a/test/language/expressions/class/elements/private-getter-shadowed-by-setter-on-nested-class.js b/test/language/expressions/class/elements/private-getter-shadowed-by-setter-on-nested-class.js new file mode 100644 index 0000000000..c146291605 --- /dev/null +++ b/test/language/expressions/class/elements/private-getter-shadowed-by-setter-on-nested-class.js @@ -0,0 +1,49 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-getter-shadowed-by-setter-on-nested-class.case +// - src/class-elements/default/cls-expr.template +/*--- +description: PrivateName of private getter can be shadowed on inner classes by a private setter (field definitions in a class expression) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +var C = class { + get #m() { return 'outer class'; } + + method() { return this.#m; } + + B = class { + method(o) { + return o.#m; + } + + set #m(v) { this._v = v; } + } +} + +let c = new C(); +let innerB = new c.B(); + +assert.throws(TypeError, function() { + innerB.method(innerB); +}, '[[Get]] operation of an accessor without getter'); + +assert.sameValue(c.method(), 'outer class'); + +assert.throws(TypeError, function() { + innerB.method(c); +}, 'access of inner class accessor from an object of outer class'); diff --git a/test/language/expressions/class/elements/private-method-on-nested-class.js b/test/language/expressions/class/elements/private-method-on-nested-class.js new file mode 100644 index 0000000000..679bfdfc2d --- /dev/null +++ b/test/language/expressions/class/elements/private-method-on-nested-class.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-method-on-nested-class.case +// - src/class-elements/default/cls-expr.template +/*--- +description: PrivateName of private method is available on inner classes (field definitions in a class expression) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +var C = class { + #m() { return 'test262'; } + + B = class { + method(o) { + return o.#m(); + } + } +} + +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(c), 'test262'); diff --git a/test/language/expressions/class/elements/private-method-shadowed-by-field-on-nested-class.js b/test/language/expressions/class/elements/private-method-shadowed-by-field-on-nested-class.js new file mode 100644 index 0000000000..4c5888c161 --- /dev/null +++ b/test/language/expressions/class/elements/private-method-shadowed-by-field-on-nested-class.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-method-shadowed-by-field-on-nested-class.case +// - src/class-elements/default/cls-expr.template +/*--- +description: PrivateName of private method can be shadowed on inner classes by a private field (field definitions in a class expression) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +var C = class { + #m() { return 'outer class'; } + + method() { return this.#m(); } + + B = class { + method(o) { + return o.#m; + } + + #m = 'test262'; + } +} + +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(innerB), 'test262'); +assert.sameValue(c.method(), 'outer class'); +assert.throws(TypeError, function() { + innerB.method(c); +}, 'accessed inner class field from an object of outer class'); diff --git a/test/language/expressions/class/elements/private-method-shadowed-by-getter-on-nested-class.js b/test/language/expressions/class/elements/private-method-shadowed-by-getter-on-nested-class.js new file mode 100644 index 0000000000..b7053de512 --- /dev/null +++ b/test/language/expressions/class/elements/private-method-shadowed-by-getter-on-nested-class.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-method-shadowed-by-getter-on-nested-class.case +// - src/class-elements/default/cls-expr.template +/*--- +description: PrivateName of private method can be shadowed on inner classes by a private getter (field definitions in a class expression) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +var C = class { + #m() { return 'outer class'; } + + method() { return this.#m(); } + + B = class { + method(o) { + return o.#m; + } + + get #m() { return 'test262'; } + } +} + +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(innerB), 'test262'); +assert.sameValue(c.method(), 'outer class'); +assert.throws(TypeError, function() { + innerB.method(c); +}, 'accessed inner class getter from an object of outer class'); diff --git a/test/language/expressions/class/elements/private-method-shadowed-by-setter-on-nested-class.js b/test/language/expressions/class/elements/private-method-shadowed-by-setter-on-nested-class.js new file mode 100644 index 0000000000..849b6683df --- /dev/null +++ b/test/language/expressions/class/elements/private-method-shadowed-by-setter-on-nested-class.js @@ -0,0 +1,49 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-method-shadowed-by-setter-on-nested-class.case +// - src/class-elements/default/cls-expr.template +/*--- +description: PrivateName of private method can be shadowed on inner classes by a private setter (field definitions in a class expression) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +var C = class { + #m() { return 'outer class'; } + + method() { return this.#m(); } + + B = class { + method(o) { + return o.#m; + } + + set #m(v) { this._v = v; } + } +} + +let c = new C(); +let innerB = new c.B(); + +assert.throws(TypeError, function() { + innerB.method(innerB); +}, '[[Get]] operation of an accessor without getter'); + +assert.sameValue(c.method(), 'outer class'); + +assert.throws(TypeError, function() { + innerB.method(c); +}, 'access of inner class accessor from an object of outer class'); diff --git a/test/language/expressions/class/elements/private-method-shadowed-on-nested-class.js b/test/language/expressions/class/elements/private-method-shadowed-on-nested-class.js new file mode 100644 index 0000000000..524f527db8 --- /dev/null +++ b/test/language/expressions/class/elements/private-method-shadowed-on-nested-class.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-method-shadowed-on-nested-class.case +// - src/class-elements/default/cls-expr.template +/*--- +description: PrivateName of private method can be shadowed by inner class private method (field definitions in a class expression) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +var C = class { + #m() { throw new Test262Error(); } + + B = class { + method() { + return this.#m(); + } + + #m() { return 'test262'; } + } +} + +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(), 'test262'); diff --git a/test/language/expressions/class/elements/private-setter-on-nested-class.js b/test/language/expressions/class/elements/private-setter-on-nested-class.js new file mode 100644 index 0000000000..13bdc508c2 --- /dev/null +++ b/test/language/expressions/class/elements/private-setter-on-nested-class.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-setter-on-nested-class.case +// - src/class-elements/default/cls-expr.template +/*--- +description: PrivateName of private setter is available on inner classes (field definitions in a class expression) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +var C = class { + set #m(v) { this._v = v; } + + B = class { + method(o, v) { + o.#m = v; + } + } +} + +let c = new C(); +let innerB = new c.B(); +innerB.method(c, 'test262'); +assert.sameValue(c._v, 'test262'); diff --git a/test/language/expressions/class/elements/private-setter-shadowed-by-field-on-nested-class.js b/test/language/expressions/class/elements/private-setter-shadowed-by-field-on-nested-class.js new file mode 100644 index 0000000000..162c47ce46 --- /dev/null +++ b/test/language/expressions/class/elements/private-setter-shadowed-by-field-on-nested-class.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-setter-shadowed-by-field-on-nested-class.case +// - src/class-elements/default/cls-expr.template +/*--- +description: PrivateName of private setter can be shadowed on inner classes by a private field (field definitions in a class expression) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +var C = class { + set #m(v) { this._v = v; } + + method(v) { this.#m = v; } + + B = class { + method(o, v) { + o.#m = v; + } + + get m() { return this.#m; } + + #m; + } +} + +let c = new C(); +let innerB = new c.B(); + +innerB.method(innerB, 'test262'); +assert.sameValue(innerB.m, 'test262'); + +c.method('outer class'); +assert.sameValue(c._v, 'outer class'); + +assert.throws(TypeError, function() { + innerB.method(c, 'foo'); +}, 'accessed inner class field from an object of outer class'); diff --git a/test/language/expressions/class/elements/private-setter-shadowed-by-getter-on-nested-class.js b/test/language/expressions/class/elements/private-setter-shadowed-by-getter-on-nested-class.js new file mode 100644 index 0000000000..b1a4b3f34b --- /dev/null +++ b/test/language/expressions/class/elements/private-setter-shadowed-by-getter-on-nested-class.js @@ -0,0 +1,50 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-setter-shadowed-by-getter-on-nested-class.case +// - src/class-elements/default/cls-expr.template +/*--- +description: PrivateName of private setter can be shadowed on inner classes by a private getter (field definitions in a class expression) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +var C = class { + set #m(v) { this._v = v; } + + method(v) { this.#m = v; } + + B = class { + method(o, v) { + o.#m = v; + } + + get #m() { return 'test262'; } + } +} + +let c = new C(); +let innerB = new c.B(); + +assert.throws(TypeError, function() { + innerB.method(innerB); +}, 'invalid [[Set]] of an acessor without setter'); + +c.method('outer class'); +assert.sameValue(c._v, 'outer class'); + +assert.throws(TypeError, function() { + innerB.method(c); +}, 'invalid access of inner class getter from an object of outer class'); diff --git a/test/language/expressions/class/elements/private-setter-shadowed-by-method-on-nested-class.js b/test/language/expressions/class/elements/private-setter-shadowed-by-method-on-nested-class.js new file mode 100644 index 0000000000..6e54fda11a --- /dev/null +++ b/test/language/expressions/class/elements/private-setter-shadowed-by-method-on-nested-class.js @@ -0,0 +1,50 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-setter-shadowed-by-method-on-nested-class.case +// - src/class-elements/default/cls-expr.template +/*--- +description: PrivateName of private setter can be shadowed on inner class by a private method (field definitions in a class expression) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +var C = class { + set #m(v) { this._v = v; } + + method(v) { this.#m = v; } + + B = class { + method(o, v) { + o.#m = v; + } + + #m() { return 'test262'; } + } +} + +let c = new C(); +let innerB = new c.B(); + +assert.throws(TypeError, function() { + innerB.method(innerB, 'foo'); +}, 'invalid [[Set]] operation in a private method'); + +c.method('outer class'); +assert.sameValue(c._v, 'outer class'); + +assert.throws(TypeError, function() { + innerB.method(c); +}, 'invalid access of inner class method from an object of outer class'); diff --git a/test/language/expressions/class/elements/private-setter-shadowed-by-setter-on-nested-class.js b/test/language/expressions/class/elements/private-setter-shadowed-by-setter-on-nested-class.js new file mode 100644 index 0000000000..3ecebdfce9 --- /dev/null +++ b/test/language/expressions/class/elements/private-setter-shadowed-by-setter-on-nested-class.js @@ -0,0 +1,49 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-setter-shadowed-by-setter-on-nested-class.case +// - src/class-elements/default/cls-expr.template +/*--- +description: PrivateName of private setter can be shadowed on inner classes by a private setter (field definitions in a class expression) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +var C = class { + set #m(v) { this._v = v; } + + method(v) { this.#m = v; } + + B = class { + method(o, v) { + o.#m = v; + } + + set #m(v) { this._v = v; } + } +} + +let c = new C(); +let innerB = new c.B(); + +innerB.method(innerB, 'test262'); +assert.sameValue(innerB._v, 'test262'); + +c.method('outer class'); +assert.sameValue(c._v, 'outer class'); + +assert.throws(TypeError, function() { + innerB.method(c, 'foo'); +}, 'access of inner class accessor from an object of outer class'); diff --git a/test/language/statements/class/elements/private-getter-on-nested-class.js b/test/language/statements/class/elements/private-getter-on-nested-class.js new file mode 100644 index 0000000000..152368822f --- /dev/null +++ b/test/language/statements/class/elements/private-getter-on-nested-class.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-getter-on-nested-class.case +// - src/class-elements/default/cls-decl.template +/*--- +description: PrivateName of private getter is available on inner classes (field definitions in a class declaration) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +class C { + get #m() { return 'test262'; } + + B = class { + method(o) { + return o.#m; + } + } +} + +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(c), 'test262'); diff --git a/test/language/statements/class/elements/private-getter-shadowed-by-field-on-nested-class.js b/test/language/statements/class/elements/private-getter-shadowed-by-field-on-nested-class.js new file mode 100644 index 0000000000..ef7da46ccc --- /dev/null +++ b/test/language/statements/class/elements/private-getter-shadowed-by-field-on-nested-class.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-getter-shadowed-by-field-on-nested-class.case +// - src/class-elements/default/cls-decl.template +/*--- +description: PrivateName of private getter can be shadowed on inner classes by a private field (field definitions in a class declaration) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +class C { + get #m() { return 'outer class'; } + + method() { return this.#m; } + + B = class { + method(o) { + return o.#m; + } + + #m = 'test262'; + } +} + +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(innerB), 'test262'); +assert.sameValue(c.method(), 'outer class'); +assert.throws(TypeError, function() { + innerB.method(c); +}, 'accessed inner class field from an object of outer class'); diff --git a/test/language/statements/class/elements/private-getter-shadowed-by-getter-on-nested-class.js b/test/language/statements/class/elements/private-getter-shadowed-by-getter-on-nested-class.js new file mode 100644 index 0000000000..d7605389b7 --- /dev/null +++ b/test/language/statements/class/elements/private-getter-shadowed-by-getter-on-nested-class.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-getter-shadowed-by-getter-on-nested-class.case +// - src/class-elements/default/cls-decl.template +/*--- +description: PrivateName of private getter can be shadowed on inner classes by a private getter (field definitions in a class declaration) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +class C { + get #m() { return 'outer class'; } + + method() { return this.#m; } + + B = class { + method(o) { + return o.#m; + } + + get #m() { return 'test262'; } + } +} + +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(innerB), 'test262'); +assert.sameValue(c.method(), 'outer class'); +assert.throws(TypeError, function() { + innerB.method(c); +}, 'accessed inner class getter from an object of outer class'); diff --git a/test/language/statements/class/elements/private-getter-shadowed-by-method-on-nested-class.js b/test/language/statements/class/elements/private-getter-shadowed-by-method-on-nested-class.js new file mode 100644 index 0000000000..b65909eb97 --- /dev/null +++ b/test/language/statements/class/elements/private-getter-shadowed-by-method-on-nested-class.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-getter-shadowed-by-method-on-nested-class.case +// - src/class-elements/default/cls-decl.template +/*--- +description: PrivateName of private getter can be shadowed on inner class by a private method (field definitions in a class declaration) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +class C { + get #m() { throw new Test262Error(); } + + B = class { + method(o) { + return o.#m(); + } + + #m() { return 'test262'; } + } +} + +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(innerB), 'test262'); +assert.throws(TypeError, function() { + innerB.method(c); +}, 'accessed inner class method from an object of outer class'); diff --git a/test/language/statements/class/elements/private-getter-shadowed-by-setter-on-nested-class.js b/test/language/statements/class/elements/private-getter-shadowed-by-setter-on-nested-class.js new file mode 100644 index 0000000000..f387f03ac3 --- /dev/null +++ b/test/language/statements/class/elements/private-getter-shadowed-by-setter-on-nested-class.js @@ -0,0 +1,49 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-getter-shadowed-by-setter-on-nested-class.case +// - src/class-elements/default/cls-decl.template +/*--- +description: PrivateName of private getter can be shadowed on inner classes by a private setter (field definitions in a class declaration) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +class C { + get #m() { return 'outer class'; } + + method() { return this.#m; } + + B = class { + method(o) { + return o.#m; + } + + set #m(v) { this._v = v; } + } +} + +let c = new C(); +let innerB = new c.B(); + +assert.throws(TypeError, function() { + innerB.method(innerB); +}, '[[Get]] operation of an accessor without getter'); + +assert.sameValue(c.method(), 'outer class'); + +assert.throws(TypeError, function() { + innerB.method(c); +}, 'access of inner class accessor from an object of outer class'); diff --git a/test/language/statements/class/elements/private-method-on-nested-class.js b/test/language/statements/class/elements/private-method-on-nested-class.js new file mode 100644 index 0000000000..306d61a8d1 --- /dev/null +++ b/test/language/statements/class/elements/private-method-on-nested-class.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-method-on-nested-class.case +// - src/class-elements/default/cls-decl.template +/*--- +description: PrivateName of private method is available on inner classes (field definitions in a class declaration) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +class C { + #m() { return 'test262'; } + + B = class { + method(o) { + return o.#m(); + } + } +} + +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(c), 'test262'); diff --git a/test/language/statements/class/elements/private-method-shadowed-by-field-on-nested-class.js b/test/language/statements/class/elements/private-method-shadowed-by-field-on-nested-class.js new file mode 100644 index 0000000000..2314ab7e79 --- /dev/null +++ b/test/language/statements/class/elements/private-method-shadowed-by-field-on-nested-class.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-method-shadowed-by-field-on-nested-class.case +// - src/class-elements/default/cls-decl.template +/*--- +description: PrivateName of private method can be shadowed on inner classes by a private field (field definitions in a class declaration) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +class C { + #m() { return 'outer class'; } + + method() { return this.#m(); } + + B = class { + method(o) { + return o.#m; + } + + #m = 'test262'; + } +} + +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(innerB), 'test262'); +assert.sameValue(c.method(), 'outer class'); +assert.throws(TypeError, function() { + innerB.method(c); +}, 'accessed inner class field from an object of outer class'); diff --git a/test/language/statements/class/elements/private-method-shadowed-by-getter-on-nested-class.js b/test/language/statements/class/elements/private-method-shadowed-by-getter-on-nested-class.js new file mode 100644 index 0000000000..b32d61e661 --- /dev/null +++ b/test/language/statements/class/elements/private-method-shadowed-by-getter-on-nested-class.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-method-shadowed-by-getter-on-nested-class.case +// - src/class-elements/default/cls-decl.template +/*--- +description: PrivateName of private method can be shadowed on inner classes by a private getter (field definitions in a class declaration) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +class C { + #m() { return 'outer class'; } + + method() { return this.#m(); } + + B = class { + method(o) { + return o.#m; + } + + get #m() { return 'test262'; } + } +} + +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(innerB), 'test262'); +assert.sameValue(c.method(), 'outer class'); +assert.throws(TypeError, function() { + innerB.method(c); +}, 'accessed inner class getter from an object of outer class'); diff --git a/test/language/statements/class/elements/private-method-shadowed-by-setter-on-nested-class.js b/test/language/statements/class/elements/private-method-shadowed-by-setter-on-nested-class.js new file mode 100644 index 0000000000..062c3d38d6 --- /dev/null +++ b/test/language/statements/class/elements/private-method-shadowed-by-setter-on-nested-class.js @@ -0,0 +1,49 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-method-shadowed-by-setter-on-nested-class.case +// - src/class-elements/default/cls-decl.template +/*--- +description: PrivateName of private method can be shadowed on inner classes by a private setter (field definitions in a class declaration) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +class C { + #m() { return 'outer class'; } + + method() { return this.#m(); } + + B = class { + method(o) { + return o.#m; + } + + set #m(v) { this._v = v; } + } +} + +let c = new C(); +let innerB = new c.B(); + +assert.throws(TypeError, function() { + innerB.method(innerB); +}, '[[Get]] operation of an accessor without getter'); + +assert.sameValue(c.method(), 'outer class'); + +assert.throws(TypeError, function() { + innerB.method(c); +}, 'access of inner class accessor from an object of outer class'); diff --git a/test/language/statements/class/elements/private-method-shadowed-on-nested-class.js b/test/language/statements/class/elements/private-method-shadowed-on-nested-class.js new file mode 100644 index 0000000000..e7b2308f16 --- /dev/null +++ b/test/language/statements/class/elements/private-method-shadowed-on-nested-class.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-method-shadowed-on-nested-class.case +// - src/class-elements/default/cls-decl.template +/*--- +description: PrivateName of private method can be shadowed by inner class private method (field definitions in a class declaration) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +class C { + #m() { throw new Test262Error(); } + + B = class { + method() { + return this.#m(); + } + + #m() { return 'test262'; } + } +} + +let c = new C(); +let innerB = new c.B(); +assert.sameValue(innerB.method(), 'test262'); diff --git a/test/language/statements/class/elements/private-setter-on-nested-class.js b/test/language/statements/class/elements/private-setter-on-nested-class.js new file mode 100644 index 0000000000..debaab2c7f --- /dev/null +++ b/test/language/statements/class/elements/private-setter-on-nested-class.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-setter-on-nested-class.case +// - src/class-elements/default/cls-decl.template +/*--- +description: PrivateName of private setter is available on inner classes (field definitions in a class declaration) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +class C { + set #m(v) { this._v = v; } + + B = class { + method(o, v) { + o.#m = v; + } + } +} + +let c = new C(); +let innerB = new c.B(); +innerB.method(c, 'test262'); +assert.sameValue(c._v, 'test262'); diff --git a/test/language/statements/class/elements/private-setter-shadowed-by-field-on-nested-class.js b/test/language/statements/class/elements/private-setter-shadowed-by-field-on-nested-class.js new file mode 100644 index 0000000000..17cf279dbd --- /dev/null +++ b/test/language/statements/class/elements/private-setter-shadowed-by-field-on-nested-class.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-setter-shadowed-by-field-on-nested-class.case +// - src/class-elements/default/cls-decl.template +/*--- +description: PrivateName of private setter can be shadowed on inner classes by a private field (field definitions in a class declaration) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +class C { + set #m(v) { this._v = v; } + + method(v) { this.#m = v; } + + B = class { + method(o, v) { + o.#m = v; + } + + get m() { return this.#m; } + + #m; + } +} + +let c = new C(); +let innerB = new c.B(); + +innerB.method(innerB, 'test262'); +assert.sameValue(innerB.m, 'test262'); + +c.method('outer class'); +assert.sameValue(c._v, 'outer class'); + +assert.throws(TypeError, function() { + innerB.method(c, 'foo'); +}, 'accessed inner class field from an object of outer class'); diff --git a/test/language/statements/class/elements/private-setter-shadowed-by-getter-on-nested-class.js b/test/language/statements/class/elements/private-setter-shadowed-by-getter-on-nested-class.js new file mode 100644 index 0000000000..0c7fa6705b --- /dev/null +++ b/test/language/statements/class/elements/private-setter-shadowed-by-getter-on-nested-class.js @@ -0,0 +1,50 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-setter-shadowed-by-getter-on-nested-class.case +// - src/class-elements/default/cls-decl.template +/*--- +description: PrivateName of private setter can be shadowed on inner classes by a private getter (field definitions in a class declaration) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +class C { + set #m(v) { this._v = v; } + + method(v) { this.#m = v; } + + B = class { + method(o, v) { + o.#m = v; + } + + get #m() { return 'test262'; } + } +} + +let c = new C(); +let innerB = new c.B(); + +assert.throws(TypeError, function() { + innerB.method(innerB); +}, 'invalid [[Set]] of an acessor without setter'); + +c.method('outer class'); +assert.sameValue(c._v, 'outer class'); + +assert.throws(TypeError, function() { + innerB.method(c); +}, 'invalid access of inner class getter from an object of outer class'); diff --git a/test/language/statements/class/elements/private-setter-shadowed-by-method-on-nested-class.js b/test/language/statements/class/elements/private-setter-shadowed-by-method-on-nested-class.js new file mode 100644 index 0000000000..c4903ef99e --- /dev/null +++ b/test/language/statements/class/elements/private-setter-shadowed-by-method-on-nested-class.js @@ -0,0 +1,50 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-setter-shadowed-by-method-on-nested-class.case +// - src/class-elements/default/cls-decl.template +/*--- +description: PrivateName of private setter can be shadowed on inner class by a private method (field definitions in a class declaration) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +class C { + set #m(v) { this._v = v; } + + method(v) { this.#m = v; } + + B = class { + method(o, v) { + o.#m = v; + } + + #m() { return 'test262'; } + } +} + +let c = new C(); +let innerB = new c.B(); + +assert.throws(TypeError, function() { + innerB.method(innerB, 'foo'); +}, 'invalid [[Set]] operation in a private method'); + +c.method('outer class'); +assert.sameValue(c._v, 'outer class'); + +assert.throws(TypeError, function() { + innerB.method(c); +}, 'invalid access of inner class method from an object of outer class'); diff --git a/test/language/statements/class/elements/private-setter-shadowed-by-setter-on-nested-class.js b/test/language/statements/class/elements/private-setter-shadowed-by-setter-on-nested-class.js new file mode 100644 index 0000000000..3e113f6915 --- /dev/null +++ b/test/language/statements/class/elements/private-setter-shadowed-by-setter-on-nested-class.js @@ -0,0 +1,49 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-setter-shadowed-by-setter-on-nested-class.case +// - src/class-elements/default/cls-decl.template +/*--- +description: PrivateName of private setter can be shadowed on inner classes by a private setter (field definitions in a class declaration) +esid: prod-FieldDefinition +features: [class-methods-private, class-fields-public, class] +flags: [generated] +info: | + Updated Productions + + CallExpression[Yield, Await]: + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] + SuperCall[?Yield, ?Await] + CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await] + CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]] + CallExpression[?Yield, ?Await].IdentifierName + CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await] + CallExpression[?Yield, ?Await].PrivateName + +---*/ + + +class C { + set #m(v) { this._v = v; } + + method(v) { this.#m = v; } + + B = class { + method(o, v) { + o.#m = v; + } + + set #m(v) { this._v = v; } + } +} + +let c = new C(); +let innerB = new c.B(); + +innerB.method(innerB, 'test262'); +assert.sameValue(innerB._v, 'test262'); + +c.method('outer class'); +assert.sameValue(c._v, 'outer class'); + +assert.throws(TypeError, function() { + innerB.method(c, 'foo'); +}, 'access of inner class accessor from an object of outer class');