#3315. Move/add mixins and generative constructors tests to Primary-constructors. (#3394)

Move/add mixin tests and generative constructor tests to `Primary-constructors`

Author: sgrekhov

LanguageFeatures/Primary-constructors/static_processing_A03_t01.dart

@@ -0,0 +1,48 @@
+// 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 Consider a class, mixin class, enum, or extension type
+/// declaration `D` with a primary constructor (note that it cannot be a
+/// `<mixinApplicationClass>`, because that kind of declaration does not
+/// syntactically support primary constructors).
+///
+/// @description Check that it is a compile-time error to declare a mixin with a
+/// primary constructor.
+/// @author sgrekhov22@gmail.com
+
+// SharedOptions=--enable-experiment=declaring-constructors
+
+mixin M1() {}
+//    ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+mixin M2;
+//    ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+mixin const M3(final int v);
+//          ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+mixin M4(var int v) {}
+//    ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+mixin M5.someName() {
+//       ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(M1);
+  print(M2);
+  print(M3);
+  print(M4);
+  print(M5);
+}

LanguageFeatures/Primary-constructors/static_processing_A03_t02.dart

@@ -0,0 +1,56 @@
+// 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 Consider a class, mixin class, enum, or extension type
+/// declaration `D` with a primary constructor (note that it cannot be a
+/// `<mixinApplicationClass>`, because that kind of declaration does not
+/// syntactically support primary constructors).
+///
+/// @description Check that it is a compile-time error to declare a mixin class
+/// with a non-trivial primary constructor.
+/// @author sgrekhov22@gmail.com
+
+// SharedOptions=--enable-experiment=declaring-constructors
+
+mixin class M1() {} // Ok, this declares a "trivial" constructor
+
+base mixin class M2;
+
+mixin class const M3(final int v);
+//                ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+base mixin M4(var int v) {}
+//         ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+abstract mixin class M5(); // Ok, "trivial" constructor
+
+abstract base mixin class M6.someName(final int v) {}
+//                        ^^^^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+base mixin M7.someName(); // Constructor is "trivial" but it's not a "mixin class"
+//            ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+mixin class M8.someName() { // Ok
+  int x;
+  this: x = 0;
+}
+
+main() {
+  print(M1);
+  print(M2);
+  print(M3);
+  print(M4);
+  print(M5);
+  print(M6);
+  print(M7);
+  print(M8);
+}

LanguageFeatures/Primary-constructors/static_processing_A03_t03.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 Consider a class, mixin class, enum, or extension type
+/// declaration `D` with a primary constructor (note that it cannot be a
+/// `<mixinApplicationClass>`, because that kind of declaration does not
+/// syntactically support primary constructors).
+///
+/// @description Check that it is a syntax error to declare a mixin application
+/// class with a primary constructor.
+/// @author sgrekhov22@gmail.com
+
+// SharedOptions=--enable-experiment=declaring-constructors
+
+mixin M {}
+
+class C1() = Object with M;
+//    ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+class C2.someName() = Object with M;
+//    ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+class const C3.someName(final int v) = Object with M;
+//    ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+class C4.new(var int v) = Object with M;
+//    ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+class C5._() = Object with M;
+//    ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+main() {
+  print(C1);
+  print(C2);
+  print(C3);
+  print(C4);
+  print(C5);
+}

LanguageFeatures/Primary-constructors/static_processing_A04_t01.dart

@@ -0,0 +1,39 @@
+// 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 Consider a class, mixin class, enum, or extension type
+/// declaration `D` with a primary constructor (note that it cannot be a
+/// `<mixinApplicationClass>`, because that kind of declaration does not
+/// syntactically support primary constructors). This declaration is treated as
+/// a class, mixin class, enum, respectively extension type declaration without
+/// a primary constructor which is obtained as described in the following. This
+/// determines the dynamic semantics of a primary constructor.
+///
+/// A compile-time error occurs if the body of `D` contains a non-redirecting
+/// generative constructor, unless `D` is an extension type.
+///
+/// @description Check that it is a compile-time error if the body of `D`
+/// contains a non-redirecting generative constructor. Test a class.
+/// @author sgrekhov22@gmail.com
+
+// SharedOptions=--enable-experiment=declaring-constructors
+
+class C1(var int v) {
+  C1.someName(this.v);
+//   ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+class C2.someName(final int v) {
+  C2(int x) : v = 42;
+//^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(C1);
+  print(C2);
+}

LanguageFeatures/Primary-constructors/static_processing_A04_t02.dart

@@ -0,0 +1,39 @@
+// 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 Consider a class, mixin class, enum, or extension type
+/// declaration `D` with a primary constructor (note that it cannot be a
+/// `<mixinApplicationClass>`, because that kind of declaration does not
+/// syntactically support primary constructors). This declaration is treated as
+/// a class, mixin class, enum, respectively extension type declaration without
+/// a primary constructor which is obtained as described in the following. This
+/// determines the dynamic semantics of a primary constructor.
+///
+/// A compile-time error occurs if the body of `D` contains a non-redirecting
+/// generative constructor, unless `D` is an extension type.
+///
+/// @description Check that it is a compile-time error if the body of `D`
+/// contains a non-redirecting generative constructor. Test a mixin class.
+/// @author sgrekhov22@gmail.com
+
+// SharedOptions=--enable-experiment=declaring-constructors
+
+mixin class C1() {
+  C1.someName();
+//   ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+class C2.someName() {
+  C2();
+//^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(C1);
+  print(C2);
+}

LanguageFeatures/Primary-constructors/static_processing_A04_t03.dart

@@ -0,0 +1,43 @@
+// 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 Consider a class, mixin class, enum, or extension type
+/// declaration `D` with a primary constructor (note that it cannot be a
+/// `<mixinApplicationClass>`, because that kind of declaration does not
+/// syntactically support primary constructors). This declaration is treated as
+/// a class, mixin class, enum, respectively extension type declaration without
+/// a primary constructor which is obtained as described in the following. This
+/// determines the dynamic semantics of a primary constructor.
+///
+/// A compile-time error occurs if the body of `D` contains a non-redirecting
+/// generative constructor, unless `D` is an extension type.
+///
+/// @description Check that it is a compile-time error if the body of `D`
+/// contains a non-redirecting generative constructor. Test an enum.
+/// @author sgrekhov22@gmail.com
+
+// SharedOptions=--enable-experiment=declaring-constructors
+
+enum const E1(final int v) {
+  e0(1);
+
+  const E1.someName(this.v);
+//         ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+enum const E2.someName(final int v) {
+  e0(2);
+
+  const E2(int x) : v = 42;
+//      ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(E1);
+  print(E2);
+}

LanguageFeatures/Primary-constructors/static_processing_A04_t04.dart

@@ -0,0 +1,35 @@
+// 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 Consider a class, mixin class, enum, or extension type
+/// declaration `D` with a primary constructor (note that it cannot be a
+/// `<mixinApplicationClass>`, because that kind of declaration does not
+/// syntactically support primary constructors). This declaration is treated as
+/// a class, mixin class, enum, respectively extension type declaration without
+/// a primary constructor which is obtained as described in the following. This
+/// determines the dynamic semantics of a primary constructor.
+///
+/// A compile-time error occurs if the body of `D` contains a non-redirecting
+/// generative constructor, unless `D` is an extension type.
+///
+/// @description Check that it is not an error if `D` is an extension type and
+/// the body of `D` contains a non-redirecting generative constructor.
+/// @author sgrekhov22@gmail.com
+
+// SharedOptions=--enable-experiment=declaring-constructors
+
+import '../../Utils/expect.dart';
+
+extension type ET1(int v) {
+  ET1.someName(this.v);
+}
+
+extension type const ET2.someName(final int v) {
+  const ET2(int v) : this.v = v;
+}
+
+main() {
+  Expect.equals(1, ET1(1).v);
+  Expect.equals(2, ET2(2).v);
+}

LanguageFeatures/Primary-constructors/static_processing_A04_t05.dart

@@ -0,0 +1,35 @@
+// 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 Consider a class, mixin class, enum, or extension type
+/// declaration `D` with a primary constructor (note that it cannot be a
+/// `<mixinApplicationClass>`, because that kind of declaration does not
+/// syntactically support primary constructors). This declaration is treated as
+/// a class, mixin class, enum, respectively extension type declaration without
+/// a primary constructor which is obtained as described in the following. This
+/// determines the dynamic semantics of a primary constructor.
+///
+/// A compile-time error occurs if the body of `D` contains a non-redirecting
+/// generative constructor, unless `D` is an extension type.
+///
+/// @description Check that it is not an error if the body of `D` contains a
+/// redirecting generative constructor. Test a class.
+/// @author sgrekhov22@gmail.com
+
+// SharedOptions=--enable-experiment=declaring-constructors
+
+import '../../Utils/expect.dart';
+
+class C1(var int v) {
+  C1.someName(int v) : this(v);
+}
+
+class const C2.someName(final int v) {
+  const C2(int v) : this.someName(v);
+}
+
+main() {
+  Expect.equals(1, C1(1).v);
+  Expect.equals(2, C2(2).v);
+}

LanguageFeatures/Primary-constructors/static_processing_A04_t07.dart

@@ -0,0 +1,41 @@
+// 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 Consider a class, mixin class, enum, or extension type
+/// declaration `D` with a primary constructor (note that it cannot be a
+/// `<mixinApplicationClass>`, because that kind of declaration does not
+/// syntactically support primary constructors). This declaration is treated as
+/// a class, mixin class, enum, respectively extension type declaration without
+/// a primary constructor which is obtained as described in the following. This
+/// determines the dynamic semantics of a primary constructor.
+///
+/// A compile-time error occurs if the body of `D` contains a non-redirecting
+/// generative constructor, unless `D` is an extension type.
+///
+/// @description Check that it is not an error if the body of `D` contains a
+/// redirecting generative constructor. Test an enum.
+/// @author sgrekhov22@gmail.com
+
+// SharedOptions=--enable-experiment=declaring-constructors
+
+import '../../Utils/expect.dart';
+
+enum E1(final int v) {
+  e0(1), e1.someName(2);
+
+  E1.someName(int v) : this(v);
+}
+
+enum const E2.someName(final int v) {
+  e0.someName(1), e1(2);
+
+  const C2(int v) : this.someName(v);
+}
+
+main() {
+  Expect.equals(1, E1.e0.v);
+  Expect.equals(2, E1.e1.v);
+  Expect.equals(1, E2.e0.v);
+  Expect.equals(2, E2.e1.v);
+}