When target requires a function, propose a function reference, not an invocation

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

 import 'package:analyzer/src/generated/ast.dart';
+import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/scanner.dart';
+import 'package:analyzer/src/generated/utilities_dart.dart';
+
+int _computeArgIndex(AstNode containingNode, Object entity) {
+  var argList = containingNode;
+  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;
+    }
+  }
+  return null;
+}
 
 /**
  * A CompletionTarget represents an edge in the parse tree which connects an
  * AST node (the [containingNode] of the completion) to one of its children
  * (the [entity], which represents the place in the parse tree where the newly
  * completed text will be inserted).
  *
  * To illustrate, consider the following snippet of code, and its associated
  * parse tree.  (T's represent tokens, N's represent AST nodes.  Some trivial
  * AST nodes are not shown).
@@ skipping 59 matching lines @@
    *
    * Usually, the entity won't be the first child of the [containingNode] (this
    * is a consequence of placing the completion target as high in the tree as
    * possible).  However, there is one exception: when the cursor is inside of
    * a multi-character token which is not a keyword or identifier (e.g. a
    * comment, or a token like "+=", the entity will be always be the token.
    */
   final Object entity;
 
   /**
+   * 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].
    */
   factory CompletionTarget.forOffset(
       CompilationUnit compilationUnit, int offset) {
     // 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
@@ skipping 65 matching lines @@
       // Since no completion target was found, we set the completion target
       // entity to null and use the compilationUnit as the parent.
       return new CompletionTarget._(compilationUnit, null);
     }
   }
 
   /**
    * Create a [CompletionTarget] holding the given [containingNode] and
    * [entity].
    */
-  CompletionTarget._(this.containingNode, this.entity);
+  CompletionTarget._(AstNode containingNode, Object entity)
+      : this.containingNode = containingNode,
+        this.entity = entity,
+        this.argIndex = _computeArgIndex(containingNode, entity);
+
+  /**
+   * Return `true` if the target is a functional argument in an argument list.
+   * The target [AstNode] hierarchy *must* be resolved for this to work.
+   */
+  bool isFunctionalArgument() {
+    if (argIndex == null) {
+      return false;
+    }
+    AstNode argList = containingNode;
+    if (argList is! ArgumentList) {
+      return false;
+    }
+    AstNode parent = argList.parent;
+    if (parent is InstanceCreationExpression) {
+      parent.constructorName;

[scheglov, 2015/03/05 20:51:09]

Remove this?

[danrubel, 2015/03/05 21:23:40]

Good eyes! Done.

+      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);
+        }
+      }
+    } 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);
+        } else if (methodElem is FunctionElement) {
+          return _isFunctionalParameter(methodElem.parameters, argIndex);
+        }
+      }
+    }
+    return false;
+  }
 
   /**
    * Determine whether [node] could possibly be the [entity] for a
    * [CompletionTarget] associated with the given [offset].
    */
   static bool _isCandidateNode(AstNode node, int offset) {
     // If the node's first token is a keyword or identifier, then the node is a
     // candidate entity if its first token is.
     Token beginToken = node.beginToken;
     if (beginToken.type == TokenType.KEYWORD ||
@@ skipping 20 matching lines @@
     if (offset < token.end) {
       return true;
     } else if (offset == token.end) {
       return token.type == TokenType.KEYWORD ||
           token.type == TokenType.IDENTIFIER ||
           token.length == 0;
     } else {
       return false;
     }
   }
+
+  /**
+   * Return `true` if the parameter is a functional parameter.
+   */
+  static bool _isFunctionalParameter(
+      List<ParameterElement> parameters, int paramIndex) {
+    if (paramIndex < parameters.length) {
+      ParameterElement param = parameters[paramIndex];
+      DartType paramType = param.type;
+      if (param.parameterKind == ParameterKind.NAMED) {
+        // TODO(danrubel) handle named parameters
+        return false;
+      } else {
+        return paramType is FunctionType || paramType is FunctionTypeAlias;
+      }
+    }
+    return false;
+  }
 }