[parser/analysis_server] Dot shorthands: Code completion for 'const .'

Parser and analysis server changes for adding code completion for `const .^` where `^` is the cursor location.

I modified the parser to handle recovering when we were parsing a dot shorthand constructor invocation that was incomplete.

Added analyzer tests, code completion tests, and frontend parser tests.

Fixes: #59836
Change-Id: Ia200ebd9149658d7563c4942afd749c262c52dc5
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/446987
Commit-Queue: Kallen Tu <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>
Reviewed-by: Chloe Stefantsova <[email protected]>

Author: kallentu

pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart

@@ -8481,17 +8481,29 @@ class Parser {
       }
     }
 
-    bool isDotShorthand = _isDotShorthand(token.next!);
-    if (isDotShorthand) {
-      Token dot = token.next!;
+    // Handling const dot shorthands.
+    if (next.isA(TokenType.PERIOD)) {
       listener.beginConstDotShorthand(constKeyword);
-      token = parsePrimary(
-        dot,
-        IdentifierContext.expressionContinuation,
-        ConstantPatternContext.explicit,
-      );
-      listener.handleDotShorthandHead(dot);
-      listener.handleDotShorthandContext(dot);
+
+      if (_isDotShorthand(next)) {
+        token = parsePrimary(
+          next,
+          IdentifierContext.expressionContinuation,
+          ConstantPatternContext.explicit,
+        );
+      } else {
+        // Recovery.
+        // This is an incomplete dot shorthand like `C c = const .`.
+        // This allows for better code completion, assuming the user wanted to
+        // write a dot shorthand.
+        token = ensureIdentifier(
+          next,
+          IdentifierContext.expressionContinuation,
+        );
+      }
+
+      listener.handleDotShorthandHead(next);
+      listener.handleDotShorthandContext(next);
       listener.endConstDotShorthand(constKeyword);
       return token;
     }

pkg/analysis_server/lib/src/services/completion/dart/in_scope_completion_pass.dart

@@ -926,6 +926,22 @@ class InScopeCompletionPass extends SimpleAstVisitor<void> {
     }
   }
 
+  @override
+  void visitDotShorthandConstructorInvocation(
+    DotShorthandConstructorInvocation node,
+  ) {
+    var period = node.period;
+    if (offset >= period.end && offset <= node.constructorName.end) {
+      var contextType = _computeContextType(node);
+      if (contextType is! InterfaceType) return;
+      declarationHelper(
+        mustBeConstant: node.isConst,
+        suggestingDotShorthand: true,
+        suggestUnnamedAsNew: true,
+      ).addConstructorNamesForType(type: contextType);
+    }
+  }
+
   @override
   void visitDotShorthandInvocation(DotShorthandInvocation node) {
     var period = node.period;
@@ -937,6 +953,7 @@ class InScopeCompletionPass extends SimpleAstVisitor<void> {
       if (element == null) return;
 
       declarationHelper(
+        mustBeConstant: node.inConstantContext,
         suggestingDotShorthand: true,
         suggestUnnamedAsNew: true,
       ).addStaticMembersOfElement(element);
@@ -956,6 +973,7 @@ class InScopeCompletionPass extends SimpleAstVisitor<void> {
     // can be any of the three.
     declarationHelper(
       suggestingDotShorthand: true,
+      mustBeConstant: node.inConstantContext,
       preferNonInvocation:
           element is InterfaceElement &&
           state.request.shouldSuggestTearOff(element),

pkg/analysis_server/test/services/completion/dart/location/dot_shorthand_constructor_invocation_test.dart

@@ -0,0 +1,78 @@
+// 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.
+
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../../../../client/completion_driver_test.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(DotShorthandConstructorInvocationTest);
+  });
+}
+
+@reflectiveTest
+class DotShorthandConstructorInvocationTest extends AbstractCompletionDriverTest
+    with DotShorthandConstructorInvocationTestCases {}
+
+mixin DotShorthandConstructorInvocationTestCases
+    on AbstractCompletionDriverTest {
+  Future<void> test_constructor_const() async {
+    allowedIdentifiers = {'named', 'notConstant'};
+    await computeSuggestions('''
+class C {
+  const C.named();
+  C.notConstant();
+}
+void f() {
+  C c = const .^
+}
+''');
+    assertResponse(r'''
+suggestions
+  named
+    kind: constructorInvocation
+''');
+  }
+
+  Future<void> test_constructor_const_withPrefix() async {
+    allowedIdentifiers = {'named', 'notConstant'};
+    await computeSuggestions('''
+class C {
+  const C.named();
+  C.notConstant();
+}
+void f() {
+  C c = const .n^
+}
+''');
+    assertResponse(r'''
+replacement
+  left: 1
+suggestions
+  named
+    kind: constructorInvocation
+''');
+  }
+
+  Future<void> test_constructor_const_withPrefix_parentheses() async {
+    allowedIdentifiers = {'named', 'notConstant'};
+    await computeSuggestions('''
+class C {
+  const C.named();
+  C.notConstant();
+}
+void f() {
+  C c = const .n^()
+}
+''');
+    assertResponse(r'''
+replacement
+  left: 1
+suggestions
+  named
+    kind: constructorInvocation
+''');
+  }
+}

pkg/analysis_server/test/services/completion/dart/location/dot_shorthand_invocation_test.dart

@@ -85,6 +85,70 @@ suggestions
 ''');
   }
 
+  Future<void> test_constructor_constantContext() async {
+    allowedIdentifiers = {'named', 'notConstant'};
+    await computeSuggestions('''
+class C {
+  const C.named();
+  C.notConstant();
+}
+void f() {
+  const C c = .^
+}
+''');
+    assertResponse(r'''
+suggestions
+  named
+    kind: constructorInvocation
+  notConstant
+    kind: constructor
+''');
+  }
+
+  Future<void> test_constructor_constantContext_withPrefix() async {
+    allowedIdentifiers = {'named', 'notConstant'};
+    await computeSuggestions('''
+class C {
+  const C.named();
+  C.notConstant();
+}
+void f() {
+  const C c = .n^
+}
+''');
+    assertResponse(r'''
+replacement
+  left: 1
+suggestions
+  named
+    kind: constructorInvocation
+  notConstant
+    kind: constructor
+''');
+  }
+
+  Future<void> test_constructor_constantContext_withPrefix_parentheses() async {
+    allowedIdentifiers = {'named', 'notConstant'};
+    await computeSuggestions('''
+class C {
+  const C.named();
+  C.notConstant();
+}
+void f() {
+  const C c = .n^()
+}
+''');
+    assertResponse(r'''
+replacement
+  left: 1
+suggestions
+  named
+    kind: constructorInvocation
+  notConstant
+    kind: constructor
+''');
+  }
+
   Future<void> test_constructor_extensionType_named() async {
     allowedIdentifiers = {'named'};
     await computeSuggestions('''

pkg/analysis_server/test/services/completion/dart/location/test_all.dart

@@ -22,6 +22,8 @@ import 'constructor_declaration_test.dart' as constructor_declaration;
 import 'constructor_invocation_test.dart' as constructor_invocation;
 import 'dart_doc_test.dart' as dart_doc;
 import 'directive_uri_test.dart' as directive_uri;
+import 'dot_shorthand_constructor_invocation_test.dart'
+    as dot_shorthand_constructor_invocation;
 import 'dot_shorthand_invocation_test.dart' as dot_shorthand_invocation;
 import 'dot_shorthand_property_access_test.dart'
     as dot_shorthand_property_access;
@@ -107,6 +109,7 @@ void main() {
     constructor_invocation.main();
     dart_doc.main();
     directive_uri.main();
+    dot_shorthand_constructor_invocation.main();
     dot_shorthand_invocation.main();
     dot_shorthand_property_access.main();
     enum_constant.main();

pkg/analyzer/lib/src/fasta/ast_builder.dart

@@ -1569,16 +1569,28 @@ class AstBuilder extends StackListener {
       );
     }
 
-    var dotShorthand = pop() as DotShorthandInvocationImpl;
-    push(
-      DotShorthandConstructorInvocationImpl(
-        constKeyword: token,
-        period: dotShorthand.period,
-        constructorName: dotShorthand.memberName,
-        typeArguments: dotShorthand.typeArguments,
-        argumentList: dotShorthand.argumentList,
-      )..isDotShorthand = dotShorthand.isDotShorthand,
-    );
+    var dotShorthand = pop() as Expression;
+    if (dotShorthand is DotShorthandInvocationImpl) {
+      push(
+        DotShorthandConstructorInvocationImpl(
+          constKeyword: token,
+          period: dotShorthand.period,
+          constructorName: dotShorthand.memberName,
+          typeArguments: dotShorthand.typeArguments,
+          argumentList: dotShorthand.argumentList,
+        )..isDotShorthand = dotShorthand.isDotShorthand,
+      );
+    } else if (dotShorthand is DotShorthandPropertyAccessImpl) {
+      push(
+        DotShorthandConstructorInvocationImpl(
+          constKeyword: token,
+          period: dotShorthand.period,
+          constructorName: dotShorthand.propertyName,
+          typeArguments: null,
+          argumentList: _syntheticArgumentList(dotShorthand.propertyName.token),
+        )..isDotShorthand = dotShorthand.isDotShorthand,
+      );
+    }
   }
 
   @override

pkg/analyzer/test/src/dart/analysis/resolve_for_completion_test.dart

@@ -191,6 +191,40 @@ void f(C foo) {var foo.s^.self = C()}
     result.assertResolvedNodes(['void f(C foo) {var foo; .s.self = C();}']);
   }
 
+  test_dotShorthand_const_constructor() async {
+    var result = await _resolveTestCode(r'''
+class C {
+  const C.named();
+}
+void f() {
+  C c = const .^
+}
+''');
+    // TODO(kallentu): The parser shouldn't wrap the
+    // DotShorthandConstructorInvocation in a function expression. This doesn't
+    // produce anything different with code completion that requires this
+    // recovered AST, but it would be nice to avoid the extra wrapping around
+    // the constructor.
+    result.assertResolvedNodes(['void f() {C c = const .()();}']);
+  }
+
+  test_dotShorthand_const_constructor_prefix() async {
+    var result = await _resolveTestCode(r'''
+class C {
+  const C.named();
+}
+void f() {
+  C c = const .name^
+}
+''');
+    // TODO(kallentu): The parser shouldn't wrap the
+    // DotShorthandConstructorInvocation in a function expression. This doesn't
+    // produce anything different with code completion that requires this
+    // recovered AST, but it would be nice to avoid the extra wrapping around
+    // the constructor.
+    result.assertResolvedNodes(['void f() {C c = const .name()();}']);
+  }
+
   test_extension_methodDeclaration_body() async {
     var result = await _resolveTestCode(r'''
 extension E on int {

pkg/analyzer_plugin/lib/src/utilities/completion/optype.dart

@@ -604,9 +604,17 @@ class _OpTypeAstVisitor extends GeneralizingAstVisitor<void> {
     }
   }
 
+  @override
+  void visitDotShorthandConstructorInvocation(
+      DotShorthandConstructorInvocation node) {
+    optype.completionLocation =
+        'DotShorthandConstructorInvocation_constructorName';
+    optype.includeConstructorSuggestions = true;
+  }
+
   @override
   void visitDotShorthandInvocation(DotShorthandInvocation node) {
-    optype.completionLocation = 'DotShorthandPropertyAccess_memberName';
+    optype.completionLocation = 'DotShorthandInvocation_memberName';
     optype.includeReturnValueSuggestions = true;
   }
 

pkg/analyzer_plugin/test/src/utilities/completion/optype_test.dart

@@ -1024,6 +1024,36 @@ main() {new core.String.from^CharCodes([]);}
         returnValue: true);
   }
 
+  Future<void> test_dotShorthandConstructorInvocation() async {
+    addTestSource('''
+class C {
+  const C.named();
+}
+void f() {
+  C c = const .n^
+}
+''');
+    await assertOpType(
+      completionLocation: 'DotShorthandConstructorInvocation_constructorName',
+      constructors: true,
+    );
+  }
+
+  Future<void> test_dotShorthandConstructorInvocation_noTarget() async {
+    addTestSource('''
+class C {
+  const C.named();
+}
+void f() {
+  C c = const .^
+}
+''');
+    await assertOpType(
+      completionLocation: 'DotShorthandConstructorInvocation_constructorName',
+      constructors: true,
+    );
+  }
+
   Future<void> test_dotShorthandInvocation() async {
     addTestSource('''
 class C {
@@ -1034,7 +1064,7 @@ void f() {
 }
 ''');
     await assertOpType(
-      completionLocation: 'DotShorthandPropertyAccess_memberName',
+      completionLocation: 'DotShorthandInvocation_memberName',
       constructors: true,
       returnValue: true,
     );

pkg/front_end/parser_testcases/dot_shorthands/const_no_identifier_recovery.dart

@@ -0,0 +1,7 @@
+class Color {
+  final int x;
+  const Color.red(this.x);
+}
+void main() {
+  Color c = const .;
+}