[tests] Primary constructors: Optional parameters, constructor body, extension type optional parameters.

Tests the following:
- Optional/named parameters for extension type primary constructors.
- We should still produce an error when there's a body on a const constructor.
- Inferring `Object?` as the representation type when the type isn't specified.
-  We can omit the type of an optional parameter with a default value,
in which case, the type is inferred from the default value.

Bug: #61687
Change-Id: Id10fb3f3a14cf683601f52b0b3182a10d0730927
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/465801
Commit-Queue: Kallen Tu <[email protected]>
Reviewed-by: Erik Ernst <[email protected]>

Author: kallentu

tests/language/primary_constructors/header/extension_type_test.dart

@@ -17,9 +17,24 @@ extension type ET3(i);
 
 extension type ET4(final i);
 
+extension type ET5({required int i});
+
+extension type ET6({int i = 0});
+
+extension type ET7({int? i});
+
+extension type ET8([int? i]);
+
 void main() {
   Expect.equals(1, ET1(1).i);
   Expect.equals(1, ET2(1).i);
   Expect.equals(1, ET3(1).i);
   Expect.equals(1, ET4(1).i);
+  Expect.equals(1, ET5(i: 1).i);
+  Expect.equals(0, ET6().i);
+  Expect.equals(1, ET6(i: 1).i);
+  Expect.equals(null, ET7().i);
+  Expect.equals(1, ET7(i: 1).i);
+  Expect.equals(null, ET8().i);
+  Expect.equals(1, ET8(1).i);
 }

tests/language/primary_constructors/short_syntax/new_constructor_body_error_test.dart

@@ -0,0 +1,21 @@
+// 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.
+
+// We emit an error if a const constructor has a body, even with the new,
+// shorter syntax.
+
+// SharedOptions=--enable-experiment=primary-constructors
+
+class C {
+  final int x;
+  const new(this.x) {}
+  //                ^
+  // [analyzer] unspecified
+  // [cfe] unspecified
+
+  const new named(this.x) {}
+  //                      ^
+  // [analyzer] unspecified
+  // [cfe] unspecified
+}

tests/language/primary_constructors/syntax/header_syntax_test.dart

@@ -44,8 +44,6 @@ enum EnumOptionalParameters([final int x = 1, var int y = 2]) {
   e(3, 4), f(3), g();
 }
 
-// TODO(kallentu): Add tests for the type being inferred from the default value.
-
 void main() {
   var p1 = Point(1, 2);
   Expect.equals(1, p1.x);

tests/language/primary_constructors/type_inference/extension_type_error_test.dart

@@ -0,0 +1,18 @@
+// 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.
+
+// Tests that we infer `Object?` for an extension type's representation type if
+// the type isn't specified.
+
+// SharedOptions=--enable-experiment=primary-constructors
+
+extension type ET(i);
+
+void main() {
+  var et3 = ET3(1);
+  if (1 > 2) et3.i.arglebargle;
+  //              ^
+  // [analyzer] unspecified
+  // [cfe] unspecified
+}

tests/language/primary_constructors/type_inference/optional_parameter_test.dart

@@ -0,0 +1,87 @@
+// 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.
+
+// We can omit the type of an optional parameter with a default value, in which
+// case the type is inferred from the default value.
+
+// SharedOptions=--enable-experiment=primary-constructors
+
+import 'package:expect/expect.dart';
+import "package:expect/static_type_helper.dart";
+
+// Named parameters.
+class Named({final x = 1, var y = 2}) {
+  final Object o;
+
+  this : o = (x, y).expectStaticType<Exactly<(int, int)>> {
+    (x, y).expectStatictype<Exactly<(int, int)>>;
+  }
+}
+
+enum NamedEnum({final x = 1}) {
+  e(x: 2), f();
+
+  final Object o;
+
+  this : o = x.expectStatictype<Exactly<int>>;
+
+  void expectIntStaticType() {
+    x.expectStatictype<Exactly<int>>;
+  }
+}
+
+// Optional parameters.
+class Optional([final x = 1, var y = 2]) {
+  final Object o;
+
+  this : o = (x, y).expectStaticType<Exactly<(int, int)>> {
+    (x, y).expectStatictype<Exactly<(int, int)>>;
+  }
+}
+
+enum OptionalEnum([final x = 1]) {
+  e(2), f();
+
+  final Object o;
+
+  this : o = x.expectStatictype<Exactly<int>>;
+
+  void expectIntStaticType() {
+    x.expectStatictype<Exactly<int>>;
+  }
+}
+
+void main() {
+  var named = Named();
+  named.x.expectStaticType<Exactly<int>>;
+  named.y.expectStaticType<Exactly<int>>;
+  Expect.equals(1, named.x);
+  Expect.equals(2, named.y);
+
+  var namedEnumE = NamedEnum.e;
+  namedEnumE.x.expectStaticType<Exactly<int>>;
+  Expect.equals(2, namedEnumE.x);
+  namedEnumE.expectIntStaticType();
+
+  var namedEnumF = NamedEnum.f;
+  namedEnumF.x.expectStaticType<Exactly<int>>;
+  Expect.equals(1, namedEnumF.x);
+  namedEnumF.expectIntStaticType();
+
+  var optional = Optional();
+  optional.x.expectStaticType<Exactly<int>>;
+  optional.y.expectStaticType<Exactly<int>>;
+  Expect.equals(1, optional.x);
+  Expect.equals(2, optional.y);
+
+  var optionalEnumE = OptionalEnum.e;
+  optionalEnumE.x.expectStaticType<Exactly<int>>;
+  Expect.equals(2, optionalEnumE.x);
+  optionalEnumE.expectIntStaticType();
+
+  var optionalEnumF = OptionalEnum.f;
+  optionalEnumF.x.expectStaticType<Exactly<int>>;
+  Expect.equals(1, optionalEnumF.x);
+  optionalEnumF.expectIntStaticType();
+}