Change to accommade Angular plugin and finalize removal of dependency to analysis_server

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.
+   */
+  Future<Null> computeSuggestionsWithEntryPoint(CompletionRequest 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, entryPoint);
+    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`.
+   */
   @override
   Future<Null> computeSuggestions(
       CompletionRequest 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);
+    Expression expression = _computeDotTarget(request, null);
     if (expression == null || expression.isSynthetic) {
       return;
     }
+    _computeSuggestions(request, collector, containingLibrary, expression);
+  }
+
+  void _computeSuggestions(
+      CompletionRequest 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) {
         // Suggestions provided by LibraryMemberContributor
         return;
       }
@@ skipping 49 matching lines @@
     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) {
-    CompletionTarget target =
-        new CompletionTarget.forOffset(request.result.unit, request.offset);
+  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)) {
@@ skipping 332 matching lines @@
       // in the reverse order.
       typesToVisit.addAll(nextType.interfaces);
       if (nextType.superclass != null) {
         typesToVisit.add(nextType.superclass);
       }
       typesToVisit.addAll(nextType.mixins);
     }
     return result;
   }
 }