move LocalReferenceContributor to new API

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/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';
@@ skipping 248 matching lines @@
       return node.isCascaded && offset > node.operator.offset + 1;
     }
     return false;
   }
 
   /**
    * 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) {
+    if (!maybeFunctionalArgument()) {
       return false;
     }
-    AstNode argList = containingNode;
-    if (argList is! ArgumentList) {
-      return false;
-    }
-    AstNode parent = argList.parent;
+    AstNode parent = containingNode.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);
         }
       }
     } 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;
   }
 
   /**
+   * 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 maybeFunctionalArgument() {
+    if (argIndex == null) {
+      return false;
+    }
+    AstNode argList = containingNode;
+    if (argList is! ArgumentList) {
+      return false;
+    }
+    return true;
+  }
+
+  /**
    * 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;
     }
     if (offset >= token.offset) {
       return null;
     }
@@ skipping 87 matching lines @@
       if (param.parameterKind == ParameterKind.NAMED) {
         // TODO(danrubel) handle named parameters
         return false;
       } else {
         return paramType is FunctionType || paramType is FunctionTypeAlias;
       }
     }
     return false;
   }
 }