Run AssistProcessor tests with the new analysis driver.

pkg/analysis_server/test/services/correction/assist_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.services.correction.assist;
 
 import 'dart:async';
 
 import 'package:analysis_server/plugin/edit/assist/assist_core.dart';
+import 'package:analysis_server/plugin/edit/assist/assist_dart.dart';
 import 'package:analysis_server/plugin/protocol/protocol.dart';
 import 'package:analysis_server/src/plugin/server_plugin.dart';
 import 'package:analysis_server/src/services/correction/assist.dart';
+import 'package:analysis_server/src/services/correction/assist_internal.dart';
+import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
+import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:plugin/manager.dart';
 import 'package:plugin/plugin.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../../abstract_single_unit.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(AssistProcessorTest);
+    defineReflectiveTests(AssistProcessorTest_Driver);
   });
 }
 
 @reflectiveTest
 class AssistProcessorTest extends AbstractSingleUnitTest {
   int offset;
   int length;
 
   ServerPlugin plugin;
   Assist assist;
@@ skipping 22 matching lines @@
   assertHasAssistAt(
       String offsetSearch, AssistKind kind, String expected) async {
     offset = findOffset(offsetSearch);
     await assertHasAssist(kind, expected);
   }
 
   /**
    * Asserts that there is no [Assist] of the given [kind] at [offset].
    */
   assertNoAssist(AssistKind kind) async {
-    List<Assist> assists = await computeAssists(
-        plugin,
-        context,
-        resolutionMap.elementDeclaredByCompilationUnit(testUnit).source,
-        offset,
-        length);
+    List<Assist> assists = await _computeAssists();
     for (Assist assist in assists) {
       if (assist.kind == kind) {
         throw fail('Unexpected assist $kind in\n${assists.join('\n')}');
       }
     }
   }
 
   /**
    * Calls [assertNoAssist] at the offset of [offsetSearch] in [testCode].
    */
@@ skipping 414 matching lines @@
 main() {
   var v = getFutureInt();
 }
 ''';
     // add sources
     Source appSource = addSource('/app.dart', appCode);
     testSource = addSource('/test.dart', testCode);
     // resolve
     context.resolveCompilationUnit2(appSource, appSource);
     testUnit = context.resolveCompilationUnit2(testSource, appSource);
-    assertNoErrorsInSource(testSource);
     testUnitElement = testUnit.element;
     testLibraryElement = testUnitElement.library;
     // prepare the assist
     offset = findOffset('v = ');
     assist = await _assertHasAssist(DartAssistKind.ADD_TYPE_ANNOTATION);
     change = assist.change;
     // verify
     {
       var testFileEdit = change.getFileEdit('/app.dart');
       var resultCode = SourceEdit.applySequence(appCode, testFileEdit.edits);
@@ skipping 287 matching lines @@
   });
 }
 ''');
   }
 
   test_assignToLocalVariable_invocationArgument() async {
     await resolveTestUnit(r'''
 main() {
   f(12345);
 }
-int f(p) {}
+void f(p) {}
 ''');
     await assertNoAssistAt('345', DartAssistKind.ASSIGN_TO_LOCAL_VARIABLE);
   }
 
   test_assignToLocalVariable_throw() async {
     await resolveTestUnit('''
 main() {
   throw 42;
 }
 ''');
@@ skipping 526 matching lines @@
   int aaa2;
   A(int aaa) : aaa2 = aaa * 2;
 }
 ''');
     await assertNoAssistAt('aaa)', DartAssistKind.CONVERT_TO_FIELD_PARAMETER);
   }
 
   test_convertToFieldParameter_OK_firstInitializer() async {
     await resolveTestUnit('''
 class A {
-  double aaa2;
+  int aaa2;
   int bbb2;
   A(int aaa, int bbb) : aaa2 = aaa, bbb2 = bbb;
 }
 ''');
     await assertHasAssistAt(
         'aaa, ',
         DartAssistKind.CONVERT_TO_FIELD_PARAMETER,
         '''
 class A {
-  double aaa2;
+  int aaa2;
   int bbb2;
   A(this.aaa2, int bbb) : bbb2 = bbb;
 }
 ''');
   }
 
   test_convertToFieldParameter_OK_onParameterName_inInitializer() async {
     await resolveTestUnit('''
 class A {
   int test2;
@@ skipping 29 matching lines @@
   int test;
   A(this.test) {
   }
 }
 ''');
   }
 
   test_convertToFieldParameter_OK_secondInitializer() async {
     await resolveTestUnit('''
 class A {
-  double aaa2;
+  int aaa2;
   int bbb2;
   A(int aaa, int bbb) : aaa2 = aaa, bbb2 = bbb;
 }
 ''');
     await assertHasAssistAt(
         'bbb)',
         DartAssistKind.CONVERT_TO_FIELD_PARAMETER,
         '''
 class A {
-  double aaa2;
+  int aaa2;
   int bbb2;
   A(int aaa, this.bbb2) : aaa2 = aaa;
 }
 ''');
   }
 
   test_convertToFinalField_BAD_hasSetter_inThisClass() async {
     await resolveTestUnit('''
 class A {
   int get foo => null;
@@ skipping 324 matching lines @@
   for (int k = 0; k < items.length; k++) {
     String item = items[k];
     print(item);
     int i = 0, j = 1;
   }
 }
 ''');
   }
 
   test_convertToGetter_BAD_noInitializer() async {
+    verifyNoTestUnitErrors = false;
     await resolveTestUnit('''
 class A {
   final int foo;
 }
 ''');
     await assertNoAssistAt('foo', DartAssistKind.CONVERT_INTO_GETTER);
   }
 
   test_convertToGetter_BAD_notFinal() async {
     await resolveTestUnit('''
@@ skipping 703 matching lines @@
     await resolveTestUnit('''
 import 'dart:math' show PI;
 main() {
   PI;
 }
 ''');
     await assertNoAssistAt('import ', DartAssistKind.IMPORT_ADD_SHOW);
   }
 
   test_importAddShow_BAD_unresolvedUri() async {
+    verifyNoTestUnitErrors = false;
     await resolveTestUnit('''
 import '/no/such/lib.dart';
 ''');
     await assertNoAssistAt('import ', DartAssistKind.IMPORT_ADD_SHOW);
   }
 
   test_importAddShow_BAD_unused() async {
     await resolveTestUnit('''
 import 'dart:math';
 ''');
@@ skipping 1644 matching lines @@
   }
 // end
 }
 ''');
   }
 
   /**
    * Computes assists and verifies that there is an assist of the given kind.
    */
   Future<Assist> _assertHasAssist(AssistKind kind) async {
-    List<Assist> assists = await computeAssists(
-        plugin,
-        context,
-        resolutionMap.elementDeclaredByCompilationUnit(testUnit).source,
-        offset,
-        length);
+    List<Assist> assists = await _computeAssists();
     for (Assist assist in assists) {
       if (assist.kind == kind) {
         return assist;
       }
     }
     throw fail('Expected to find assist $kind in\n${assists.join('\n')}');
   }
 
   void _assertLinkedGroup(LinkedEditGroup group, List<String> expectedStrings,
       [List<LinkedEditSuggestion> expectedSuggestions]) {
     List<Position> expectedPositions = _findResultPositions(expectedStrings);
     expect(group.positions, unorderedEquals(expectedPositions));
     if (expectedSuggestions != null) {
       expect(group.suggestions, unorderedEquals(expectedSuggestions));
     }
   }
 
+  Future<List<Assist>> _computeAssists() async {
+    CompilationUnitElement testUnitElement =
+        resolutionMap.elementDeclaredByCompilationUnit(testUnit);
+    DartAssistContext assistContext = new _DartAssistContextForValues(
+        testUnitElement.source,
+        offset,
+        length,
+        testUnitElement.context,
+        testUnit);
+    AssistProcessor processor = new AssistProcessor(assistContext);
+    return await processor.compute();
+  }
+
   List<Position> _findResultPositions(List<String> searchStrings) {
     List<Position> positions = <Position>[];
     for (String search in searchStrings) {
       int offset = resultCode.indexOf(search);
       positions.add(new Position(testFile, offset));
     }
     return positions;
   }
 
   void _setStartEndSelection() {
     offset = findOffset('// start\n') + '// start\n'.length;
     length = findOffset('// end') - offset;
   }
 }
+
+@reflectiveTest
+class AssistProcessorTest_Driver extends AssistProcessorTest {
+  @override
+  bool get enableNewAnalysisDriver => true;
+
+  @failingTest
+  @override
+  test_addTypeAnnotation_local_OK_addImport_notLibraryUnit() {
+    return test_addTypeAnnotation_local_OK_addImport_notLibraryUnit();
+  }
+
+  @failingTest
+  @override
+  test_invalidSelection() {
+    return test_invalidSelection();
+  }
+}
+
+class _DartAssistContextForValues implements DartAssistContext {
+  @override
+  final Source source;
+
+  @override
+  final int selectionOffset;
+
+  @override
+  final int selectionLength;
+
+  @override
+  final AnalysisContext analysisContext;
+
+  @override
+  final CompilationUnit unit;
+
+  _DartAssistContextForValues(this.source, this.selectionOffset,
+      this.selectionLength, this.analysisContext, this.unit);
+}