suggest method references in named expressions

pkg/analysis_server/lib/src/provisional/completion/dart/completion_target.dart

 // Copyright (c) 2015, 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.
 
 library analysis_server.src.provisional.completion.dart.completion_target;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 
 int _computeArgIndex(AstNode containingNode, Object entity) {
   var argList = containingNode;
+  if (argList is NamedExpression) {
+    entity = argList;
+    argList = argList.parent;
+  }
   if (argList is ArgumentList) {
     NodeList<Expression> args = argList.arguments;
     for (int index = 0; index < args.length; ++index) {
       if (entity == args[index]) {
         return index;
       }
     }
     if (args.isEmpty) {
       return 0;
     }
@@ skipping 105 matching lines @@
 
   /**
    * If the target is an argument in an [ArgumentList], then this is the index
    * of the argument in the list, otherwise this is `null`.
    */
   final int argIndex;
 
   /**
    * Compute the appropriate [CompletionTarget] for the given [offset] within
    * the [compilationUnit].
-   * 
+   *
    * Optionally, start the search from within [entryPoint] instead of using
    * the [compilationUnit], which is useful for analyzing ASTs that have no
    * [compilationUnit] such as dart expressions within angular templates.
    */
   factory CompletionTarget.forOffset(
-      CompilationUnit compilationUnit, int offset, {AstNode entryPoint}) {
+      CompilationUnit compilationUnit, int offset,
+      {AstNode entryPoint}) {
     // The precise algorithm is as follows.  We perform a depth-first search of
     // all edges in the parse tree (both those that point to AST nodes and
     // those that point to tokens), visiting parents before children.  The
     // first edge which points to an entity satisfying either _isCandidateToken
     // or _isCandidateNode is the completion target.  If no edge is found that
     // satisfies these two predicates, then we set the completion target entity
     // to null and the containingNode to the entryPoint.
     //
     // Note that if a token is not a candidate target, then none of the tokens
     // that precede it are candidate targets either.  Therefore any entity
     // whose last token is not a candidate target can be skipped.  This lets us
     // prune the search to the point where no recursion is necessary; at each
     // step in the process we know exactly which child node we need to proceed
     // to.
     entryPoint ??= compilationUnit;
     AstNode containingNode = entryPoint;
-    outerLoop: while (true) {
+    outerLoop:
+    while (true) {
       if (containingNode is Comment) {
         // Comments are handled specially: we descend into any CommentReference
         // child node that contains the cursor offset.
         Comment comment = containingNode;
         for (CommentReference commentReference in comment.references) {
           if (commentReference.offset <= offset &&
               offset <= commentReference.end) {
             containingNode = commentReference;
             continue outerLoop;
           }
@@ skipping 103 matching lines @@
   /**
    * Return `true` if the target is a functional argument in an argument list.
    * The target [AstNode] hierarchy *must* be resolved for this to work.
    * See [maybeFunctionalArgument].
    */
   bool isFunctionalArgument() {
     if (!maybeFunctionalArgument()) {
       return false;
     }
     AstNode parent = containingNode.parent;
+    if (parent is ArgumentList) {
+      parent = parent.parent;
+    }
     if (parent is InstanceCreationExpression) {
       DartType instType = parent.bestType;
       if (instType != null) {
         Element intTypeElem = instType.element;
         if (intTypeElem is ClassElement) {
           SimpleIdentifier constructorName = parent.constructorName.name;
           ConstructorElement constructor = constructorName != null
               ? intTypeElem.getNamedConstructor(constructorName.name)
               : intTypeElem.unnamedConstructor;
           return constructor != null &&
-              _isFunctionalParameter(constructor.parameters, argIndex);
+              _isFunctionalParameter(
+                  constructor.parameters, argIndex, containingNode);
         }
       }
     } else if (parent is MethodInvocation) {
       SimpleIdentifier methodName = parent.methodName;
       if (methodName != null) {
         Element methodElem = methodName.bestElement;
         if (methodElem is MethodElement) {
-          return _isFunctionalParameter(methodElem.parameters, argIndex);
+          return _isFunctionalParameter(
+              methodElem.parameters, argIndex, containingNode);
         } else if (methodElem is FunctionElement) {
-          return _isFunctionalParameter(methodElem.parameters, argIndex);
+          return _isFunctionalParameter(
+              methodElem.parameters, argIndex, containingNode);
         }
       }
     }
     return false;
   }
 
   /**
    * Return `true` if the target maybe a functional argument in an argument list.
    * This is used in determining whether the target [AstNode] hierarchy
    * needs to be resolved so that [isFunctionalArgument] will work.
    */
   bool maybeFunctionalArgument() {
-    if (argIndex == null) {
-      return false;
+    if (argIndex != null) {
+      if (containingNode is ArgumentList) {
+        return true;
+      }
+      if (containingNode is NamedExpression) {
+        if (containingNode.parent is ArgumentList) {
+          return true;
+        }
+      }
     }
-    AstNode argList = containingNode;
-    if (argList is! ArgumentList) {
-      return false;
-    }
-    return true;
+    return false;
   }
 
   /**
    * Determine if the offset is contained in a preceding comment token
    * and return that token, otherwise return `null`.
    */
   static Token _getContainingCommentToken(Token token, int offset) {
     if (token == null) {
       return null;
     }
@@ skipping 75 matching lines @@
       return token.type == TokenType.KEYWORD ||
           previous.type == TokenType.IDENTIFIER;
     } else {
       return false;
     }
   }
 
   /**
    * Return `true` if the parameter is a functional parameter.
    */
-  static bool _isFunctionalParameter(
-      List<ParameterElement> parameters, int paramIndex) {
+  static bool _isFunctionalParameter(List<ParameterElement> parameters,
+      int paramIndex, AstNode containingNode) {
+    DartType paramType;
     if (paramIndex < parameters.length) {
       ParameterElement param = parameters[paramIndex];
-      DartType paramType = param.type;
       if (param.parameterKind == ParameterKind.NAMED) {
-        // TODO(danrubel) handle named parameters
-        return false;
+        if (containingNode is NamedExpression) {
+          String name = containingNode.name?.label?.name;
+          param = parameters.firstWhere(
+              (ParameterElement param) =>
+                  param.parameterKind == ParameterKind.NAMED &&
+                  param.name == name,
+              orElse: () => null);
+          paramType = param?.type;
+        }
       } else {
-        return paramType is FunctionType || paramType is FunctionTypeAlias;
+        paramType = param.type;
       }
     }
-    return false;
+    return paramType is FunctionType || paramType is FunctionTypeAlias;
   }
 }