#3315. Add tests for new() and factory() constructors

Author: sgrekhov

LanguageFeatures/Primary-constructors/static_processing_A01_t01.dart

@@ -0,0 +1,71 @@
+// 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 The ability to use `new` or `factory` as a keyword and omitting
+/// the class name in declarations of ordinary (non-primary) constructors is
+/// purely syntactic. The static analysis and meaning of such constructors is
+/// identical to the form that uses the class name.
+///
+/// @description Check that `new` can be used instead of the class name in
+/// declarations of ordinary constructors. Test classes.
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=declaring-constructors
+
+import '../../Utils/expect.dart';
+
+const metadata = 42;
+
+class C1 {
+  int? v;
+  @metadata new() {
+    v = 1;
+  }
+}
+
+class C2 {
+  final int v;
+  @metadata const new(int v) : v = v;
+}
+
+class C3 {
+  final int v;
+  new(this.v);
+}
+
+class A {
+  int v;
+  A(this.v);
+}
+
+class C4 extends A {
+  new(super.v);
+}
+
+class C5 {
+  final int v;
+  new([int v = 0]) : v = v;
+}
+
+class C6 {
+  final int v;
+  const new({int v = 0}) : v = v;
+}
+
+class C7 {
+  final int v;
+  new({required int v}) : v = v;
+}
+
+main() {
+  Expect.equals(1, C1().v);
+  Expect.equals(2, C2(2).v);
+  Expect.equals(3, C3(3).v);
+  Expect.equals(4, C4(4).v);
+  Expect.equals(0, C5().v);
+  Expect.equals(5, C5(5).v);
+  Expect.equals(0, C6().v);
+  Expect.equals(6, C6(v: 6).v);
+  Expect.equals(7, C7(v: 7).v);
+}

LanguageFeatures/Primary-constructors/static_processing_A01_t02.dart

@@ -0,0 +1,49 @@
+// 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 The ability to use `new` or `factory` as a keyword and omitting
+/// the class name in declarations of ordinary (non-primary) constructors is
+/// purely syntactic. The static analysis and meaning of such constructors is
+/// identical to the form that uses the class name.
+///
+/// @description Check that `new` can be used instead of the class name in
+/// declarations of ordinary constructors. Test extension types.
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=declaring-constructors
+
+import '../../Utils/expect.dart';
+
+const metadata = 42;
+
+extension type ET1._(int v) {
+  @metadata const new(this.v);
+}
+
+extension type ET2._(int v) {
+  @metadata new() : v = 2;
+}
+
+extension type ET3._(int v) {
+  const new([int v = 0]) : v = v;
+}
+
+extension type ET4._(int v) {
+  new({int v = 0}) : v = v;
+}
+
+extension type ET5._(int v) {
+  const new({required int v}) : v = v;
+}
+
+main() {
+  Expect.equals(1, ET1(1).v);
+  Expect.equals(2, ET2().v);
+  Expect.equals(3, ET3(3).v);
+  Expect.equals(0, ET3().v);
+  Expect.equals(4, ET4(v: 4).v);
+  Expect.equals(0, ET4().v);
+  Expect.equals(5, ET5(v: 5).v);
+  Expect.equals(0, ET5().v);
+}

LanguageFeatures/Primary-constructors/static_processing_A01_t03.dart

@@ -0,0 +1,63 @@
+// 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 The ability to use `new` or `factory` as a keyword and omitting
+/// the class name in declarations of ordinary (non-primary) constructors is
+/// purely syntactic. The static analysis and meaning of such constructors is
+/// identical to the form that uses the class name.
+///
+/// @description Check that `new` can be used instead of the class name in
+/// declarations of ordinary constructors. Test enums.
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=declaring-constructors
+
+import '../../Utils/expect.dart';
+
+const metadata = 42;
+
+enum E1 {
+  a(1);
+
+  final int v;
+  @metadata const new(this.v);
+}
+
+enum E2 {
+  a();
+
+  final int v;
+  const new() : v = 2;
+}
+
+enum E3 {
+  a(1), b();
+
+  final int v;
+  const new([int v = 0]) : v = v;
+}
+
+enum E4 {
+  a(v: 1), b();
+
+  final int v;
+  const new({int v = 0}) : v = v;
+}
+
+enum E5 {
+  a(v: 1);
+
+  final int v;
+  const new({required int v}) : v = v;
+}
+
+main() {
+  Expect.equals(1, E1.a.v);
+  Expect.equals(2, E2.a.v);
+  Expect.equals(1, E3.a.v);
+  Expect.equals(0, E3.b.v);
+  Expect.equals(1, E4.a.v);
+  Expect.equals(0, E4.b.v);
+  Expect.equals(1, E5.a.v);
+}

LanguageFeatures/Primary-constructors/static_processing_A01_t04.dart

@@ -0,0 +1,53 @@
+// 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 The ability to use `new` or `factory` as a keyword and omitting
+/// the class name in declarations of ordinary (non-primary) constructors is
+/// purely syntactic. The static analysis and meaning of such constructors is
+/// identical to the form that uses the class name.
+///
+/// @description Check that it is a compile-time error if a `new` keyword is
+/// used as a constructor name in the factory constructor redirection.
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=declaring-constructors
+
+class C1 {
+  C1();
+  factory C1.someName() = new;
+//                        ^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+class C2 {
+  factory C2() = new.someName;
+//               ^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  C2.someName();
+}
+
+extension type ET1._(int v) {
+  ET1(this.v);
+  factory ET1.someName(int v) = new;
+//                              ^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+extension type ET2._(int v) {
+  factory ET2(int v) = new.someName;
+//                     ^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  ET2.someName(this.v);
+}
+
+main() {
+  print(C1);
+  print(C2);
+  print(ET1);
+  print(ET2);
+}

LanguageFeatures/Primary-constructors/static_processing_A01_t05.dart

@@ -0,0 +1,73 @@
+// 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 The ability to use `new` or `factory` as a keyword and omitting
+/// the class name in declarations of ordinary (non-primary) constructors is
+/// purely syntactic. The static analysis and meaning of such constructors is
+/// identical to the form that uses the class name.
+///
+/// @description Check that it is a compile-time error if a `new` keyword is
+/// used as a constructor name in the initializer list.
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=declaring-constructors
+
+class C1 {
+  C1();
+  C1.someName() : new();
+//                ^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+class C2 {
+  C2() : new.someName();
+//       ^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  C2.someName();
+}
+
+extension type ET1(int v) {
+  ET1.someName() : new(0);
+//                 ^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+extension type ET2.someName(int v) {
+  ET2() : new.someName(0);
+//        ^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+enum E1 {
+  e0;
+
+  const E1();
+  const E1.someName() : new();
+//                      ^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+enum E2 {
+  e0;
+
+  const ET2() : new.someName();
+//              ^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  const ET2.someName();
+}
+
+main() {
+  print(C1);
+  print(C2);
+  print(ET1);
+  print(ET2);
+  print(E1);
+  print(E2);
+}

LanguageFeatures/Primary-constructors/static_processing_A01_t06.dart

@@ -0,0 +1,45 @@
+// 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 The ability to use `new` or `factory` as a keyword and omitting
+/// the class name in declarations of ordinary (non-primary) constructors is
+/// purely syntactic. The static analysis and meaning of such constructors is
+/// identical to the form that uses the class name.
+///
+/// @description Check that `factory` can be used instead of the class name in
+/// declarations of ordinary constructors.
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=declaring-constructors
+
+import '../../Utils/expect.dart';
+
+class C1 {
+  int v;
+  C1.create(this.v);
+
+  factory() => C1.create(1);
+}
+
+class C2 {
+  final int v;
+  const C2.create(this.v);
+
+  const factory(int v) = C2.create;
+}
+
+extension type ET1.create(int v) {
+  factory() => ET1.create(1);
+}
+
+extension type const ET2.create(int v) {
+  const factory ET2 (int v) = ET2.create;
+}
+
+main() {
+  Expect.equals(1, C1().v);
+  Expect.equals(2, C2(2).v);
+  Expect.equals(1, ET1().v);
+  Expect.equals(2, ET2(2).v);
+}

LanguageFeatures/Primary-constructors/static_processing_A01_t07.dart

@@ -0,0 +1,36 @@
+// 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 The ability to use `new` or `factory` as a keyword and omitting
+/// the class name in declarations of ordinary (non-primary) constructors is
+/// purely syntactic. The static analysis and meaning of such constructors is
+/// identical to the form that uses the class name.
+///
+/// @description Check that it is a compile-time error if a keyword `factory` is
+/// used to declare a constant non-redirecting constructor.
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=declaring-constructors
+
+class C {
+  int v;
+  C.create(this.v);
+
+  const factory C() => C.create(1);
+//^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+extension type const ET(int _) {
+  const factory() => ET(0);
+//^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(C);
+  print(ET);
+}