Remove ReplacementRange

pkg/analyzer_plugin/lib/src/utilities/completion/completion_target.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 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/ast/token.dart';
+import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 
 /**
  * A CompletionTarget represents an edge in the parse tree which connects an
  * AST node (the [containingNode] of the completion) to one of its children
  * (the [entity], which represents the place in the parse tree where the newly
  * completed text will be inserted).
  *
  * To illustrate, consider the following snippet of code, and its associated
  * parse tree.  (T's represent tokens, N's represent AST nodes.  Some trivial
@@ skipping 226 matching lines @@
     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 a source range that represents the region of text that should be
+   * replaced when a suggestion based on this target is selected, given that the
+   * completion was requested at the given [requestOffset].
+   */
+  SourceRange computeReplacementRange(int requestOffset) {
+    bool isKeywordOrIdentifier(Token token) =>
+        token.type.isKeyword || token.type == TokenType.IDENTIFIER;
+
+    Token token = entity is AstNode ? (entity as AstNode).beginToken : entity;
+    if (token != null && requestOffset < token.offset) {
+      token = token.previous;
+    }
+    if (token != null) {
+      if (requestOffset == token.offset && !isKeywordOrIdentifier(token)) {
+        // If the insertion point is at the beginning of the current token
+        // and the current token is not an identifier
+        // then check the previous token to see if it should be replaced
+        token = token.previous;
+      }
+      if (token != null && isKeywordOrIdentifier(token)) {
+        if (token.offset <= requestOffset && requestOffset <= token.end) {
+          // Replacement range for typical identifier completion
+          return new SourceRange(token.offset, token.length);
+        }
+      }
+      if (token is StringToken) {
+        SimpleStringLiteral uri =
+            astFactory.simpleStringLiteral(token, token.lexeme);
+        Keyword keyword = token.previous?.keyword;
+        if (keyword == Keyword.IMPORT ||
+            keyword == Keyword.EXPORT ||
+            keyword == Keyword.PART) {
+          int start = uri.contentsOffset;
+          int end = uri.contentsEnd;
+          if (start <= requestOffset && requestOffset <= end) {
+            // Replacement range for import URI
+            return new SourceRange(start, end - start);
+          }
+        }
+      }
+    }
+    return new SourceRange(requestOffset, 0);
+  }
+
+  /**
    * Return `true` if the target is a functional argument in an argument list.
    * The target [AstNode] hierarchy *must* be resolved for this to work.
    * See [maybeFunctionalArgument].
    */
   bool isFunctionalArgument() {
     if (!maybeFunctionalArgument()) {
       return false;
     }
     AstNode parent = containingNode.parent;
     if (parent is ArgumentList) {
@@ skipping 181 matching lines @@
               orElse: () => null);
           paramType = param?.type;
         }
       } else {
         paramType = param.type;
       }
     }
     return paramType is FunctionType || paramType is FunctionTypeAlias;
   }
 }