Update the plugin API

pkg/analyzer_plugin/lib/utilities/completion/type_member_contributor.dart

 // Copyright (c) 2017, 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 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer_plugin/protocol/protocol_common.dart' hide Element;
 import 'package:analyzer_plugin/src/utilities/completion/completion_target.dart';
 import 'package:analyzer_plugin/src/utilities/completion/suggestion_builder.dart';
 import 'package:analyzer_plugin/src/utilities/visitors/local_declaration_visitor.dart';
 import 'package:analyzer_plugin/utilities/completion/completion_core.dart';
 import 'package:analyzer_plugin/utilities/completion/relevance.dart';
 import 'package:analyzer_plugin/utilities/completion/suggestion_builder.dart';
 
 /**
  * A completion contributor that will generate suggestions for instance
  * invocations and accesses.
  */
 class TypeMemberContributor implements CompletionContributor {
   /**
-   * Clients should not overload this function.
+   * Plugin contributors should primarily overload this function.
+   * Should more parameters be needed for autocompletion needs, the
+   * overloaded function should define those parameters and
+   * call on `computeSuggestionsWithEntryPoint`.
    */
-  Future<Null> computeSuggestionsWithEntryPoint(CompletionRequest request,
-      CompletionCollector collector, AstNode entryPoint) async {
+  @override
+  Future<Null> computeSuggestions(
+      DartCompletionRequest request, CompletionCollector collector) async {
     LibraryElement containingLibrary = request.result.libraryElement;
     // Gracefully degrade if the library element is not resolved
     // e.g. detached part file or source change
     if (containingLibrary == null) {
       return;
     }
 
     // Recompute the target since resolution may have changed it
-    Expression expression = _computeDotTarget(request, entryPoint);
+    Expression expression = _computeDotTarget(request, null);
     if (expression == null || expression.isSynthetic) {
       return;
     }
     _computeSuggestions(request, collector, containingLibrary, expression);
   }
 
   /**
-   * Plugin contributors should primarily overload this function.
-   * Should more parameters be needed for autocompletion needs, the
-   * overloaded function should define those parameters and
-   * call on `computeSuggestionsWithEntryPoint`.
+   * Clients should not overload this function.
    */
-  @override
-  Future<Null> computeSuggestions(
-      CompletionRequest request, CompletionCollector collector) async {
+  Future<Null> computeSuggestionsWithEntryPoint(DartCompletionRequest request,
+      CompletionCollector collector, AstNode entryPoint) async {
     LibraryElement containingLibrary = request.result.libraryElement;
     // Gracefully degrade if the library element is not resolved
     // e.g. detached part file or source change
     if (containingLibrary == null) {
       return;
     }
 
     // Recompute the target since resolution may have changed it
-    Expression expression = _computeDotTarget(request, null);
+    Expression expression = _computeDotTarget(request, entryPoint);
     if (expression == null || expression.isSynthetic) {
       return;
     }
     _computeSuggestions(request, collector, containingLibrary, expression);
   }
 
+  /**
+   * Update the completion [target] and [dotTarget] based on the given [unit].
+   */
+  Expression _computeDotTarget(
+      DartCompletionRequest request, AstNode entryPoint) {
+    CompletionTarget target = new CompletionTarget.forOffset(
+        request.result.unit, request.offset,
+        entryPoint: entryPoint);
+    AstNode node = target.containingNode;
+    if (node is MethodInvocation) {
+      if (identical(node.methodName, target.entity)) {
+        return node.realTarget;
+      } else if (node.isCascaded && node.operator.offset + 1 == target.offset) {
+        return node.realTarget;
+      }
+    }
+    if (node is PropertyAccess) {
+      if (identical(node.propertyName, target.entity)) {
+        return node.realTarget;
+      } else if (node.isCascaded && node.operator.offset + 1 == target.offset) {
+        return node.realTarget;
+      }
+    }
+    if (node is PrefixedIdentifier) {
+      if (identical(node.identifier, target.entity)) {
+        return node.prefix;
+      }
+    }
+    return null;
+  }
+
   void _computeSuggestions(
-      CompletionRequest request,
+      DartCompletionRequest request,
       CompletionCollector collector,
       LibraryElement containingLibrary,
       Expression expression) {
     if (expression is Identifier) {
       Element element = expression.bestElement;
       if (element is ClassElement) {
         // Suggestions provided by StaticMemberContributor
         return;
       }
       if (element is PrefixElement) {
@@ skipping 48 matching lines @@
       type = request.result.typeProvider.objectType;
     }
 
     // Build the suggestions
     if (type is InterfaceType) {
       _SuggestionBuilder builder = new _SuggestionBuilder(
           request.resourceProvider, collector, containingLibrary);
       builder.buildSuggestions(type, containingMethodName);
     }
   }
-
-  /**
-   * Update the completion [target] and [dotTarget] based on the given [unit].
-   */
-  Expression _computeDotTarget(CompletionRequest request, AstNode entryPoint) {
-    CompletionTarget target = new CompletionTarget.forOffset(
-        request.result.unit, request.offset,
-        entryPoint: entryPoint);
-    AstNode node = target.containingNode;
-    if (node is MethodInvocation) {
-      if (identical(node.methodName, target.entity)) {
-        return node.realTarget;
-      } else if (node.isCascaded && node.operator.offset + 1 == target.offset) {
-        return node.realTarget;
-      }
-    }
-    if (node is PropertyAccess) {
-      if (identical(node.propertyName, target.entity)) {
-        return node.realTarget;
-      } else if (node.isCascaded && node.operator.offset + 1 == target.offset) {
-        return node.realTarget;
-      }
-    }
-    if (node is PrefixedIdentifier) {
-      if (identical(node.identifier, target.entity)) {
-        return node.prefix;
-      }
-    }
-    return null;
-  }
 }
 
 /**
  * An [AstVisitor] which looks for a declaration with the given name
  * and if found, tries to determine a type for that declaration.
  */
 class _LocalBestTypeVisitor extends LocalDeclarationVisitor {
   /**
    * The name for the declaration to be found.
    */
@@ skipping 310 matching lines @@
       // in the reverse order.
       typesToVisit.addAll(nextType.interfaces);
       if (nextType.superclass != null) {
         typesToVisit.add(nextType.superclass);
       }
       typesToVisit.addAll(nextType.mixins);
     }
     return result;
   }
 }