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;
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/channel/channel.dart';
 import 'package:analysis_server/src/constants.dart';
 import 'package:analysis_server/src/context_manager.dart';
 import 'package:analysis_server/src/domain_analysis.dart';
 import 'package:analysis_server/src/domain_completion.dart';
 import 'package:analysis_server/src/plugin/server_plugin.dart';
 import 'package:analysis_server/src/protocol.dart';
 import 'package:analysis_server/src/services/completion/completion_manager.dart';
 import 'package:analysis_server/src/services/completion/dart_completion_manager.dart';
 import 'package:analysis_server/src/services/index/index.dart' show Index;
 import 'package:analysis_server/src/services/index/local_memory_index.dart';
 import 'package:analysis_server/src/services/search/search_engine.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer/source/pub_package_map_provider.dart';
+import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:plugin/manager.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 import 'package:unittest/unittest.dart';
 
 import 'analysis_abstract.dart';
 import 'mock_sdk.dart';
 import 'mocks.dart';
@@ skipping 11 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);
+    String completion = 'export';

[Brian Wilkerson, 2015/08/12 13:59:25]

(I'd actually find it easier to read without the local variable...)

[danrubel, 2015/08/15 19:17:16]

Done.

+    assertHasResult(CompletionSuggestionKind.KEYWORD, completion,
+        relevance: DART_RELEVANCE_HIGH);

[Brian Wilkerson, 2015/08/12 13:59:25]

Should we also test for the absence of invalid suggestions?

[danrubel, 2015/08/15 19:17:16]

Good point. Added.

+  }
+
+  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);
+    String completion = 'import';
+    assertHasResult(CompletionSuggestionKind.KEYWORD, completion,
+        relevance: DART_RELEVANCE_HIGH);

[Brian Wilkerson, 2015/08/12 13:59:25]

We should also test for 'export', 'library' and 'part'.

[danrubel, 2015/08/15 19:17:16]

Done.

+  }
+
   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);

[Brian Wilkerson, 2015/08/12 13:59:25]

I think we're suggesting 'export' at this point so that if the user backspaces
twice the list will be complete. (If that's not accurate, please let me know.)
If 'export' makes sense, so do 'import', 'part', and 'typedef' (and possibly
'void').

[danrubel, 2015/08/15 19:17:16]

That is correct.

+      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);
   }
 }