Version 2.10.0-104.0.dev

Merge commit '4237fda6a52cb51b93a8968f3b5b4f2599564233' into 'dev'

Author: Dart CI

DEPS

@@ -44,7 +44,7 @@ vars = {
   # co19 is a cipd package. Use update.sh in tests/co19[_2] to update these
   # hashes. It requires access to the dart-build-access group, which EngProd
   # has.
-  "co19_rev": "c99bc4280fe5ea323c4c937fd073c5e2d17fd975",
+  "co19_rev": "d21ed3a1dd64107916db68afdce21709df65e85f",
   "co19_2_rev": "e48b3090826cf40b8037648f19d211e8eab1b4b6",
 
   # The internal benchmarks to use. See go/dart-benchmarks-internal
@@ -112,7 +112,7 @@ vars = {
   "idl_parser_rev": "5fb1ebf49d235b5a70c9f49047e83b0654031eb7",
   "intl_tag": "0.16.1",
   "jinja2_rev": "2222b31554f03e62600cd7e383376a7c187967a1",
-  "json_rpc_2_rev": "995611cf006c927d51cc53cb28f1aa4356d5414f",
+  "json_rpc_2_rev": "8f189db8f0c299187a0e8fa959dba7e9b0254be5",
   "linter_tag": "0.1.118",
   "logging_rev": "9561ba016ae607747ae69b846c0e10958ca58ed4",
   "markupsafe_rev": "8f45f5cfa0009d2a70589bcda0349b8cb2b72783",

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

@@ -4,6 +4,8 @@
 
 library _fe_analyzer_shared.parser.parser;
 
+import 'package:_fe_analyzer_shared/src/parser/type_info_impl.dart';
+
 import '../messages/codes.dart' as codes;
 
 import '../scanner/scanner.dart' show ErrorToken, Token;
@@ -1130,8 +1132,59 @@ class Parser {
       }
       if (optional('=', next)) {
         equals = next;
-        token = computeType(equals, /* required = */ true)
-            .ensureTypeOrVoid(equals, this);
+        TypeInfo type = computeType(equals, /* required = */ true);
+        if (!type.isFunctionType) {
+          // Recovery: In certain cases insert missing 'Function' and missing
+          // parens.
+          Token skippedType = type.skipType(equals);
+          if (optional('(', skippedType.next) &&
+              skippedType.next.endGroup != null &&
+              optional(';', skippedType.next.endGroup.next)) {
+            // Turn "<return type>? '(' <whatever> ')';"
+            // into "<return type>? Function '(' <whatever> ')';".
+            // Assume the type is meant as the return type.
+            Token functionToken =
+                rewriter.insertSyntheticKeyword(skippedType, Keyword.FUNCTION);
+            reportRecoverableError(functionToken,
+                codes.templateExpectedButGot.withArguments('Function'));
+            type = computeType(equals, /* required = */ true);
+          } else if (type is NoType &&
+              optional('<', skippedType.next) &&
+              skippedType.next.endGroup != null) {
+            // Recover these two:
+            // "<whatever>;" => "Function<whatever>();"
+            // "<whatever>(<whatever>);" => "Function<whatever>(<whatever>);"
+            Token endGroup = skippedType.next.endGroup;
+            bool recover = false;
+            if (optional(';', endGroup.next)) {
+              // Missing parenthesis. Insert them.
+              // Turn "<whatever>;" in to "<whatever>();"
+              // Insert missing 'Function' below.
+              reportRecoverableError(endGroup,
+                  missingParameterMessage(MemberKind.FunctionTypeAlias));
+              rewriter.insertParens(endGroup, /*includeIdentifier =*/ false);
+              recover = true;
+            } else if (optional('(', endGroup.next) &&
+                endGroup.next.endGroup != null &&
+                optional(';', endGroup.next.endGroup.next)) {
+              // "<whatever>(<whatever>);". Insert missing 'Function' below.
+              recover = true;
+            }
+
+            if (recover) {
+              // Assume the '<' indicates type arguments to the function.
+              // Insert 'Function' before them.
+              Token functionToken =
+                  rewriter.insertSyntheticKeyword(equals, Keyword.FUNCTION);
+              reportRecoverableError(functionToken,
+                  codes.templateExpectedButGot.withArguments('Function'));
+              type = computeType(equals, /* required = */ true);
+            }
+          } else {
+            // E.g. "typedef j = foo;" -- don't attempt any recovery.
+          }
+        }
+        token = type.ensureTypeOrVoid(equals, this);
       } else {
         // A rewrite caused the = to disappear
         token = parseFormalParametersRequiredOpt(

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

@@ -30,6 +30,10 @@ abstract class TypeInfo {
   /// Return true if the receiver has a trailing `?`.
   bool get isNullable;
 
+  /// Returns true if the type represents a function type, i.e. something like
+  /// void Function foo(int x);
+  bool get isFunctionType;
+
   /// Call this function when the token after [token] must be a type (not void).
   /// This function will call the appropriate event methods on the [Parser]'s
   /// listener to handle the type, inserting a synthetic type reference if

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

@@ -101,6 +101,9 @@ class NoType implements TypeInfo {
   @override
   bool get isNullable => false;
 
+  @override
+  bool get isFunctionType => false;
+
   @override
   Token ensureTypeNotVoid(Token token, Parser parser) {
     parser.reportRecoverableErrorWithToken(
@@ -142,6 +145,9 @@ class PrefixedType implements TypeInfo {
   @override
   bool get isNullable => false;
 
+  @override
+  bool get isFunctionType => false;
+
   @override
   Token ensureTypeNotVoid(Token token, Parser parser) =>
       parseType(token, parser);
@@ -191,6 +197,9 @@ class SimpleNullableTypeWith1Argument extends SimpleTypeWith1Argument {
   @override
   bool get isNullable => true;
 
+  @override
+  bool get isFunctionType => false;
+
   @override
   Token parseTypeRest(Token start, Token token, Parser parser) {
     token = token.next;
@@ -222,6 +231,9 @@ class SimpleTypeWith1Argument implements TypeInfo {
   @override
   bool get isNullable => false;
 
+  @override
+  bool get isFunctionType => false;
+
   @override
   Token ensureTypeNotVoid(Token token, Parser parser) =>
       parseType(token, parser);
@@ -266,6 +278,9 @@ class SimpleNullableType extends SimpleType {
   @override
   bool get isNullable => true;
 
+  @override
+  bool get isFunctionType => false;
+
   @override
   Token parseTypeRest(Token start, Parser parser) {
     Token token = start.next;
@@ -293,6 +308,9 @@ class SimpleType implements TypeInfo {
   @override
   bool get isNullable => false;
 
+  @override
+  bool get isFunctionType => false;
+
   @override
   Token ensureTypeNotVoid(Token token, Parser parser) =>
       parseType(token, parser);
@@ -338,6 +356,9 @@ class VoidType implements TypeInfo {
   @override
   bool get isNullable => false;
 
+  @override
+  bool get isFunctionType => false;
+
   @override
   Token ensureTypeNotVoid(Token token, Parser parser) {
     // Report an error, then parse `void` as if it were a type name.
@@ -462,6 +483,9 @@ class ComplexTypeInfo implements TypeInfo {
   @override
   bool get isNullable => beforeQuestionMark != null;
 
+  @override
+  bool get isFunctionType => gftHasReturnType != null;
+
   @override
   Token ensureTypeNotVoid(Token token, Parser parser) =>
       parseType(token, parser);

pkg/analysis_server/lib/src/computer/computer_signature.dart

@@ -17,10 +17,14 @@ import 'package:analyzer/src/dartdoc/dartdoc_directive_info.dart';
 class DartUnitSignatureComputer {
   final DartdocDirectiveInfo _dartdocInfo;
   final AstNode _node;
+  ArgumentList _argumentList;
   DartUnitSignatureComputer(
       this._dartdocInfo, CompilationUnit _unit, int _offset)
       : _node = NodeLocator(_offset).searchWithin(_unit);
 
+  /// The [ArgumentList] node located by [compute].
+  ArgumentList get argumentList => _argumentList;
+
   bool get offsetIsValid => _node != null;
 
   /// Returns the computed signature information, maybe `null`.
@@ -64,6 +68,8 @@ class DartUnitSignatureComputer {
       return null;
     }
 
+    _argumentList = args;
+
     final parameters =
         execElement.parameters.map((p) => _convertParam(p)).toList();
 
@@ -76,7 +82,9 @@ class DartUnitSignatureComputer {
     return ParameterInfo(
         param.isOptionalPositional
             ? ParameterKind.OPTIONAL
-            : param.isPositional ? ParameterKind.REQUIRED : ParameterKind.NAMED,
+            : param.isPositional
+                ? ParameterKind.REQUIRED
+                : ParameterKind.NAMED,
         param.displayName,
         param.type.getDisplayString(withNullability: false),
         defaultValue: param.defaultValueCode);

pkg/analysis_server/lib/src/lsp/client_configuration.dart

@@ -10,6 +10,13 @@ class LspClientConfiguration {
   bool get enableSdkFormatter => _settings['enableSdkFormatter'] ?? true;
   int get lineLength => _settings['lineLength'];
 
+  /// A preview flag for enabling commit characters for completions.
+  ///
+  /// This is a temporary setting to allow this feature to be tested without
+  /// defaulting to on for everybody.
+  bool get previewCommitCharacters =>
+      _settings['previewCommitCharacters'] ?? false;
+
   void replace(Map<String, dynamic> newConfig) {
     _settings
       ..clear()

pkg/analysis_server/lib/src/lsp/constants.dart

@@ -4,6 +4,19 @@
 
 import 'package:analysis_server/lsp_protocol/protocol_generated.dart';
 
+/// The characters that will cause the editor to automatically commit the selected
+/// completion item.
+///
+/// For example, pressing `(` at the location of `^` in the code below would
+/// automatically commit the functions name and insert a `(` to avoid either having
+/// to press `<enter>` and then `(` or having `()` included in the completion items
+/// `insertText` (which is incorrect when passing a function around rather than
+/// invoking it).
+///
+///     myLongFunctionName();
+///     print(myLong^)
+const dartCompletionCommitCharacters = ['.', '('];
+
 /// Set the characters that will cause the editor to automatically
 /// trigger completion.
 /// TODO(dantup): There are several characters that we want to conditionally
@@ -26,10 +39,11 @@ import 'package:analysis_server/lsp_protocol/protocol_generated.dart';
 /// for the VS Code implementation of this.
 const dartCompletionTriggerCharacters = ['.', '=', '(', r'$'];
 
-/// TODO(dantup): Signature help triggering is even more sensitive to
-/// bad chars, so we'll need to implement the logic described here:
-/// https://github.com/dart-lang/sdk/issues/34241
-const dartSignatureHelpTriggerCharacters = <String>[];
+/// Characters that refresh signature help only if it's already open on the client.
+const dartSignatureHelpRetriggerCharacters = <String>[','];
+
+/// Characters that automatically trigger signature help when typed in the client.
+const dartSignatureHelpTriggerCharacters = <String>['('];
 
 /// Characters to trigger formatting when format-on-type is enabled.
 const dartTypeFormattingCharacters = ['}', ';'];

pkg/analysis_server/lib/src/lsp/handlers/handler_signature_help.dart

@@ -10,22 +10,35 @@ import 'package:analysis_server/src/lsp/lsp_analysis_server.dart';
 import 'package:analysis_server/src/lsp/mapping.dart';
 
 class SignatureHelpHandler
-    extends MessageHandler<TextDocumentPositionParams, SignatureHelp> {
+    extends MessageHandler<SignatureHelpParams, SignatureHelp> {
   SignatureHelpHandler(LspAnalysisServer server) : super(server);
   @override
   Method get handlesMessage => Method.textDocument_signatureHelp;
 
   @override
-  LspJsonHandler<TextDocumentPositionParams> get jsonHandler =>
-      TextDocumentPositionParams.jsonHandler;
+  LspJsonHandler<SignatureHelpParams> get jsonHandler =>
+      SignatureHelpParams.jsonHandler;
 
   @override
   Future<ErrorOr<SignatureHelp>> handle(
-      TextDocumentPositionParams params, CancellationToken token) async {
+      SignatureHelpParams params, CancellationToken token) async {
     if (!isDartDocument(params.textDocument)) {
       return success(null);
     }
 
+    // If triggered automatically by pressing the trigger character, we will
+    // only provide results if the character we typed was the one that actually
+    // starts the argument list. This is to avoid popping open signature help
+    // whenever the user types a `(` that might not be the start of an argument
+    // list, as the client does not have any context and will always send the
+    // request.
+    final autoTriggered = params.context?.triggerKind ==
+            SignatureHelpTriggerKind.TriggerCharacter &&
+        // Retriggers can be ignored (treated as manual invocations) as it's
+        // fine to always generate results if the signature help is already
+        // visible on the client (it will just update, it doesn't pop up new UI).
+        params.context?.isRetrigger == false;
+
     final pos = params.position;
     final path = pathOfDoc(params.textDocument);
     final unit = await path.mapResult(requireResolvedUnit);
@@ -43,6 +56,17 @@ class SignatureHelpHandler
       if (signature == null) {
         return success(); // No error, just no valid hover.
       }
+
+      // Skip results if this was an auto-trigger but not from the start of the
+      // argument list.
+      // The ArgumentList's offset is before the paren, but the request offset
+      // will be after.
+      if (autoTriggered &&
+          computer.argumentList != null &&
+          offset != computer.argumentList.offset + 1) {
+        return success();
+      }
+
       final formats = server?.clientCapabilities?.textDocument?.signatureHelp
           ?.signatureInformation?.documentationFormat;
       return success(toSignatureHelp(formats, signature));

pkg/analysis_server/lib/src/lsp/server_capabilities_computer.dart

@@ -106,6 +106,8 @@ class ServerCapabilitiesComputer {
         clientCapabilities.textDocument?.rename?.prepareSupport ?? false;
 
     final enableFormatter = _server.clientConfiguration.enableSdkFormatter;
+    final previewCommitCharacters =
+        _server.clientConfiguration.previewCommitCharacters;
 
     final dynamicRegistrations = ClientDynamicRegistrations(clientCapabilities);
 
@@ -132,6 +134,9 @@ class ServerCapabilitiesComputer {
           ? null
           : CompletionOptions(
               triggerCharacters: dartCompletionTriggerCharacters,
+              allCommitCharacters: previewCommitCharacters
+                  ? dartCompletionCommitCharacters
+                  : null,
               resolveProvider: true,
             ),
       hoverProvider: dynamicRegistrations.hover
@@ -141,6 +146,7 @@ class ServerCapabilitiesComputer {
           ? null
           : SignatureHelpOptions(
               triggerCharacters: dartSignatureHelpTriggerCharacters,
+              retriggerCharacters: dartSignatureHelpRetriggerCharacters,
             ),
       definitionProvider: dynamicRegistrations.definition
           ? null
@@ -242,6 +248,8 @@ class ServerCapabilitiesComputer {
     final registrations = <Registration>[];
 
     final enableFormatter = _server.clientConfiguration.enableSdkFormatter;
+    final previewCommitCharacters =
+        _server.clientConfiguration.previewCommitCharacters;
 
     /// Helper for creating registrations with IDs.
     void register(bool condition, Method method, [ToJsonable options]) {
@@ -279,6 +287,8 @@ class ServerCapabilitiesComputer {
       CompletionRegistrationOptions(
         documentSelector: allTypes,
         triggerCharacters: dartCompletionTriggerCharacters,
+        allCommitCharacters:
+            previewCommitCharacters ? dartCompletionCommitCharacters : null,
         resolveProvider: true,
       ),
     );
@@ -293,6 +303,7 @@ class ServerCapabilitiesComputer {
       SignatureHelpRegistrationOptions(
         documentSelector: allTypes,
         triggerCharacters: dartSignatureHelpTriggerCharacters,
+        retriggerCharacters: dartSignatureHelpRetriggerCharacters,
       ),
     );
     register(