use CompletionTarget for replacement offset/length

pkg/analysis_server/test/services/completion/completion_test_util.dart

 // Copyright (c) 2014, 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 test.services.completion.util;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol.dart' as protocol show Element,
     ElementKind;
 import 'package:analysis_server/src/protocol.dart' hide Element, ElementKind;
 import 'package:analysis_server/src/services/completion/completion_manager.dart';
-import 'package:analysis_server/src/services/completion/completion_target.dart';
 import 'package:analysis_server/src/services/completion/dart_completion_cache.dart';
 import 'package:analysis_server/src/services/completion/dart_completion_manager.dart';
 import 'package:analysis_server/src/services/completion/imported_computer.dart';
 import 'package:analysis_server/src/services/completion/invocation_computer.dart';
 import 'package:analysis_server/src/services/completion/local_computer.dart';
 import 'package:analysis_server/src/services/index/index.dart';
 import 'package:analysis_server/src/services/index/local_memory_index.dart';
 import 'package:analysis_server/src/services/search/search_engine_internal.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 14 matching lines @@
   SearchEngineImpl searchEngine;
   DartCompletionComputer computer;
   String testFile = '/completionTest.dart';
   Source testSource;
   CompilationUnit testUnit;
   int completionOffset;
   AstNode completionNode;
   bool _computeFastCalled = false;
   DartCompletionRequest request;
   DartCompletionCache cache;
+  DartCompletionManager _completionManager;
 
   void addResolvedUnit(String file, String code) {
     Source source = addSource(file, code);
     CompilationUnit unit = resolveLibraryUnit(source);
     index.indexUnit(context, unit);
   }
 
   void addTestSource(String content) {
     expect(completionOffset, isNull, reason: 'Call addTestUnit exactly once');
     completionOffset = content.indexOf('^');
@@ skipping 420 matching lines @@
     if (computer is ImportedComputer) {
       assertSuggestGetter(name, returnType);
       assertSuggestSetter(name);
     } else {
       assertNotSuggested(name);
     }
   }
 
   bool computeFast() {
     _computeFastCalled = true;
-    testUnit = context.parseCompilationUnit(testSource);
-    completionNode =
-        new NodeLocator.con1(completionOffset).searchWithin(testUnit);
-    request.unit = testUnit;
-    request.node = completionNode;
-    request.target = new CompletionTarget.forOffset(testUnit, completionOffset);
-    return computer.computeFast(request);
+    _completionManager = new DartCompletionManager(
+        context,
+        searchEngine,
+        testSource,
+        cache,
+        [computer]);
+    var result = _completionManager.computeFast(request);
+    if (request.replacementOffset == null) {
+      fail('expected non null');
+    }
+    return result.isEmpty;
   }
 
   Future computeFull(assertFunction(bool result), {bool fullAnalysis: true}) {
     if (!_computeFastCalled) {
       expect(computeFast(), isFalse);
     }
 
     // Index SDK
     for (Source librarySource in context.librarySources) {
       CompilationUnit unit =
@@ skipping 19 matching lines @@
       List<Source> libSourceList = context.getLibrariesContaining(testSource);
       if (libSourceList.length > 0) {
         LibraryElement library = context.getLibraryElement(libSourceList[0]);
         if (library != null) {
           CompilationUnit unit =
               context.getResolvedCompilationUnit(testSource, library);
           if (unit != null) {
             request.unit = unit;
             request.node =
                 new NodeLocator.con1(completionOffset).searchWithin(unit);
-            if (request.node is SimpleIdentifier) {
-              request.replacementOffset = request.node.offset;
-              request.replacementLength = request.node.length;
-            } else {
-              request.replacementOffset = request.offset;
-              request.replacementLength = 0;
-            }
-            if (request.replacementOffset == null) {
-              fail('expected non null');
-            }
             resolved = true;
             if (!fullAnalysis) {
               break;
             }
           }
         }
       }
 
       result = context.performAnalysisTask();
     }
@@ skipping 330 matching lines @@
       library A;
       bool hasLength(int expected) { }
       void baz() { }''');
     addTestSource('''
       import '/libA.dart';
       class B { }
       String bar() => true;
       void main() {expect(^)}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
       assertSuggestLocalFunction('bar', 'String');
       assertSuggestImportedFunction('hasLength', 'bool');
       assertSuggestImportedFunction('identical', 'bool');
       assertSuggestLocalClass('B');
       assertSuggestImportedClass('Object');
       assertNotSuggested('main');
       assertNotSuggested('baz');
       assertNotSuggested('print');
     });
   }
 
   test_ArgumentList_imported_function() {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
     addSource('/libA.dart', '''
       library A;
       bool hasLength(int expected) { }
       expect(arg) { }
       void baz() { }''');
     addTestSource('''
       import '/libA.dart'
       class B { }
       String bar() => true;
       void main() {expect(^)}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
       assertSuggestLocalFunction('bar', 'String');
       assertSuggestImportedFunction('hasLength', 'bool');
       assertSuggestImportedFunction('identical', 'bool');
       assertSuggestLocalClass('B');
       assertSuggestImportedClass('Object');
       assertNotSuggested('main');
       assertNotSuggested('baz');
       assertNotSuggested('print');
     });
   }
 
   test_ArgumentList_local_function() {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
     addSource('/libA.dart', '''
       library A;
       bool hasLength(int expected) { }
       void baz() { }''');
     addTestSource('''
       import '/libA.dart'
       expect(arg) { }
       class B { }
       String bar() => true;
       void main() {expect(^)}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
       assertSuggestLocalFunction('bar', 'String');
       assertSuggestImportedFunction('hasLength', 'bool');
       assertSuggestImportedFunction('identical', 'bool');
       assertSuggestLocalClass('B');
       assertSuggestImportedClass('Object');
       assertNotSuggested('main');
       assertNotSuggested('baz');
       assertNotSuggested('print');
     });
   }
 
   test_ArgumentList_local_method() {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
     addSource('/libA.dart', '''
       library A;
       bool hasLength(int expected) { }
       void baz() { }''');
     addTestSource('''
       import '/libA.dart'
       class B {
         expect(arg) { }
         void foo() {expect(^)}}
       String bar() => true;''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertNoSuggestions(kind: CompletionSuggestionKind.ARGUMENT_LIST);
       assertSuggestLocalFunction('bar', 'String');
       assertSuggestImportedFunction('hasLength', 'bool');
       assertSuggestImportedFunction('identical', 'bool');
       assertSuggestLocalClass('B');
       assertSuggestImportedClass('Object');
       assertNotSuggested('main');
       assertNotSuggested('baz');
       assertNotSuggested('print');
     });
   }
 
   test_ArgumentList_namedParam() {
     // SimpleIdentifier  NamedExpression  ArgumentList  MethodInvocation
     // ExpressionStatement
     addSource('/libA.dart', '''
       library A;
       bool hasLength(int expected) { }''');
     addTestSource('''
       import '/libA.dart'
       String bar() => true;
       void main() {expect(foo: ^)}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestLocalFunction('bar', 'String');
       assertSuggestImportedFunction('hasLength', 'bool');
       assertNotSuggested('main');
     });
   }
 
   test_AsExpression() {
     // SimpleIdentifier  TypeName  AsExpression
     addTestSource('''
       class A {var b; X _c; foo() {var a; (a as ^).foo();}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertNotSuggested('b');
       assertNotSuggested('_c');
       assertSuggestImportedClass('Object');
       assertSuggestLocalClass('A');
       assertNotSuggested('==');
     });
   }
 
   test_AssignmentExpression_name() {
     // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement  Block
     addTestSource('class A {} main() {int a; int ^b = 1;}');
     computeFast();
     return computeFull((bool result) {
       assertNoSuggestions();
     });
   }
 
   test_AssignmentExpression_RHS() {
     // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement  Block
     addTestSource('class A {} main() {int a; int b = ^}');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestLocalVariable('a', 'int');
       assertSuggestLocalFunction('main', null);
       assertSuggestLocalClass('A');
       assertSuggestImportedClass('Object');
     });
   }
 
   test_AssignmentExpression_type() {
     // SimpleIdentifier  TypeName  VariableDeclarationList
     // VariableDeclarationStatement  Block
     addTestSource('''
       class A {} main() {
         int a;
         ^ b = 1;}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestLocalClass('A');
       assertSuggestImportedClass('int');
       // TODO (danrubel) When entering 1st of 2 identifiers on assignment LHS
       // the user may be either (1) entering a type for the assignment
       // or (2) starting a new statement.
       // Consider suggesting only types
       // if only spaces separates the 1st and 2nd identifiers.
       //assertNotSuggested('a');
       //assertNotSuggested('main');
       //assertNotSuggested('identical');
     });
   }
 
   test_AssignmentExpression_type_newline() {
     // SimpleIdentifier  TypeName  VariableDeclarationList
     // VariableDeclarationStatement  Block
     addTestSource('''
       class A {} main() {
         int a;
         ^
         b = 1;}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestLocalClass('A');
       assertSuggestImportedClass('int');
       // Allow non-types preceding an identifier on LHS of assignment
       // if newline follows first identifier
       // because user is probably starting a new statement
       assertSuggestLocalVariable('a', 'int');
       assertSuggestLocalFunction('main', null);
       assertSuggestImportedFunction('identical', 'bool');
     });
   }
 
   test_AssignmentExpression_type_partial() {
     // SimpleIdentifier  TypeName  VariableDeclarationList
     // VariableDeclarationStatement  Block
     addTestSource('''
       class A {} main() {
         int a;
         int^ b = 1;}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset - 3);
+      expect(request.replacementLength, 3);
       assertSuggestLocalClass('A');
       assertSuggestImportedClass('int');
       // TODO (danrubel) When entering 1st of 2 identifiers on assignment LHS
       // the user may be either (1) entering a type for the assignment
       // or (2) starting a new statement.
       // Consider suggesting only types
       // if only spaces separates the 1st and 2nd identifiers.
       //assertNotSuggested('a');
       //assertNotSuggested('main');
       //assertNotSuggested('identical');
     });
   }
 
   test_AssignmentExpression_type_partial_newline() {
     // SimpleIdentifier  TypeName  VariableDeclarationList
     // VariableDeclarationStatement  Block
     addTestSource('''
       class A {} main() {
         int a;
         i^
         b = 1;}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset - 1);
+      expect(request.replacementLength, 1);
       assertSuggestLocalClass('A');
       assertSuggestImportedClass('int');
       // Allow non-types preceding an identifier on LHS of assignment
       // if newline follows first identifier
       // because user is probably starting a new statement
       assertSuggestLocalVariable('a', 'int');
       assertSuggestLocalFunction('main', null);
       assertSuggestImportedFunction('identical', 'bool');
     });
   }
 
   test_AwaitExpression() {
     // SimpleIdentifier  AwaitExpression  ExpressionStatement
     addTestSource('''
       class A {int x; int y() => 0;}
       main(){A a; await ^}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestLocalVariable('a', 'A');
       assertSuggestLocalFunction('main', null);
       assertSuggestLocalClass('A');
       assertSuggestImportedClass('Object');
     });
   }
 
   test_BinaryExpression_LHS() {
     // SimpleIdentifier  BinaryExpression  VariableDeclaration
     // VariableDeclarationList  VariableDeclarationStatement
     addTestSource('main() {int a = 1, b = ^ + 2;}');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestLocalVariable('a', 'int');
       assertSuggestImportedClass('Object');
       assertNotSuggested('b');
     });
   }
 
   test_BinaryExpression_RHS() {
     // SimpleIdentifier  BinaryExpression  VariableDeclaration
     // VariableDeclarationList  VariableDeclarationStatement
     addTestSource('main() {int a = 1, b = 2 + ^;}');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestLocalVariable('a', 'int');
       assertSuggestImportedClass('Object');
       assertNotSuggested('b');
       assertNotSuggested('==');
     });
   }
 
   test_Block() {
     // Block  BlockFunctionBody  MethodDeclaration
     addSource('/testAB.dart', '''
@@ skipping 30 matching lines @@
         a() {
           var f;
           localF(int arg1) { }
           {var x;}
           ^ var r;
         }
         void b() { }}
       class Z { }''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
 
       assertSuggestLocalClass('X');
       assertSuggestLocalClass('Z');
       assertLocalSuggestMethod('a', 'X', null);
       assertLocalSuggestMethod('b', 'X', 'void');
       assertSuggestLocalFunction('localF', null);
       assertSuggestLocalVariable('f', null);
       // Don't suggest locals out of scope
       assertNotSuggested('r');
       assertNotSuggested('x');
@@ skipping 60 matching lines @@
       import "/testCD.dart" hide D;
       import "/testEEF.dart" show EE;
       import "/testG.dart" as g;
       int T5;
       var _T6;
       Z D2() {int x;}
       class X {a() {var f; {var x;} D^ var r;} void b() { }}
       class Z { }''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset - 1);
+      expect(request.replacementLength, 1);
 
       assertSuggestLocalClass('X');
       assertSuggestLocalClass('Z');
       assertLocalSuggestMethod('a', 'X', null);
       assertLocalSuggestMethod('b', 'X', 'void');
       assertSuggestLocalVariable('f', null);
       // Don't suggest locals out of scope
       assertNotSuggested('r');
       assertNotSuggested('x');
 
@@ skipping 36 matching lines @@
       lib B;
       class F { var f1; f2() { } get f3 => 0; set f4(fx) { } }
       class E extends F { var e1; e2() { } }
       class I { int i1; i2() { } }
       class M { var m1; int m2() { } }''');
     addTestSource('''
       import "/testB.dart";
       class A extends E implements I with M {a() {^}}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       // TODO (danrubel) prefer fields over getters
       // If add `get e1;` to interface I
       // then suggestions include getter e1 rather than field e1
       assertSuggestImportedField('e1', null);
       assertSuggestImportedField('f1', null);
       assertSuggestImportedField('i1', 'int');
       assertSuggestImportedField('m1', null);
       assertSuggestImportedGetter('f3', null);
       assertSuggestImportedSetter('f4');
       assertSuggestImportedMethod('e2', 'E', null);
       assertSuggestImportedMethod('f2', 'F', null);
       assertSuggestImportedMethod('i2', 'I', null);
       //assertSuggestImportedMethod('m2', null, null);
       assertNotSuggested('==');
     });
   }
 
   test_Block_inherited_local() {
     // Block  BlockFunctionBody  MethodDeclaration  ClassDeclaration
     addTestSource('''
       class F { var f1; f2() { } get f3 => 0; set f4(fx) { } }
       class E extends F { var e1; e2() { } }
       class I { int i1; i2() { } }
       class M { var m1; int m2() { } }
       class A extends E implements I with M {a() {^}}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestLocalField('e1', null);
       assertSuggestLocalField('f1', null);
       assertSuggestLocalField('i1', 'int');
       assertSuggestLocalField('m1', null);
       assertSuggestLocalGetter('f3', null);
       assertSuggestLocalSetter('f4');
       assertSuggestLocalMethod('e2', 'E', null);
       assertSuggestLocalMethod('f2', 'F', null);
       assertSuggestLocalMethod('i2', 'I', null);
       assertSuggestLocalMethod('m2', 'M', 'int');
     });
   }
 
   test_CascadeExpression_selector1() {
     // PropertyAccess  CascadeExpression  ExpressionStatement  Block
     addSource('/testB.dart', '''
       class B { }''');
     addTestSource('''
       import "/testB.dart";
       class A {var b; X _c;}
       class X{}
       // looks like a cascade to the parser
       // but the user is trying to get completions for a non-cascade
       main() {A a; a.^.z}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestInvocationField('b', null);
       assertSuggestInvocationField('_c', 'X');
       assertNotSuggested('Object');
       assertNotSuggested('A');
       assertNotSuggested('B');
       assertNotSuggested('X');
       assertNotSuggested('z');
       assertNotSuggested('==');
     });
   }
 
   test_CascadeExpression_selector2() {
     // SimpleIdentifier  PropertyAccess  CascadeExpression  ExpressionStatement
     addSource('/testB.dart', '''
       class B { }''');
     addTestSource('''
       import "/testB.dart";
       class A {var b; X _c;}
       class X{}
       main() {A a; a..^z}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 1);
       assertSuggestInvocationField('b', null);
       assertSuggestInvocationField('_c', 'X');
       assertNotSuggested('Object');
       assertNotSuggested('A');
       assertNotSuggested('B');
       assertNotSuggested('X');
       assertNotSuggested('z');
       assertNotSuggested('==');
     });
   }
 
   test_CascadeExpression_selector2_withTrailingReturn() {
     // PropertyAccess  CascadeExpression  ExpressionStatement  Block
     addSource('/testB.dart', '''
       class B { }''');
     addTestSource('''
       import "/testB.dart";
       class A {var b; X _c;}
       class X{}
       main() {A a; a..^ return}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestInvocationField('b', null);
       assertSuggestInvocationField('_c', 'X');
       assertNotSuggested('Object');
       assertNotSuggested('A');
       assertNotSuggested('B');
       assertNotSuggested('X');
       assertNotSuggested('z');
       assertNotSuggested('==');
     });
   }
 
   test_CascadeExpression_target() {
     // SimpleIdentifier  CascadeExpression  ExpressionStatement
     addTestSource('''
       class A {var b; X _c;}
       class X{}
       main() {A a; a^..b}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset - 1);
+      expect(request.replacementLength, 1);
       assertNotSuggested('b');
       assertNotSuggested('_c');
       assertSuggestLocalVariable('a', 'A');
       assertSuggestLocalClass('A');
       assertSuggestLocalClass('X');
       // top level results are partially filtered
       //assertSuggestImportedClass('Object');
       assertNotSuggested('==');
     });
   }
 
   test_CatchClause_typed() {
     // Block  CatchClause  TryStatement
     addTestSource('class A {a() {try{var x;} on E catch (e) {^}}}');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestParameter('e', 'E');
       assertSuggestLocalMethod('a', 'A', null);
       assertSuggestImportedClass('Object');
       assertNotSuggested('x');
     });
   }
 
   test_CatchClause_untyped() {
     // Block  CatchClause  TryStatement
     addTestSource('class A {a() {try{var x;} catch (e, s) {^}}}');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestParameter('e', null);
       assertSuggestParameter('s', 'StackTrace');
       assertSuggestLocalMethod('a', 'A', null);
       assertSuggestImportedClass('Object');
       assertNotSuggested('x');
     });
   }
 
   test_ClassDeclaration_body() {
     // ClassDeclaration  CompilationUnit
     addSource('/testB.dart', '''
       class B { }''');
     addTestSource('''
       import "testB.dart" as x;
       @deprecated class A {^}
       class _B {}
       A T;''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       CompletionSuggestion suggestionA = assertSuggestLocalClass(
           'A',
           relevance: COMPLETION_RELEVANCE_LOW,
           isDeprecated: true);
       if (suggestionA != null) {
         expect(suggestionA.element.isDeprecated, isTrue);
         expect(suggestionA.element.isPrivate, isFalse);
       }
       CompletionSuggestion suggestionB = assertSuggestLocalClass('_B');
       if (suggestionB != null) {
@@ skipping 61 matching lines @@
       assertNoSuggestions();
     });
   }
 
   test_ConditionalExpression_empty() {
     // SimpleIdentifier  PrefixIdentifier  IfStatement
     addTestSource('''
       class A {var b; X _c; foo() {A a; if (^) something}}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestLocalField('b', null);
       assertSuggestLocalField('_c', 'X');
       assertSuggestImportedClass('Object');
       assertSuggestLocalClass('A');
       assertNotSuggested('==');
     });
   }
 
   test_ConditionalExpression_invocation() {
     // SimpleIdentifier  PrefixIdentifier  IfStatement
     addTestSource('''
       main() {var a; if (a.^) something}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestInvocationMethod('toString', 'Object', 'String');
       //TODO (danrubel) type for '_c' should be 'X' not null
       assertNotSuggested('Object');
       assertNotSuggested('A');
       assertNotSuggested('==');
     });
   }
 
   test_ConstructorName_importedClass() {
     // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
     // InstanceCreationExpression
     addSource('/testB.dart', '''
       lib B;
       int T1;
       F1() { }
       class X {X.c(); X._d(); z() {}}''');
     addTestSource('''
       import "/testB.dart";
       var m;
       main() {new X.^}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestNamedConstructor('c', 'X');
       assertNotSuggested('F1');
       assertNotSuggested('T1');
       assertNotSuggested('_d');
       assertNotSuggested('z');
       assertNotSuggested('m');
     });
   }
 
   test_ConstructorName_importedFactory() {
     // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
     // InstanceCreationExpression
     addSource('/testB.dart', '''
       lib B;
       int T1;
       F1() { }
       class X {factory X.c(); factory X._d(); z() {}}''');
     addTestSource('''
       import "/testB.dart";
       var m;
       main() {new X.^}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestNamedConstructor('c', 'X');
       assertNotSuggested('F1');
       assertNotSuggested('T1');
       assertNotSuggested('_d');
       assertNotSuggested('z');
       assertNotSuggested('m');
     });
   }
 
   test_ConstructorName_importedFactory2() {
     // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
     // InstanceCreationExpression
     addTestSource('''
       main() {new String.fr^omCharCodes([]);}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset - 2);
+      expect(request.replacementLength, 13);
       assertSuggestNamedConstructor('fromCharCodes', 'String');
       assertNotSuggested('isEmpty');
       assertNotSuggested('isNotEmpty');
       assertNotSuggested('length');
       assertNotSuggested('Object');
       assertNotSuggested('String');
     });
   }
 
   test_ConstructorName_localClass() {
     // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
     // InstanceCreationExpression
     addTestSource('''
       int T1;
       F1() { }
       class X {X.c(); X._d(); z() {}}
       main() {new X.^}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestNamedConstructor('c', 'X');
       assertSuggestNamedConstructor('_d', 'X');
       assertNotSuggested('F1');
       assertNotSuggested('T1');
       assertNotSuggested('z');
       assertNotSuggested('m');
     });
   }
 
   test_ConstructorName_localFactory() {
     // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
     // InstanceCreationExpression
     addTestSource('''
       int T1;
       F1() { }
       class X {factory X.c(); factory X._d(); z() {}}
       main() {new X.^}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestNamedConstructor('c', 'X');
       assertSuggestNamedConstructor('_d', 'X');
       assertNotSuggested('F1');
       assertNotSuggested('T1');
       assertNotSuggested('z');
       assertNotSuggested('m');
     });
   }
 
   test_ExpressionStatement_identifier() {
     // SimpleIdentifier  ExpressionStatement  Block
     addSource('/testA.dart', '''
       _B F1() { }
       class A {int x;}
       class _B { }''');
     addTestSource('''
       import "/testA.dart";
       typedef int F2(int blat);
       class Clz = Object with Object;
       class C {foo(){^} void bar() {}}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestImportedClass('A');
       assertSuggestImportedFunction('F1', '_B', false);
       assertSuggestLocalClass('C');
       assertSuggestLocalMethod('foo', 'C', null);
       assertSuggestLocalMethod('bar', 'C', 'void');
       assertSuggestLocalFunctionTypeAlias('F2', 'int');
       assertSuggestLocalClassTypeAlias('Clz');
       assertSuggestLocalClass('C');
       assertNotSuggested('x');
       assertNotSuggested('_B');
@@ skipping 38 matching lines @@
     return computeFull((bool result) {
       assertNoSuggestions();
     });
   }
 
   test_ForEachStatement_body_typed() {
     // Block  ForEachStatement
     addTestSource('main(args) {for (int foo in bar) {^}}');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestLocalVariable('foo', 'int');
       assertSuggestImportedClass('Object');
     });
   }
 
   test_ForEachStatement_body_untyped() {
     // Block  ForEachStatement
     addTestSource('main(args) {for (foo in bar) {^}}');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestLocalVariable('foo', null);
       assertSuggestImportedClass('Object');
     });
   }
 
   test_FormalParameterList() {
     // FormalParameterList MethodDeclaration
     addTestSource('''
       foo() { }
       void bar() { }
       class A {a(^) { }}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestLocalFunction('foo', null);
       assertSuggestLocalMethod('a', 'A', null);
       assertSuggestLocalClass('A');
       assertSuggestImportedClass('String');
       assertSuggestImportedFunction('identical', 'bool');
       assertNotSuggested('bar');
     });
   }
 
   test_ForStatement_body() {
     // Block  ForStatement
     addTestSource('main(args) {for (int i; i < 10; ++i) {^}}');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestLocalVariable('i', 'int');
       assertSuggestImportedClass('Object');
     });
   }
 
   test_ForStatement_condition() {
     // SimpleIdentifier  ForStatement
     addTestSource('main() {for (int index = 0; i^)}');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset - 1);
+      expect(request.replacementLength, 1);
       assertSuggestLocalVariable('index', 'int');
     });
   }
 
   test_ForStatement_initializer() {
     // SimpleIdentifier  ForStatement
     addTestSource('main() {List a; for (^)}');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestLocalVariable('a', 'List');
       assertSuggestImportedClass('Object');
       assertSuggestImportedClass('int');
     });
   }
 
   test_ForStatement_updaters() {
     // SimpleIdentifier  ForStatement
     addTestSource('main() {for (int index = 0; index < 10; i^)}');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset - 1);
+      expect(request.replacementLength, 1);
       assertSuggestLocalVariable('index', 'int');
     });
   }
 
   test_ForStatement_updaters_prefix_expression() {
     // SimpleIdentifier  PrefixExpression  ForStatement
     addTestSource('''
       void bar() { }
       main() {for (int index = 0; index < 10; ++i^)}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset - 1);
+      expect(request.replacementLength, 1);
       assertSuggestLocalVariable('index', 'int');
       assertSuggestLocalFunction('main', null);
       assertNotSuggested('bar');
     });
   }
 
   test_FunctionExpression_body_function() {
     // Block  BlockFunctionBody  FunctionExpression
     addTestSource('''
       void bar() { }
       String foo(List args) {x.then((R b) {^});}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       var f = assertSuggestLocalFunction('foo', 'String', false);
       if (f != null) {
         expect(f.element.isPrivate, isFalse);
       }
       assertSuggestLocalFunction('bar', 'void');
       assertSuggestParameter('args', 'List');
       assertSuggestParameter('b', 'R');
       assertSuggestImportedClass('Object');
     });
   }
 
   test_IfStatement_condition() {
     // SimpleIdentifier  IfStatement  Block  BlockFunctionBody
     addTestSource('''
       class A {int x; int y() => 0;}
       main(){var a; if (^)}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestLocalVariable('a', null);
       assertSuggestLocalFunction('main', null);
       assertSuggestLocalClass('A');
       assertSuggestImportedClass('Object');
     });
   }
 
   test_ImportDirective_dart() {
     // SimpleStringLiteral  ImportDirective
     addTestSource('''
@@ skipping 12 matching lines @@
       F1() { }
       class A {int x;}''');
     addTestSource('''
       import "/testA.dart";
       int T2;
       F2() { }
       class B {int x;}
       class C {foo(){var f; {var x;} new ^}}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestImportedClass('Object');
       assertSuggestImportedClass('A');
       assertSuggestLocalClass('B');
       assertSuggestLocalClass('C');
       assertNotSuggested('f');
       assertNotSuggested('x');
       assertNotSuggested('foo');
       assertNotSuggested('F1');
       assertNotSuggested('F2');
       assertNotSuggested('T1');
       assertNotSuggested('T2');
     });
   }
 
   test_InterpolationExpression() {
     // SimpleIdentifier  InterpolationExpression  StringInterpolation
     addTestSource('main() {String name; print("hello \$^");}');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestLocalVariable('name', 'String');
       assertSuggestImportedClass('Object');
     });
   }
 
   test_InterpolationExpression_block() {
     // SimpleIdentifier  InterpolationExpression  StringInterpolation
     addTestSource('main() {String name; print("hello \${n^}");}');
     computeFast();
     return computeFull((bool result) {
       assertSuggestLocalVariable('name', 'String');
       // top level results are partially filtered
       //assertSuggestImportedClass('Object');
     });
   }
 
   test_InterpolationExpression_prefix_selector() {
     // SimpleIdentifier  PrefixedIdentifier  InterpolationExpression
     addTestSource('main() {String name; print("hello \${name.^}");}');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestInvocationGetter('length', 'int');
       assertNotSuggested('name');
       assertNotSuggested('Object');
       assertNotSuggested('==');
     });
   }
 
   test_InterpolationExpression_prefix_target() {
     // SimpleIdentifier  PrefixedIdentifier  InterpolationExpression
     addTestSource('main() {String name; print("hello \${nam^e.length}");}');
@@ skipping 11 matching lines @@
     addSource('/testB.dart', '''
       lib B;
       foo() { }
       class X {X.c(); X._d(); z() {}}''');
     addTestSource('''
       import "/testB.dart";
       class Y {Y.c(); Y._d(); z() {}}
       main() {var x; if (x is ^) { }}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestImportedClass('X');
       assertSuggestLocalClass('Y');
       assertNotSuggested('x');
       assertNotSuggested('main');
       assertNotSuggested('foo');
     });
   }
 
   test_IsExpression_target() {
     // IfStatement  Block  BlockFunctionBody
     addTestSource('''
       foo() { }
       void bar() { }
       class A {int x; int y() => 0;}
       main(){var a; if (^ is A)}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestLocalVariable('a', null);
       assertSuggestLocalFunction('main', null);
       assertSuggestLocalFunction('foo', null);
       assertNotSuggested('bar');
       assertSuggestLocalClass('A');
       assertSuggestImportedClass('Object');
     });
   }
 
   test_IsExpression_type() {
     // SimpleIdentifier  TypeName  IsExpression  IfStatement
     addTestSource('''
       class A {int x; int y() => 0;}
       main(){var a; if (a is ^)}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertNotSuggested('a');
       assertNotSuggested('main');
       assertSuggestLocalClass('A');
       assertSuggestImportedClass('Object');
     });
   }
 
   test_IsExpression_type_partial() {
     // SimpleIdentifier  TypeName  IsExpression  IfStatement
     addTestSource('''
       class A {int x; int y() => 0;}
       main(){var a; if (a is Obj^)}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset - 3);
+      expect(request.replacementLength, 3);
       assertNotSuggested('a');
       assertNotSuggested('main');
       assertSuggestLocalClass('A');
       assertSuggestImportedClass('Object');
     });
   }
 
   test_Literal_string() {
     // SimpleStringLiteral  ExpressionStatement  Block
     addTestSource('class A {a() {"hel^lo"}}');
     computeFast();
     return computeFull((bool result) {
       assertNoSuggestions();
     });
   }
 
   test_MethodDeclaration_body_getters() {
     // Block  BlockFunctionBody  MethodDeclaration
     addTestSource('class A {@deprecated X get f => 0; Z a() {^} get _g => 1;}');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       CompletionSuggestion methodA = assertSuggestLocalMethod('a', 'A', 'Z');
       if (methodA != null) {
         expect(methodA.element.isDeprecated, isFalse);
         expect(methodA.element.isPrivate, isFalse);
       }
       CompletionSuggestion getterF = assertSuggestLocalGetter(
           'f',
           'X',
           relevance: COMPLETION_RELEVANCE_LOW,
           isDeprecated: true);
       if (getterF != null) {
         expect(getterF.element.isDeprecated, isTrue);
         expect(getterF.element.isPrivate, isFalse);
       }
       CompletionSuggestion getterG = assertSuggestLocalGetter('_g', null);
       if (getterG != null) {
         expect(getterG.element.isDeprecated, isFalse);
         expect(getterG.element.isPrivate, isTrue);
       }
     });
   }
 
   test_MethodDeclaration_members() {
     // Block  BlockFunctionBody  MethodDeclaration
     addTestSource('class A {@deprecated X f; Z _a() {^} var _g;}');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       CompletionSuggestion methodA = assertSuggestLocalMethod('_a', 'A', 'Z');
       if (methodA != null) {
         expect(methodA.element.isDeprecated, isFalse);
         expect(methodA.element.isPrivate, isTrue);
       }
       CompletionSuggestion getterF = assertSuggestLocalField(
           'f',
           'X',
           relevance: COMPLETION_RELEVANCE_LOW,
           isDeprecated: true);
@@ skipping 10 matching lines @@
       }
       assertSuggestImportedClass('bool');
     });
   }
 
   test_MethodDeclaration_parameters_named() {
     // Block  BlockFunctionBody  MethodDeclaration
     addTestSource('class A {@deprecated Z a(X x, _, b, {y: boo}) {^}}');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       CompletionSuggestion methodA = assertSuggestLocalMethod(
           'a',
           'A',
           'Z',
           relevance: COMPLETION_RELEVANCE_LOW,
           isDeprecated: true);
       if (methodA != null) {
         expect(methodA.element.isDeprecated, isTrue);
         expect(methodA.element.isPrivate, isFalse);
       }
       assertSuggestParameter('x', 'X');
       assertSuggestParameter('y', null);
       assertSuggestParameter('b', null);
       assertSuggestImportedClass('int');
       assertNotSuggested('_');
     });
   }
 
   test_MethodDeclaration_parameters_positional() {
     // Block  BlockFunctionBody  MethodDeclaration
     addTestSource('''
       foo() { }
       void bar() { }
       class A {Z a(X x, [int y=1]) {^}}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestLocalFunction('foo', null);
       assertSuggestLocalFunction('bar', 'void');
       assertSuggestLocalMethod('a', 'A', 'Z');
       assertSuggestParameter('x', 'X');
       assertSuggestParameter('y', 'int');
       assertSuggestImportedClass('String');
     });
   }
 
   test_MethodInvocation_no_semicolon() {
     // MethodInvocation  ExpressionStatement  Block
     addTestSource('''
       main() { }
       class I {X get f => new A();get _g => new A();}
       class A implements I {
         var b; X _c;
         X get d => new A();get _e => new A();
         // no semicolon between completion point and next statement
         set s1(I x) {} set _s2(I x) {x.^ m(null);}
         m(X x) {} I _n(X x) {}}
       class X{}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestInvocationGetter('f', 'X');
       assertSuggestInvocationGetter('_g', null);
       assertNotSuggested('b');
       assertNotSuggested('_c');
       assertNotSuggested('d');
       assertNotSuggested('_e');
       assertNotSuggested('s1');
       assertNotSuggested('_s2');
       assertNotSuggested('m');
       assertNotSuggested('_n');
@@ skipping 17 matching lines @@
       import "/testB.dart";
       part "$testFile";
       class A { }
       var m;''');
     addTestSource('''
       part of libA;
       class B { }
       main() {new ^}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestLocalClass('B');
       assertSuggestImportedClass('Object');
       assertSuggestImportedClass('X');
       assertSuggestNonLocalClass('A');
       assertNotSuggested('F1');
       assertNotSuggested('T1');
       assertNotSuggested('_d');
       assertNotSuggested('z');
       assertNotSuggested('m');
     });
@@ skipping 11 matching lines @@
       class B { }''');
     addTestSource('''
       library libA;
       import "/testB.dart";
       part "/testA.dart";
       class A { }
       main() {new ^}
       var m;''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestLocalClass('A');
       assertSuggestImportedClass('Object');
       assertSuggestImportedClass('X');
       assertSuggestNonLocalClass('B');
       assertNotSuggested('F1');
       assertNotSuggested('T1');
       assertNotSuggested('_d');
       assertNotSuggested('z');
       assertNotSuggested('m');
     });
@@ skipping 15 matching lines @@
         m(X x) {} I _n(X x) {}}
       class X{}''');
     addTestSource('''
       import "/testB.dart";
       class A extends B {
         static const String scA = 'foo';
         w() { }}
       main() {A.^}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestInvocationField('scA', 'String');
       assertSuggestInvocationField('scB', 'int');
       assertSuggestInvocationField('scI', null);
       assertNotSuggested('b');
       assertNotSuggested('_c');
       assertNotSuggested('d');
       assertNotSuggested('_e');
       assertNotSuggested('f');
       assertNotSuggested('_g');
       assertNotSuggested('s1');
@@ skipping 19 matching lines @@
         @deprecated var b; X _c;
         X get d => new A();get _e => new A();
         set s1(I x) {} set _s2(I x) {}
         m(X x) {} I _n(X x) {}}
       class X{}''');
     addTestSource('''
       import "/testB.dart";
       main() {A a; a.^}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestInvocationField('sc', 'int');
       assertSuggestInvocationField('b', null, isDeprecated: true);
       assertNotSuggested('_c');
       assertSuggestInvocationGetter('d', 'X');
       assertNotSuggested('_e');
       assertSuggestInvocationGetter('f', 'X');
       assertNotSuggested('_g');
       assertSuggestInvocationSetter('s1');
       assertNotSuggested('_s2');
       assertSuggestInvocationMethod('m', 'A', null);
@@ skipping 13 matching lines @@
       class I {X get f => new A();get _g => new A();}
       class A implements I {
         static const int sc = 12;
         var b; X _c;
         X get d => new A();get _e => new A();
         set s1(I x) {} set _s2(I x) {}
         m(X x) {} I _n(X x) {}}
       class X{}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestInvocationField('sc', 'int');
       assertSuggestInvocationField('b', null);
       assertSuggestInvocationField('_c', 'X');
       assertSuggestInvocationGetter('d', 'X');
       assertSuggestInvocationGetter('_e', null);
       assertSuggestInvocationGetter('f', 'X');
       assertSuggestInvocationGetter('_g', null);
       assertSuggestInvocationSetter('s1');
       assertSuggestInvocationSetter('_s2');
       assertSuggestInvocationMethod('m', 'A', null);
@@ skipping 13 matching lines @@
       var T1;
       class X { }
       class Y { }''');
     addTestSource('''
       import "/testB.dart" as b;
       var T2;
       class A { }
       main() {b.^}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestInvocationClass('X');
       assertSuggestInvocationClass('Y');
       assertSuggestInvocationTopLevelVar('T1', null);
       assertNotSuggested('T2');
       assertNotSuggested('Object');
       assertNotSuggested('b');
       assertNotSuggested('A');
       assertNotSuggested('==');
     });
   }
 
   test_PrefixedIdentifier_parameter() {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
     addSource('/testB.dart', '''
       lib B;
       class _W {M y; var _z;}
       class X extends _W {}
       class M{}''');
     addTestSource('''
       import "/testB.dart";
       foo(X x) {x.^}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestInvocationField('y', 'M');
       assertNotSuggested('_z');
       assertNotSuggested('==');
     });
   }
 
   test_PrefixedIdentifier_prefix() {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
     addSource('/testA.dart', '''
       class A {static int bar = 10;}
       _B() {}''');
     addTestSource('''
       import "/testA.dart";
       class X {foo(){A^.bar}}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset - 1);
+      expect(request.replacementLength, 1);
       assertSuggestImportedClass('A');
       assertSuggestLocalClass('X');
       assertSuggestLocalMethod('foo', 'X', null);
       assertNotSuggested('bar');
       assertNotSuggested('_B');
     });
   }
 
   test_PrefixedIdentifier_propertyAccess() {
     // PrefixedIdentifier  ExpressionStatement  Block  BlockFunctionBody
     addTestSource('class A {String x; int get foo {x.^}');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestInvocationGetter('isEmpty', 'bool');
       assertSuggestInvocationMethod('compareTo', 'Comparable', 'int');
     });
   }
 
   test_PrefixedIdentifier_propertyAccess_newStmt() {
     // PrefixedIdentifier  ExpressionStatement  Block  BlockFunctionBody
     addTestSource('class A {String x; int get foo {x.^ int y = 0;}');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestInvocationGetter('isEmpty', 'bool');
       assertSuggestInvocationMethod('compareTo', 'Comparable', 'int');
     });
   }
 
   test_PropertyAccess_expression() {
     // SimpleIdentifier  MethodInvocation  PropertyAccess  ExpressionStatement
     addTestSource('class A {a() {"hello".to^String().length}}');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset - 2);
+      expect(request.replacementLength, 8);
       assertSuggestInvocationGetter('length', 'int');
       assertNotSuggested('A');
       assertNotSuggested('a');
       assertNotSuggested('Object');
       assertNotSuggested('==');
     });
   }
 
   test_PropertyAccess_selector() {
     // SimpleIdentifier  PropertyAccess  ExpressionStatement  Block
     addTestSource('class A {a() {"hello".length.^}}');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestInvocationGetter('isEven', 'bool');
       assertNotSuggested('A');
       assertNotSuggested('a');
       assertNotSuggested('Object');
       assertNotSuggested('==');
     });
   }
 
   test_ThisExpression_block() {
     // MethodInvocation  ExpressionStatement  Block
     addTestSource('''
       main() { }
       class I {X get f => new A();get _g => new A();}
       class A implements I {
         A() {}
         A.z() {}
         var b; X _c;
         X get d => new A();get _e => new A();
         // no semicolon between completion point and next statement
         set s1(I x) {} set _s2(I x) {this.^ m(null);}
         m(X x) {} I _n(X x) {}}
       class X{}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestInvocationField('b', null);
       assertSuggestInvocationField('_c', 'X');
       assertSuggestInvocationGetter('d', 'X');
       assertSuggestInvocationGetter('_e', null);
       assertSuggestInvocationGetter('f', 'X');
       assertSuggestInvocationGetter('_g', null);
       assertSuggestInvocationMethod('m', 'A', null);
       assertSuggestInvocationMethod('_n', 'A', 'I');
       assertSuggestInvocationSetter('s1');
       assertSuggestInvocationSetter('_s2');
@@ skipping 15 matching lines @@
         A() {this.^}
         A.z() {}
         var b; X _c;
         X get d => new A();get _e => new A();
         // no semicolon between completion point and next statement
         set s1(I x) {} set _s2(I x) {m(null);}
         m(X x) {} I _n(X x) {}}
       class X{}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestInvocationField('b', null);
       assertSuggestInvocationField('_c', 'X');
       assertSuggestInvocationGetter('d', 'X');
       assertSuggestInvocationGetter('_e', null);
       assertSuggestInvocationGetter('f', 'X');
       assertSuggestInvocationGetter('_g', null);
       assertSuggestInvocationMethod('m', 'A', null);
       assertSuggestInvocationMethod('_n', 'A', 'I');
       assertSuggestInvocationSetter('s1');
       assertSuggestInvocationSetter('_s2');
@@ skipping 51 matching lines @@
       lib B;
       foo() { }
       class _B { }
       class X {X.c(); X._d(); z() {}}''');
     addTestSource('''
       import "/testB.dart";
       class Y {Y.c(); Y._d(); z() {}}
       class C {bar(){var f; {var x;} var e = ^}}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestImportedClass('X');
       assertNotSuggested('_B');
       assertSuggestLocalClass('Y');
       assertSuggestLocalClass('C');
       assertSuggestLocalVariable('f', null);
       assertNotSuggested('x');
       assertNotSuggested('e');
     });
   }
 
   test_VariableDeclarationStatement_RHS_missing_semicolon() {
     // VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement
     addSource('/testB.dart', '''
       lib B;
       foo1() { }
       void bar1() { }
       class _B { }
       class X {X.c(); X._d(); z() {}}''');
     addTestSource('''
       import "/testB.dart";
       foo2() { }
       void bar2() { }
       class Y {Y.c(); Y._d(); z() {}}
       class C {bar(){var f; {var x;} var e = ^ var g}}''');
     computeFast();
     return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
       assertSuggestImportedClass('X');
       assertSuggestImportedFunction('foo1', null);
       assertNotSuggested('bar1');
       assertSuggestLocalFunction('foo2', null);
       assertNotSuggested('bar2');
       assertNotSuggested('_B');
       assertSuggestLocalClass('Y');
       assertSuggestLocalClass('C');
       assertSuggestLocalVariable('f', null);
       assertNotSuggested('x');
       assertNotSuggested('e');
     });
   }
 }