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

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 73 matching lines @@
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class CompletionTarget {
   /**
    * The compilation unit in which the completion is occurring.
    */
   final CompilationUnit unit;
 
   /**
+   * The offset within the source at which the completion is being requested.
+   */
+  final int offset;
+
+  /**
    * The context in which the completion is occurring.  This is the AST node
    * which is a direct parent of [entity].
    */
   final AstNode containingNode;
 
   /**
    * The entity which the completed text will replace (or which will be
    * displaced once the completed text is inserted).  This may be an AstNode or
    * a Token, or it may be null if the cursor is after all tokens in the file.
    *
@@ skipping 51 matching lines @@
           }
         }
       }
       for (var entity in containingNode.childEntities) {
         if (entity is Token) {
           if (_isCandidateToken(entity, offset)) {
             // Try to replace with a comment token.
             Token commentToken = _getContainingCommentToken(entity, offset);
             if (commentToken != null) {
               return new CompletionTarget._(
-                  compilationUnit, containingNode, commentToken, true);
+                  compilationUnit, offset, containingNode, commentToken, true);
             }
             // Target found.
             return new CompletionTarget._(
-                compilationUnit, containingNode, entity, false);
+                compilationUnit, offset, containingNode, entity, false);
           } else {
             // Since entity is a token, we don't need to look inside it; just
             // proceed to the next entity.
             continue;
           }
         } else if (entity is AstNode) {
           // If the last token in the node isn't a candidate target, then
           // neither the node nor any of its descendants can possibly be the
           // completion target, so we can skip the node entirely.
           if (!_isCandidateToken(entity.endToken, offset)) {
             continue;
           }
 
           // If the node is a candidate target, then we are done.
           if (_isCandidateNode(entity, offset)) {
             // Check to see if the offset is in a preceding comment
             Token commentToken =
                 _getContainingCommentToken(entity.beginToken, offset);
             if (commentToken != null) {
               entity = commentToken;
               // If the preceding comment is dartdoc token, then update
               // the containing node to be the dartdoc comment.
               // Otherwise completion is not required.
               Comment docComment =
                   _getContainingDocComment(containingNode, commentToken);
               if (docComment != null) {
                 containingNode = docComment;
               } else {
-                return new CompletionTarget._(
-                    compilationUnit, compilationUnit, commentToken, true);
+                return new CompletionTarget._(compilationUnit, offset,
+                    compilationUnit, commentToken, true);
               }
             }
             return new CompletionTarget._(
-                compilationUnit, containingNode, entity, false);
+                compilationUnit, offset, containingNode, entity, false);
           }
 
           // Otherwise, the completion target is somewhere inside the entity,
           // so we need to jump to the start of the outer loop to examine its
           // contents.
           containingNode = entity;
           continue outerLoop;
         } else {
           // Unexpected entity found (all entities in a parse tree should be
           // AST nodes or tokens).
           assert(false);
         }
       }
 
       // No completion target found.  It should only be possible to reach here
       // the first time through the outer loop (since we only jump to the start
       // of the outer loop after determining that the completion target is
       // inside an entity).  We can check that assumption by verifying that
       // containingNode is still the compilationUnit.
       assert(identical(containingNode, compilationUnit));
 
       // 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, compilationUnit, null, false);
+          compilationUnit, offset, compilationUnit, null, false);
     }
   }
 
   /**
    * Create a [CompletionTarget] holding the given [containingNode] and
    * [entity].
    */
-  CompletionTarget._(
-      this.unit, AstNode containingNode, Object entity, this.isCommentText)
+  CompletionTarget._(this.unit, this.offset, AstNode containingNode,
+      Object entity, this.isCommentText)
       : this.containingNode = containingNode,
         this.entity = entity,
         this.argIndex = _computeArgIndex(containingNode, entity);
 
   /**
+   * Return `true` if the [containingNode] is a cascade
+   * and the completion insertion is not between the two dots.
+   * For example, `..d^` and `..^d` are considered a cascade
+   * from a completion standpoint, but `.^.d` is not.
+   */
+  bool get isCascade {
+    AstNode node = containingNode;
+    if (node is PropertyAccess) {
+      return node.isCascaded && offset > node.operator.offset + 1;
+    }
+    if (node is MethodInvocation) {
+      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) {
       return false;
     }
     AstNode argList = containingNode;
     if (argList is! ArgumentList) {
       return false;
@@ skipping 127 matching lines @@
       if (param.parameterKind == ParameterKind.NAMED) {
         // TODO(danrubel) handle named parameters
         return false;
       } else {
         return paramType is FunctionType || paramType is FunctionTypeAlias;
       }
     }
     return false;
   }
 }