[analyzer] Dot shorthands: Tests with abstract classes, factory constructors, const ctors, and type arguments.

kallentu · kallentu · commit 435a56bccccb · 2025-12-01T10:16:23.000-08:00
Testing the code paths of `InstanceCreationExpressionResolver.resolveDotShorthand`. I wanted to make sure we covered everything with these conditions so this is a sanity check to make sure the recent changes with https://dart-review.googlesource.com/c/sdk/+/462542 still kept the same semantics. The only big difference that I can see with the change above is that `test_abstractClass_const_typeArguments` has two diagnostics instead of one now. I checked with the equivalent non-shorthand code, and we are also producing two diagnostics, so I'm not too bothered by that. This is a table of what each unit test is testing. Abstract Factory Const Type args Analyzer Test FALSE FALSE FALSE FALSE Most existing tests FALSE FALSE FALSE TRUE test_typeParameters FALSE FALSE TRUE FALSE Existing const ctor tests FALSE FALSE TRUE TRUE test_typeParameters_const FALSE TRUE FALSE FALSE test_factory FALSE TRUE FALSE TRUE test_factory_typeArguments FALSE TRUE TRUE FALSE test_factory_const FALSE TRUE TRUE TRUE test_factory_const_typeArguments TRUE FALSE FALSE FALSE test_abstractClass TRUE FALSE FALSE TRUE test_abstractClass_typeArguments TRUE FALSE TRUE FALSE test_abstractClass_const TRUE FALSE TRUE TRUE test_abstractClass_const_typeArguments TRUE TRUE FALSE FALSE test_abstractClass_factory TRUE TRUE FALSE TRUE test_abstractClass_factory_typeArguments TRUE TRUE TRUE FALSE test_abstractClass_factory_const TRUE TRUE TRUE TRUE test_abstractClass_factory_const_typeArguments Bug: #61978 Change-Id: I6be2df562711cd7e8f52dacf62a422b823afdad1 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/464764 Reviewed-by: Paul Berry <paulberry@google.com>
diff --git a/pkg/analyzer/test/src/dart/resolution/dot_shorthand_constructor_invocation_test.dart b/pkg/analyzer/test/src/dart/resolution/dot_shorthand_constructor_invocation_test.dart
@@ -18,18 +18,67 @@ main() {
 @reflectiveTest
 class DotShorthandConstructorInvocationResolutionTest
     extends PubPackageResolutionTest {
-  test_abstract_instantiation() async {
+  test_abstractClass() async {
     await assertErrorsInCode(
       r'''
-Function getFunction() {
-  return .new();
+abstract class Foo<T> {
+  Foo();
+}
+
+void main() {
+  Foo _ = .new();
 }
 ''',
-      [error(diag.instantiateAbstractClass, 34, 6)],
+      [error(diag.instantiateAbstractClass, 60, 6)],
     );
   }
 
-  test_abstract_instantiation_factory() async {
+  test_abstractClass_const() async {
+    await assertErrorsInCode(
+      r'''
+abstract class C {
+  static C fn() => CB.named(1);
+}
+
+class CB implements C {
+  final int x;
+  CB.named(this.x);
+}
+
+void main() {
+  C c = const .fn(1);
+  print(c);
+}
+''',
+      [error(diag.constWithUndefinedConstructor, 145, 2)],
+    );
+  }
+
+  test_abstractClass_const_typeArguments() async {
+    await assertErrorsInCode(
+      r'''
+abstract class C {
+  static C fn() => CB.named(1);
+}
+
+class CB implements C {
+  final int x;
+  CB.named(this.x);
+}
+
+void main() {
+  C c = const .fn<int>(1);
+  print(c);
+}
+''',
+      [
+        error(diag.constWithUndefinedConstructor, 145, 2),
+        error(diag.wrongNumberOfTypeArgumentsDotShorthandConstructor, 147, 5),
+      ],
+    );
+  }
+
+  test_abstractClass_factory() async {
     await assertNoErrorsInCode(r'''
 void main() async {
   var iter = [1, 2];
@@ -65,18 +114,86 @@ DotShorthandConstructorInvocation
 ''');
   }
 
-  test_abstractClass() async {
+  test_abstractClass_factory_const() async {
+    await assertNoErrorsInCode(r'''
+abstract class Foo<T> {
+  const factory Foo.a() = _Foo;
+
+  const Foo();
+}
+
+class _Foo<T> extends Foo<T> {
+  const _Foo();
+}
+
+Foo<T> bar<T>() => const .a();
+''');
+
+    var node = findNode.singleDotShorthandConstructorInvocation;
+    assertResolvedNodeText(node, r'''
+DotShorthandConstructorInvocation
+  constKeyword: const
+  period: .
+  constructorName: SimpleIdentifier
+    token: a
+    element: ConstructorMember
+      baseElement: <testLibrary>::@class::Foo::@constructor::a
+      substitution: {T: Never}
+    staticType: null
+  argumentList: ArgumentList
+    leftParenthesis: (
+    rightParenthesis: )
+  isDotShorthand: true
+  staticType: Foo<Never>
+''');
+  }
+
+  test_abstractClass_factory_const_typeArguments() async {
     await assertErrorsInCode(
       r'''
 abstract class Foo<T> {
+  const factory Foo.a() = _Foo;
+
+  const Foo();
+}
+
+class _Foo<T> extends Foo<T> {
+  const _Foo();
+}
+
+Foo<int> bar<T>() => const .a<int>();
+''',
+      [error(diag.wrongNumberOfTypeArgumentsDotShorthandConstructor, 154, 5)],
+    );
+  }
+
+  test_abstractClass_factory_typeArguments() async {
+    await assertErrorsInCode(
+      r'''
+abstract class Foo<T> {
+  factory Foo.a() = _Foo;
+
   Foo();
 }
 
-void main() {
-  Foo _ = .new();
+class _Foo<T> extends Foo<T> {
+  _Foo();
 }
+
+Foo<T> bar<T>() => .a<T>();
 ''',
-      [error(diag.instantiateAbstractClass, 60, 6)],
+      [error(diag.wrongNumberOfTypeArgumentsDotShorthandConstructor, 128, 3)],
+    );
+  }
+
+  test_abstractClass_function() async {
+    await assertErrorsInCode(
+      r'''
+Function getFunction() {
+  return .new();
+}
+''',
+      [error(diag.instantiateAbstractClass, 34, 6)],
     );
   }
 
@@ -506,7 +623,7 @@ DotShorthandConstructorInvocation
 
   test_factory() async {
     await assertNoErrorsInCode(r'''
-abstract class Foo<T> {
+class Foo<T> {
   factory Foo.a() = _Foo;
 
   Foo();
@@ -517,13 +634,83 @@ class _Foo<T> extends Foo<T> {
 }
 
 Foo<T> bar<T>() => .a();
+''');
+
+    var node = findNode.singleDotShorthandConstructorInvocation;
+    assertResolvedNodeText(node, r'''
+DotShorthandConstructorInvocation
+  period: .
+  constructorName: SimpleIdentifier
+    token: a
+    element: ConstructorMember
+      baseElement: <testLibrary>::@class::Foo::@constructor::a
+      substitution: {T: T}
+    staticType: null
+  argumentList: ArgumentList
+    leftParenthesis: (
+    rightParenthesis: )
+  isDotShorthand: true
+  staticType: Foo<T>
 ''');
   }
 
+  test_factory_const() async {
+    await assertNoErrorsInCode(r'''
+class Foo<T> {
+  const factory Foo.a() = _Foo;
+
+  const Foo();
+}
+
+class _Foo<T> extends Foo<T> {
+  const _Foo();
+}
+
+Foo<T> bar<T>() => const .a();
+''');
+
+    var node = findNode.singleDotShorthandConstructorInvocation;
+    assertResolvedNodeText(node, r'''
+DotShorthandConstructorInvocation
+  constKeyword: const
+  period: .
+  constructorName: SimpleIdentifier
+    token: a
+    element: ConstructorMember
+      baseElement: <testLibrary>::@class::Foo::@constructor::a
+      substitution: {T: Never}
+    staticType: null
+  argumentList: ArgumentList
+    leftParenthesis: (
+    rightParenthesis: )
+  isDotShorthand: true
+  staticType: Foo<Never>
+''');
+  }
+
+  test_factory_const_typeArguments() async {
+    await assertErrorsInCode(
+      r'''
+class Foo<T> {
+  const factory Foo.a() = _Foo;
+
+  const Foo();
+}
+
+class _Foo<T> extends Foo<T> {
+  const _Foo();
+}
+
+Foo<int> bar<T>() => const .a<int>();
+''',
+      [error(diag.wrongNumberOfTypeArgumentsDotShorthandConstructor, 145, 5)],
+    );
+  }
+
   test_factory_typeArguments() async {
     await assertErrorsInCode(
       r'''
-abstract class Foo<T> {
+class Foo<T> {
   factory Foo.a() = _Foo;
 
   Foo();
@@ -535,7 +722,7 @@ class _Foo<T> extends Foo<T> {
 
 Foo<T> bar<T>() => .a<T>();
 ''',
-      [error(diag.wrongNumberOfTypeArgumentsDotShorthandConstructor, 128, 3)],
+      [error(diag.wrongNumberOfTypeArgumentsDotShorthandConstructor, 119, 3)],
     );
   }
 
