tests for keyword/identifier replacementOffset - asserts fixes #23906 and fixes #23947

pkg/analysis_server/test/domain_completion_test.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.domain.completion;
 
 import 'dart:async';
 
 import 'package:analysis_server/completion/completion_core.dart'
     show CompletionRequest, CompletionResult;
@@ skipping 37 matching lines @@
   AnalysisDomainHandler analysisDomain;
   Test_CompletionDomainHandler completionDomain;
   Request request;
   int requestCount = 0;
   String testFile2 = '/project/bin/test2.dart';
 
   AnalysisServer createAnalysisServer(Index index) {
     ExtensionManager manager = new ExtensionManager();
     ServerPlugin serverPlugin = new ServerPlugin();
     manager.processPlugins([serverPlugin]);
-    return new Test_AnalysisServer(
-        super.serverChannel,
-        super.resourceProvider,
-        super.packageMapProvider,
-        index,
-        serverPlugin,
-        new AnalysisServerOptions(),
-        new MockSdk(),
+    return new Test_AnalysisServer(super.serverChannel, super.resourceProvider,
+        super.packageMapProvider, index, serverPlugin,
+        new AnalysisServerOptions(), new MockSdk(),
         InstrumentationService.NULL_SERVICE);
   }
 
   @override
   Index createIndex() {
     return createLocalMemoryIndex();
   }
 
   void sendRequest(String path) {
     String id = (++requestCount).toString();
@@ skipping 185 matching lines @@
 
 @reflectiveTest
 class CompletionTest extends AbstractAnalysisTest {
   String completionId;
   int completionOffset;
   int replacementOffset;
   int replacementLength;
   List<CompletionSuggestion> suggestions = [];
   bool suggestionsDone = false;
 
-  String addTestFile(String content, {offset}) {
+  String addTestFile(String content, {int offset}) {
     completionOffset = content.indexOf('^');
     if (offset != null) {
       expect(completionOffset, -1, reason: 'cannot supply offset and ^');
       completionOffset = offset;
       return super.addTestFile(content);
     }
     expect(completionOffset, isNot(equals(-1)), reason: 'missing ^');
     int nextOffset = content.indexOf('^', completionOffset + 1);
     expect(nextOffset, equals(-1), reason: 'too many ^');
     return super.addTestFile(content.substring(0, completionOffset) +
         content.substring(completionOffset + 1));
   }
 
   void assertHasResult(CompletionSuggestionKind kind, String completion,
-      [int relevance = DART_RELEVANCE_DEFAULT,
-      bool isDeprecated = false,
-      bool isPotential = false]) {
+      {int relevance: DART_RELEVANCE_DEFAULT,
+      bool isDeprecated: false,
+      bool isPotential: false,
+      int selectionOffset}) {
     var cs;
     suggestions.forEach((s) {
       if (s.completion == completion) {
         if (cs == null) {
           cs = s;
         } else {
           fail('expected exactly one $completion but found > 1');
         }
       }
     });
     if (cs == null) {
       var completions = suggestions.map((s) => s.completion).toList();
       fail('expected "$completion" but found\n $completions');
     }
     expect(cs.kind, equals(kind));
     expect(cs.relevance, equals(relevance));
-    expect(cs.selectionOffset, equals(completion.length));
+    expect(cs.selectionOffset, selectionOffset ?? completion.length);
     expect(cs.selectionLength, equals(0));
     expect(cs.isDeprecated, equals(isDeprecated));
     expect(cs.isPotential, equals(isPotential));
   }
 
   void assertNoResult(String completion) {
     if (suggestions.any((cs) => cs.completion == completion)) {
       fail('did not expect completion: $completion');
     }
   }
@@ skipping 63 matching lines @@
     ''');
     return getSuggestions().then((_) {
       expect(replacementOffset, equals(completionOffset));
       expect(replacementLength, equals(0));
       assertHasResult(CompletionSuggestionKind.INVOCATION, 'Object');
       assertHasResult(CompletionSuggestionKind.INVOCATION, 'HtmlElement');
       assertNoResult('test');
     });
   }
 
+  test_imports_incremental() async {
+    addTestFile('''library foo;
+      e^
+      import "dart:async";
+      import "package:foo/foo.dart";
+      class foo { }''');
+    await waitForTasksFinished();
+    server.updateContent('uc1', {testFile: new AddContentOverlay(testCode)});
+    server.updateContent('uc2', {
+      testFile:
+          new ChangeContentOverlay([new SourceEdit(completionOffset, 0, 'xp')])
+    });
+    completionOffset += 2;
+    await getSuggestions();
+    expect(replacementOffset, completionOffset - 3);
+    expect(replacementLength, 3);
+    assertHasResult(CompletionSuggestionKind.KEYWORD, 'export',
+        relevance: DART_RELEVANCE_HIGH);
+    assertHasResult(CompletionSuggestionKind.KEYWORD, 'import',
+        relevance: DART_RELEVANCE_HIGH);
+    assertNoResult('extends');
+    assertNoResult('library');
+  }
+
+  test_imports_partial() async {
+    addTestFile('''^
+      import "package:foo/foo.dart";
+      import "package:bar/bar.dart";
+      class Baz { }''');
+
+    // Wait for analysis then edit the content
+    await waitForTasksFinished();
+    String revisedContent = testCode.substring(0, completionOffset) +
+        'i' +
+        testCode.substring(completionOffset);
+    ++completionOffset;
+    server.handleRequest(new AnalysisUpdateContentParams(
+        {testFile: new AddContentOverlay(revisedContent)}).toRequest('add1'));
+
+    // Request code completion immediately after edit
+    Response response = handleSuccessfulRequest(new CompletionGetSuggestionsParams(
+        testFile, completionOffset).toRequest('0'));
+    completionId = response.id;
+    assertValidId(completionId);
+    await waitForTasksFinished();
+    expect(replacementOffset, completionOffset - 1);
+    expect(replacementLength, 1);
+    assertHasResult(CompletionSuggestionKind.KEYWORD, 'library',
+        relevance: DART_RELEVANCE_HIGH);
+    assertHasResult(CompletionSuggestionKind.KEYWORD, 'import',
+        relevance: DART_RELEVANCE_HIGH);
+    assertHasResult(CompletionSuggestionKind.KEYWORD, 'export',
+        relevance: DART_RELEVANCE_HIGH);
+    assertHasResult(CompletionSuggestionKind.KEYWORD, 'part',
+        relevance: DART_RELEVANCE_HIGH);
+    assertNoResult('extends');
+  }
+
   test_imports_prefixed() {
     addTestFile('''
       import 'dart:html' as foo;
       main() {^}
     ''');
     return getSuggestions().then((_) {
       expect(replacementOffset, equals(completionOffset));
       expect(replacementLength, equals(0));
       assertHasResult(CompletionSuggestionKind.INVOCATION, 'Object');
       assertHasResult(CompletionSuggestionKind.INVOCATION, 'foo');
@@ skipping 18 matching lines @@
       expect(replacementLength, equals(0));
       assertHasResult(CompletionSuggestionKind.INVOCATION, 'b');
     });
   }
 
   test_keyword() {
     addTestFile('library A; cl^');
     return getSuggestions().then((_) {
       expect(replacementOffset, equals(completionOffset - 2));
       expect(replacementLength, equals(2));
-      assertHasResult(
-          CompletionSuggestionKind.KEYWORD, 'export', DART_RELEVANCE_HIGH);
-      assertHasResult(
-          CompletionSuggestionKind.KEYWORD, 'class', DART_RELEVANCE_HIGH);
+      assertHasResult(CompletionSuggestionKind.KEYWORD, 'export',
+          relevance: DART_RELEVANCE_HIGH);
+      assertHasResult(CompletionSuggestionKind.KEYWORD, 'class',
+          relevance: DART_RELEVANCE_HIGH);
     });
   }
 
   test_local_named_constructor() {
     addTestFile('class A {A.c(); x() {new A.^}}');
     return getSuggestions().then((_) {
       expect(replacementOffset, equals(completionOffset));
       expect(replacementLength, equals(0));
       assertHasResult(CompletionSuggestionKind.INVOCATION, 'c');
       assertNoResult('A');
     });
   }
 
   test_locals() {
     addTestFile('class A {var a; x() {var b;^}} class DateTime { }');
     return getSuggestions().then((_) {
       expect(replacementOffset, equals(completionOffset));
       expect(replacementLength, equals(0));
       assertHasResult(CompletionSuggestionKind.INVOCATION, 'A');
-      assertHasResult(
-          CompletionSuggestionKind.INVOCATION, 'a', DART_RELEVANCE_LOCAL_FIELD);
+      assertHasResult(CompletionSuggestionKind.INVOCATION, 'a',
+          relevance: DART_RELEVANCE_LOCAL_FIELD);
       assertHasResult(CompletionSuggestionKind.INVOCATION, 'b',
-          DART_RELEVANCE_LOCAL_VARIABLE);
+          relevance: DART_RELEVANCE_LOCAL_VARIABLE);
       assertHasResult(CompletionSuggestionKind.INVOCATION, 'x',
-          DART_RELEVANCE_LOCAL_METHOD);
+          relevance: DART_RELEVANCE_LOCAL_METHOD);
       assertHasResult(CompletionSuggestionKind.INVOCATION, 'DateTime');
     });
   }
 
   test_offset_past_eof() {
     addTestFile('main() { }', offset: 300);
     return getSuggestions().then((_) {
       expect(replacementOffset, equals(300));
       expect(replacementLength, equals(0));
       expect(suggestionsDone, true);
       expect(suggestions.length, 0);
     });
   }
 
   test_overrides() {
     addFile('/libA.dart', 'class A {m() {}}');
     addTestFile('''
 import '/libA.dart';
 class B extends A {m() {^}}
 ''');
     return getSuggestions().then((_) {
       expect(replacementOffset, equals(completionOffset));
       expect(replacementLength, equals(0));
       assertHasResult(CompletionSuggestionKind.INVOCATION, 'm',
-          DART_RELEVANCE_LOCAL_METHOD);
+          relevance: DART_RELEVANCE_LOCAL_METHOD);
     });
   }
 
   test_partFile() {
-    addFile(
-        '/project/bin/testA.dart',
-        '''
+    addFile('/project/bin/testA.dart', '''
       library libA;
       part "$testFile";
       import 'dart:html';
       class A { }
     ''');
     addTestFile('''
       part of libA;
       main() {^}''');
     return getSuggestions().then((_) {
       expect(replacementOffset, equals(completionOffset));
       expect(replacementLength, equals(0));
       assertHasResult(CompletionSuggestionKind.INVOCATION, 'Object');
       assertHasResult(CompletionSuggestionKind.INVOCATION, 'HtmlElement');
       assertHasResult(CompletionSuggestionKind.INVOCATION, 'A');
       assertNoResult('test');
     });
   }
 
   test_partFile2() {
-    addFile(
-        '/testA.dart',
-        '''
+    addFile('/testA.dart', '''
       part of libA;
       class A { }''');
     addTestFile('''
       library libA;
       part "/testA.dart";
       import 'dart:html';
       main() {^}
     ''');
     return getSuggestions().then((_) {
       expect(replacementOffset, equals(completionOffset));
@@ skipping 25 matching lines @@
       typedef foo();
       var test = '';
       main() {tes^t}
     ''');
     return getSuggestions().then((_) {
       expect(replacementOffset, equals(completionOffset - 3));
       expect(replacementLength, equals(4));
       // Suggestions based upon imported elements are partially filtered
       //assertHasResult(CompletionSuggestionKind.INVOCATION, 'Object');
       assertHasResult(CompletionSuggestionKind.INVOCATION, 'test',
-          DART_RELEVANCE_LOCAL_TOP_LEVEL_VARIABLE);
+          relevance: DART_RELEVANCE_LOCAL_TOP_LEVEL_VARIABLE);
       assertNoResult('HtmlElement');
     });
   }
 }
 
 class MockCache extends CompletionCache {
   MockCache(AnalysisContext context, Source source) : super(context, source);
 }
 
 class MockCompletionManager implements CompletionManager {
@@ skipping 93 matching lines @@
     ++cancelCount;
     return new Future.value(true);
   }
 
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 class Test_AnalysisServer extends AnalysisServer {
   final MockContext mockContext = new MockContext();
 
-  Test_AnalysisServer(
-      ServerCommunicationChannel channel,
+  Test_AnalysisServer(ServerCommunicationChannel channel,
       ResourceProvider resourceProvider,
-      PubPackageMapProvider packageMapProvider,
-      Index index,
-      ServerPlugin serverPlugin,
-      AnalysisServerOptions analysisServerOptions,
-      DartSdk defaultSdk,
-      InstrumentationService instrumentationService)
-      : super(
-            channel,
-            resourceProvider,
-            packageMapProvider,
-            index,
-            serverPlugin,
-            analysisServerOptions,
-            defaultSdk,
-            instrumentationService);
+      PubPackageMapProvider packageMapProvider, Index index,
+      ServerPlugin serverPlugin, AnalysisServerOptions analysisServerOptions,
+      DartSdk defaultSdk, InstrumentationService instrumentationService)
+      : super(channel, resourceProvider, packageMapProvider, index,
+          serverPlugin, analysisServerOptions, defaultSdk,
+          instrumentationService);
 
   @override
   AnalysisContext getAnalysisContext(String path) {
     return mockContext;
   }
 
   @override
   ContextSourcePair getContextSourcePair(String path) {
     ContextSourcePair pair = super.getContextSourcePair(path);
     return new ContextSourcePair(mockContext, pair.source);
@@ skipping 44 matching lines @@
 }
     ''');
     await waitForTasksFinished();
     Request request =
         new CompletionGetSuggestionsParams(testFile, 0).toRequest('0');
     Response response = handler.handleRequest(request);
     expect(response.error, isNotNull);
     expect(response.error.code, RequestErrorCode.NO_INDEX_GENERATED);
   }
 }