From 6ad41e57b73552564e30e53ab0a9a6abf2a8bd13 Mon Sep 17 00:00:00 2001 From: sgrekhov Date: Thu, 30 Oct 2025 10:59:35 +0200 Subject: [PATCH 1/3] #3329. Add more private named parameters tests --- .../static_semantics_A01_t04.dart | 59 +++++++++++++ .../static_semantics_A01_t05.dart | 84 +++++++++++++++++++ .../static_semantics_A02_t03.dart | 65 ++++++++++++++ .../static_semantics_A02_t04.dart | 69 +++++++++++++++ .../super_parameters_A01_t01.dart | 44 ++++++++++ .../super_parameters_A01_t02.dart | 38 +++++++++ 6 files changed, 359 insertions(+) create mode 100644 LanguageFeatures/Private-named-parameters/static_semantics_A01_t04.dart create mode 100644 LanguageFeatures/Private-named-parameters/static_semantics_A01_t05.dart create mode 100644 LanguageFeatures/Private-named-parameters/static_semantics_A02_t03.dart create mode 100644 LanguageFeatures/Private-named-parameters/static_semantics_A02_t04.dart create mode 100644 LanguageFeatures/Private-named-parameters/super_parameters_A01_t01.dart create mode 100644 LanguageFeatures/Private-named-parameters/super_parameters_A01_t02.dart diff --git a/LanguageFeatures/Private-named-parameters/static_semantics_A01_t04.dart b/LanguageFeatures/Private-named-parameters/static_semantics_A01_t04.dart new file mode 100644 index 0000000000..956af8c259 --- /dev/null +++ b/LanguageFeatures/Private-named-parameters/static_semantics_A01_t04.dart @@ -0,0 +1,59 @@ +// Copyright (c) 2025, the Dart project authors. Please see the AUTHORS file +// for details. All rights reserved. Use of this source code is governed by a +// BSD-style license that can be found in the LICENSE file. + +/// @assertion Given a named initializing formal or field parameter (for a +/// primary constructor) with private name `p` in constructor `C`: +/// - If `p` has no corresponding public name `n`, then compile-time error. +/// +/// @description Check that it is a compile-time error if a named initializing +/// formal parameter has a private name that has no corresponding public name. +/// @author sgrekhov22@gmail.com + +// SharedOptions=--enable-experiment=private-named-parameters + +class C { + String _; + C({this._ = ""}); +// ^ +// [analyzer] unspecified +// [cfe] unspecified + + C._({required this._}); +// ^ +// [analyzer] unspecified +// [cfe] unspecified +} + +extension type ET._(String _) { + ET({this._ = ""}); +// ^ +// [analyzer] unspecified +// [cfe] unspecified + + ET.named({required this._}); +// ^ +// [analyzer] unspecified +// [cfe] unspecified +} + +enum E { + e0; + + final String _; + const E({this._ = ""}); +// ^ +// [analyzer] unspecified +// [cfe] unspecified + + const E.named({required this._}); +// ^ +// [analyzer] unspecified +// [cfe] unspecified +} + +main() { + print(C); + print(ET); + print(E); +} diff --git a/LanguageFeatures/Private-named-parameters/static_semantics_A01_t05.dart b/LanguageFeatures/Private-named-parameters/static_semantics_A01_t05.dart new file mode 100644 index 0000000000..1f29373918 --- /dev/null +++ b/LanguageFeatures/Private-named-parameters/static_semantics_A01_t05.dart @@ -0,0 +1,84 @@ +// Copyright (c) 2025, the Dart project authors. Please see the AUTHORS file +// for details. All rights reserved. Use of this source code is governed by a +// BSD-style license that can be found in the LICENSE file. + +/// @assertion Given a named initializing formal or field parameter (for a +/// primary constructor) with private name `p` in constructor `C`: +/// - If `p` has no corresponding public name `n`, then compile-time error. +/// +/// @description Check that it is a compile-time error if a named formal +/// parameter of a declaring constructor has a private name with no +/// corresponding public name. +/// @author sgrekhov22@gmail.com + +// SharedOptions=--enable-experiment=private-named-parameters,declaring-constructors + +class C1({var String __}) { +// ^^ +// [analyzer] unspecified +// [cfe] unspecified +} + +class C2({required final String _}) { +// ^ +// [analyzer] unspecified +// [cfe] unspecified +} + +class C3 { + this({required final String _}); +// ^ +// [analyzer] unspecified +// [cfe] unspecified +} + +class C4 { + this({var String __ = ""}); +// ^^ +// [analyzer] unspecified +// [cfe] unspecified +} + +extension type ET1 { + this({final String __ = ""}); +// ^^ +// [analyzer] unspecified +// [cfe] unspecified +} + +extension type ET2 { + this({final String _ = ""}); +// ^ +// [analyzer] unspecified +// [cfe] unspecified +} + +enum E1({required final String __}) { +// ^^ +// [analyzer] unspecified +// [cfe] unspecified + e0(_: ""); +// ^ +// [analyzer] unspecified +// [cfe] unspecified +} + +enum E2 { + e0; + + const this({final String _ = ""}); +// ^ +// [analyzer] unspecified +// [cfe] unspecified +} + +main() { + print(C1); + print(C2); + print(C3); + print(C4); + print(ET1); + print(ET2); + print(E1); + print(E2); +} diff --git a/LanguageFeatures/Private-named-parameters/static_semantics_A02_t03.dart b/LanguageFeatures/Private-named-parameters/static_semantics_A02_t03.dart new file mode 100644 index 0000000000..bf8451cb78 --- /dev/null +++ b/LanguageFeatures/Private-named-parameters/static_semantics_A02_t03.dart @@ -0,0 +1,65 @@ +// Copyright (c) 2025, the Dart project authors. Please see the AUTHORS file +// for details. All rights reserved. Use of this source code is governed by a +// BSD-style license that can be found in the LICENSE file. + +/// @assertion Given a named initializing formal or field parameter (for a +/// primary constructor) with private name `p` in constructor `C`: +/// - If `p` has no corresponding public name `n`, then compile-time error. You +/// can't use a private name for a named parameter unless there is a valid +/// public name that could be used at the call site. +/// - If any other parameter in `C` has declared name `p` or `n`, then +/// compile-time error. +/// +/// @description Check that it is a compile-time error if any other parameter in +/// `C` has declared name `p` or `n`. +/// @author sgrekhov22@gmail.com + +// SharedOptions=--enable-experiment=private-named-parameters + +class C { + String _p; + String p; + C(String p, {this._p = ""}) : p = p; +// ^^ +// [analyzer] unspecified +// [cfe] unspecified + + C._(this.p, {required this._p}); +// ^^ +// [analyzer] unspecified +// [cfe] unspecified +} + +extension type ET._(String _p) { + ET(int p, {this._p = ""}); +// ^^ +// [analyzer] unspecified +// [cfe] unspecified + + ET.named(int p, {required this._p}); +// ^^ +// [analyzer] unspecified +// [cfe] unspecified +} + +enum E { + e0(1); + + final String _p; + final int? p; + const E(int? p, {this._p = ""}) : p = p; +// ^^ +// [analyzer] unspecified +// [cfe] unspecified + + const E.named(this.p, {required this._p}); +// ^^ +// [analyzer] unspecified +// [cfe] unspecified +} + +main() { + print(C); + print(ET); + print(E); +} diff --git a/LanguageFeatures/Private-named-parameters/static_semantics_A02_t04.dart b/LanguageFeatures/Private-named-parameters/static_semantics_A02_t04.dart new file mode 100644 index 0000000000..3dc32fd98f --- /dev/null +++ b/LanguageFeatures/Private-named-parameters/static_semantics_A02_t04.dart @@ -0,0 +1,69 @@ +// Copyright (c) 2025, the Dart project authors. Please see the AUTHORS file +// for details. All rights reserved. Use of this source code is governed by a +// BSD-style license that can be found in the LICENSE file. + +/// @assertion Given a named initializing formal or field parameter (for a +/// primary constructor) with private name `p` in constructor `C`: +/// - If `p` has no corresponding public name `n`, then compile-time error. You +/// can't use a private name for a named parameter unless there is a valid +/// public name that could be used at the call site. +/// - If any other parameter in `C` has declared name `p` or `n`, then +/// compile-time error. +/// +/// @description Check that it is a compile-time error if any other parameter in +/// `C` has declared name `p` or `n`. +/// @author sgrekhov22@gmail.com + +// SharedOptions=--enable-experiment=private-named-parameters,declaring-constructors + +class C1(int p, {var String _p = ""}) { +// ^^ +// [analyzer] unspecified +// [cfe] unspecified +} + +class C2 { + this(int p, {final String _p = "", }); +// ^^ +// [analyzer] unspecified +// [cfe] unspecified +} + +extension type ET1 { + this(int p, {final String _p = ""}); +// ^^ +// [analyzer] unspecified +// [cfe] unspecified +} + +extension type ET2 { + this(int p = 0, {final String _p = ""}); +// ^^ +// [analyzer] unspecified +// [cfe] unspecified +} + +enum E1(int p, {final String _p = ""}) { +// ^^ +// [analyzer] unspecified +// [cfe] unspecified + e0(1); +} + +enum E2 { + e0(2); + + const this(int? p, {final String _p = ""}); +// ^^ +// [analyzer] unspecified +// [cfe] unspecified +} + +main() { + print(C1); + print(C2); + print(ET1); + print(ET2); + print(E1); + print(E2); +} diff --git a/LanguageFeatures/Private-named-parameters/super_parameters_A01_t01.dart b/LanguageFeatures/Private-named-parameters/super_parameters_A01_t01.dart new file mode 100644 index 0000000000..4afa66faed --- /dev/null +++ b/LanguageFeatures/Private-named-parameters/super_parameters_A01_t01.dart @@ -0,0 +1,44 @@ +// Copyright (c) 2025, the Dart project authors. Please see the AUTHORS file +// for details. All rights reserved. Use of this source code is governed by a +// BSD-style license that can be found in the LICENSE file. + +/// @assertion A super parameter generates an implicit argument that forwards to +/// a superclass constructor. The super constructor's argument name is always +/// public, even if the corresponding constructor parameter uses this feature +/// and has a private name. Thus, super parameters continue to always use public +/// names. +/// +/// @description Check that private super parameter can be invoked using its +/// public name. +/// @author sgrekhov22@gmail.com + +// SharedOptions=--enable-experiment=private-named-parameters + +import '../../Utils/expect.dart'; + +class A1 { + String _p; + A1({this._p = ""}); +} + +class A2 { + String _p; + A2({required this._p}); +} + +class C1 extends A1 { + C1({super.p}); + C1.named({super.p}); +} + +class C2 extends A2 { + C2({required super.p}); + C2.named({required super.p}); +} + +main() { + Expect.equals("a", C1(p: "a")._p); + Expect.equals("b", C1.named(p: "b")._p); + Expect.equals("c", C2(p: "c")._p); + Expect.equals("d", C2.named(p: "d")._p); +} diff --git a/LanguageFeatures/Private-named-parameters/super_parameters_A01_t02.dart b/LanguageFeatures/Private-named-parameters/super_parameters_A01_t02.dart new file mode 100644 index 0000000000..52c4fe3a64 --- /dev/null +++ b/LanguageFeatures/Private-named-parameters/super_parameters_A01_t02.dart @@ -0,0 +1,38 @@ +// Copyright (c) 2025, the Dart project authors. Please see the AUTHORS file +// for details. All rights reserved. Use of this source code is governed by a +// BSD-style license that can be found in the LICENSE file. + +/// @assertion A super parameter generates an implicit argument that forwards to +/// a superclass constructor. The super constructor's argument name is always +/// public, even if the corresponding constructor parameter uses this feature +/// and has a private name. Thus, super parameters continue to always use public +/// names. +/// +/// @description Check that private super parameter can be invoked using its +/// public name. Test declaring constructors. +/// @author sgrekhov22@gmail.com + +// SharedOptions=--enable-experiment=private-named-parameters + +import '../../Utils/expect.dart'; + +class A1 { + String _p; + A1({this._p = ""}); +} + +class A2 { + String _p; + A2({required this._p}); +} + +class C1({super.p}) extends A1; + +class C2 extends A2 { + this({required super.p}); +} + +main() { + Expect.equals("a", C1(p: "a")._p); + Expect.equals("b", C2(p: "b")._p); +} From 32cffcbc73f09de30c6ea1e74f2761d3dfcb06e4 Mon Sep 17 00:00:00 2001 From: sgrekhov Date: Thu, 30 Oct 2025 11:02:19 +0200 Subject: [PATCH 2/3] Fix accidental syntax error --- .../Private-named-parameters/static_semantics_A02_t04.dart | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/LanguageFeatures/Private-named-parameters/static_semantics_A02_t04.dart b/LanguageFeatures/Private-named-parameters/static_semantics_A02_t04.dart index 3dc32fd98f..248830b2ea 100644 --- a/LanguageFeatures/Private-named-parameters/static_semantics_A02_t04.dart +++ b/LanguageFeatures/Private-named-parameters/static_semantics_A02_t04.dart @@ -37,8 +37,8 @@ extension type ET1 { } extension type ET2 { - this(int p = 0, {final String _p = ""}); -// ^^ + this(int p, {final String _p = ""}); +// ^^ // [analyzer] unspecified // [cfe] unspecified } From b91ca8ebd7edf6b9c7b2f75a27f3a9c293afd285 Mon Sep 17 00:00:00 2001 From: sgrekhov Date: Thu, 30 Oct 2025 12:03:52 +0200 Subject: [PATCH 3/3] Implement review recommendations --- .../static_semantics_A01_t05.dart | 4 ++-- .../static_semantics_A02_t03.dart | 2 +- .../static_semantics_A02_t04.dart | 2 +- .../super_parameters_A01_t01.dart | 14 ++++++++++++++ 4 files changed, 18 insertions(+), 4 deletions(-) diff --git a/LanguageFeatures/Private-named-parameters/static_semantics_A01_t05.dart b/LanguageFeatures/Private-named-parameters/static_semantics_A01_t05.dart index 1f29373918..83e70f3bfd 100644 --- a/LanguageFeatures/Private-named-parameters/static_semantics_A01_t05.dart +++ b/LanguageFeatures/Private-named-parameters/static_semantics_A01_t05.dart @@ -6,8 +6,8 @@ /// primary constructor) with private name `p` in constructor `C`: /// - If `p` has no corresponding public name `n`, then compile-time error. /// -/// @description Check that it is a compile-time error if a named formal -/// parameter of a declaring constructor has a private name with no +/// @description Check that it is a compile-time error if a declaring named +/// formal parameter of a declaring constructor has a private name with no /// corresponding public name. /// @author sgrekhov22@gmail.com diff --git a/LanguageFeatures/Private-named-parameters/static_semantics_A02_t03.dart b/LanguageFeatures/Private-named-parameters/static_semantics_A02_t03.dart index bf8451cb78..a8895b83da 100644 --- a/LanguageFeatures/Private-named-parameters/static_semantics_A02_t03.dart +++ b/LanguageFeatures/Private-named-parameters/static_semantics_A02_t03.dart @@ -11,7 +11,7 @@ /// compile-time error. /// /// @description Check that it is a compile-time error if any other parameter in -/// `C` has declared name `p` or `n`. +/// `C` has declared name `p` or `n`. Test initializing formals. /// @author sgrekhov22@gmail.com // SharedOptions=--enable-experiment=private-named-parameters diff --git a/LanguageFeatures/Private-named-parameters/static_semantics_A02_t04.dart b/LanguageFeatures/Private-named-parameters/static_semantics_A02_t04.dart index 248830b2ea..afa7570abf 100644 --- a/LanguageFeatures/Private-named-parameters/static_semantics_A02_t04.dart +++ b/LanguageFeatures/Private-named-parameters/static_semantics_A02_t04.dart @@ -11,7 +11,7 @@ /// compile-time error. /// /// @description Check that it is a compile-time error if any other parameter in -/// `C` has declared name `p` or `n`. +/// `C` has declared name `p` or `n`. Test declaring parameters. /// @author sgrekhov22@gmail.com // SharedOptions=--enable-experiment=private-named-parameters,declaring-constructors diff --git a/LanguageFeatures/Private-named-parameters/super_parameters_A01_t01.dart b/LanguageFeatures/Private-named-parameters/super_parameters_A01_t01.dart index 4afa66faed..ab1a828ddb 100644 --- a/LanguageFeatures/Private-named-parameters/super_parameters_A01_t01.dart +++ b/LanguageFeatures/Private-named-parameters/super_parameters_A01_t01.dart @@ -36,9 +36,23 @@ class C2 extends A2 { C2.named({required super.p}); } +class C3 extends A1 { + C3(String p) : super(p: p); + C3.named(String p) : super(p: p); +} + +class C4 extends A2 { + C4(String p) : super(p: p); + C4.named(String p) : super(p: p); +} + main() { Expect.equals("a", C1(p: "a")._p); Expect.equals("b", C1.named(p: "b")._p); Expect.equals("c", C2(p: "c")._p); Expect.equals("d", C2.named(p: "d")._p); + Expect.equals("e", C3("e")._p); + Expect.equals("f", C3.named("f")._p); + Expect.equals("g", C4("g")._p); + Expect.equals("h", C4.named("h")._p); }