do not suggest completions for cascade on library prefix - fixes #25215

pkg/analysis_server/lib/src/services/completion/dart/completion_manager.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 services.completion.dart.manager;
 
 import 'dart:async';
 
 import 'package:analysis_server/plugin/protocol/protocol.dart';
 import 'package:analysis_server/src/provisional/completion/completion_core.dart'
@@ skipping 50 matching lines @@
     implements DartCompletionRequest {
   /**
    * The source for the library containing the completion request.
    * This may be different from the source in which the completion is requested
    * if the completion is being requested in a part file.
    * This may be `null` if the library for a part file cannot be determined.
    */
   Source _librarySource;
 
   /**
-   * The cached completion target or `null` if not computed yet.
-   */
-  CompletionTarget _target;
-
-  /**
    * The [DartType] for Object in dart:core
    */
   InterfaceType _objectType;
 
   /**
    * `true` if [resolveDeclarationsInScope] has partially resolved the unit
    * referenced by [target], else `false`.
    */
   bool _haveResolveDeclarationsInScope = false;
 
+  @override
+  Expression dotTarget;
+
+  @override
+  CompletionTarget target;
+
   /**
    * Initialize a newly created completion request based on the given request.
    */
   factory DartCompletionRequestImpl.forRequest(CompletionRequest request) {
     return new DartCompletionRequestImpl._(
         request.context,
         request.resourceProvider,
         request.searchEngine,
         request.source,
         request.offset);
   }
 
   DartCompletionRequestImpl._(
       AnalysisContext context,
       ResourceProvider resourceProvider,
       SearchEngine searchEngine,
       Source source,
       int offset)
       : super(context, resourceProvider, searchEngine, source, offset) {
+    _updateTargets(context.computeResult(source, PARSED_UNIT));
     if (target.unit.directives.any((d) => d is PartOfDirective)) {
       List<Source> libraries = context.getLibrariesContaining(source);
       if (libraries.isNotEmpty) {
         _librarySource = libraries[0];
       }
     } else {
       _librarySource = source;
     }
   }
 
@@ skipping 14 matching lines @@
   InterfaceType get objectType {
     if (_objectType == null) {
       Source coreUri = context.sourceFactory.forUri('dart:core');
       LibraryElement coreLib = context.getLibraryElement(coreUri);
       _objectType = coreLib.getType('Object').type;
     }
     return _objectType;
   }
 
   @override
-  CompletionTarget get target {
-    if (_target == null) {
-      CompilationUnit unit = context.computeResult(source, PARSED_UNIT);
-      _target = new CompletionTarget.forOffset(unit, offset);
-    }
-    return _target;
-  }
-
-  @override
   Future<CompilationUnit> resolveDeclarationsInScope() async {
     CompilationUnit unit = target.unit;
     if (_haveResolveDeclarationsInScope) {
       return unit;
     }
 
     // Gracefully degrade if librarySource cannot be determined
     if (_librarySource == null) {
       return null;
     }
 
     // Resolve declarations in the target unit
     CompilationUnit resolvedUnit =
         await new AnalysisFutureHelper<CompilationUnit>(context,
                 new LibrarySpecificUnit(_librarySource, source), RESOLVED_UNIT3)
             .computeAsync();
 
     // TODO(danrubel) determine if the underlying source has been modified
     // in a way that invalidates the completion request
     // and return null
 
     // Gracefully degrade if unit cannot be resolved
     if (resolvedUnit == null) {
       return null;
     }
 
     // Recompute the target for the newly resolved unit
-    _target = new CompletionTarget.forOffset(resolvedUnit, offset);
+    _updateTargets(resolvedUnit);
     _haveResolveDeclarationsInScope = true;
     return resolvedUnit;
   }
 
   @override
   Future<List<Directive>> resolveDirectives() async {
     CompilationUnit libUnit;
     if (_librarySource == source) {
       libUnit = await resolveDeclarationsInScope();
     } else if (_librarySource != null) {
-      libUnit =
-          await new AnalysisFutureHelper<CompilationUnit>(
-                  context,
-                  new LibrarySpecificUnit(_librarySource, _librarySource),
-                  RESOLVED_UNIT3)
-              .computeAsync();
+      libUnit = await new AnalysisFutureHelper<CompilationUnit>(
+              context,
+              new LibrarySpecificUnit(_librarySource, _librarySource),
+              RESOLVED_UNIT3)
+          .computeAsync();
     }
     return libUnit?.directives;
   }
 
   @override
   Future resolveExpression(Expression expression) async {
     //TODO(danrubel) resolve the expression or containing method
     // rather than the entire complilation unit
 
     // Gracefully degrade if librarySource cannot be determined
@@ skipping 10 matching lines @@
     // TODO(danrubel) determine if the underlying source has been modified
     // in a way that invalidates the completion request
     // and return null
 
     // Gracefully degrade if unit cannot be resolved
     if (resolvedUnit == null) {
       return null;
     }
 
     // Recompute the target for the newly resolved unit
-    _target = new CompletionTarget.forOffset(resolvedUnit, offset);
+    _updateTargets(resolvedUnit);
     _haveResolveDeclarationsInScope = true;
   }
+
+  /**
+   * Update the completion [target] and [dotTarget] based on the given [unit].
+   */
+  void _updateTargets(CompilationUnit unit) {
+    dotTarget = null;
+    target = new CompletionTarget.forOffset(unit, offset);
+    AstNode node = target.containingNode;
+    if (node is MethodInvocation) {
+      if (identical(node.methodName, target.entity)) {
+        dotTarget = node.realTarget;
+      } else if (node.isCascaded && node.operator.offset + 1 == target.offset) {
+        dotTarget = node.realTarget;
+      }
+    }
+    if (node is PropertyAccess) {
+      if (identical(node.propertyName, target.entity)) {
+        dotTarget = node.realTarget;
+      } else if (node.isCascaded && node.operator.offset + 1 == target.offset) {
+        dotTarget = node.realTarget;
+      }
+    }
+    if (node is PrefixedIdentifier) {
+      if (identical(node.identifier, target.entity)) {
+        dotTarget = node.prefix;
+      }
+    }
+  }
 }