Run Quick Fixes tests with the new analysis driver.

pkg/analysis_server/test/services/correction/fix_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.fix;
 
 import 'dart:async';
 
 import 'package:analysis_server/plugin/edit/fix/fix_core.dart';
+import 'package:analysis_server/plugin/edit/fix/fix_dart.dart';
 import 'package:analysis_server/plugin/protocol/protocol.dart'
     hide AnalysisError;
 import 'package:analysis_server/src/services/correction/fix.dart';
 import 'package:analysis_server/src/services/correction/fix_internal.dart';
+import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/src/error/codes.dart';
+import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../../abstract_context.dart';
 import '../../abstract_single_unit.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(FixProcessorTest);
+    defineReflectiveTests(FixProcessorTest_Driver);
     defineReflectiveTests(LintFixTest);
   });
 }
 
 typedef bool AnalysisErrorFilter(AnalysisError error);
 
 /**
  * Base class for fix processor tests.
  */
 class BaseFixProcessorTest extends AbstractSingleUnitTest {
@@ skipping 25 matching lines @@
   bool b = true;
   $lineWithTest
 }
 
 bool test() {
 }
 ''');
   }
 
   assertHasFix(FixKind kind, String expected) async {
-    AnalysisError error = _findErrorToFix();
+    AnalysisError error = await _findErrorToFix();
     fix = await _assertHasFix(kind, error);
     change = fix.change;
     // apply to "file"
     List<SourceFileEdit> fileEdits = change.edits;
     expect(fileEdits, hasLength(1));
     resultCode = SourceEdit.applySequence(testCode, change.edits[0].edits);
     // verify
     expect(resultCode, expected);
   }
 
   assertNoFix(FixKind kind) async {
-    AnalysisError error = _findErrorToFix();
+    AnalysisError error = await _findErrorToFix();
     List<Fix> fixes = await _computeFixes(error);
     for (Fix fix in fixes) {
       if (fix.kind == kind) {
         throw fail('Unexpected fix $kind in\n${fixes.join('\n')}');
       }
     }
   }
 
   Position expectedPosition(String search) {
     int offset = resultCode.indexOf(search);
@@ skipping 39 matching lines @@
     expect(group.positions, unorderedEquals(expectedPositions));
     if (expectedSuggestions != null) {
       expect(group.suggestions, unorderedEquals(expectedSuggestions));
     }
   }
 
   /**
    * Computes fixes for the given [error] in [testUnit].
    */
   Future<List<Fix>> _computeFixes(AnalysisError error) async {
-    FixContextImpl fixContext = new FixContextImpl(provider, context, error);
-    DefaultFixContributor contributor = new DefaultFixContributor();
-    return contributor.computeFixes(fixContext);
+    if (enableNewAnalysisDriver) {
+      DartFixContext fixContext = new _DartFixContextImpl(
+          provider,
+          driver.getTopLevelNameDeclarations,
+          resolutionMap.elementDeclaredByCompilationUnit(testUnit).context,
+          testUnit,
+          error);
+      return await new DefaultFixContributor().internalComputeFixes(fixContext);
+    } else {
+      FixContextImpl fixContext = new FixContextImpl(provider, context, error);
+      DefaultFixContributor contributor = new DefaultFixContributor();
+      return contributor.computeFixes(fixContext);
+    }
   }
 
   /**
    * Configures the [SourceFactory] to have the `my_pkg` package in
    * `/packages/my_pkg/lib` folder.
    */
   void _configureMyPkg(Map<String, String> pathToCode) {
     pathToCode.forEach((path, code) {
       provider.newFile('$myPkgLibPath/$path', code);
     });
     // configure SourceFactory
     Folder myPkgFolder = provider.getResource(myPkgLibPath);
     UriResolver pkgResolver = new PackageMapUriResolver(provider, {
       'my_pkg': [myPkgFolder]
     });
     context.sourceFactory = new SourceFactory(
         [AbstractContextTest.SDK_RESOLVER, pkgResolver, resourceResolver]);
     // force 'my_pkg' resolution
     addSource(
         '/tmp/other.dart',
         pathToCode.keys
             .map((path) => "import 'package:my_pkg/$path';")
             .join('\n'));
   }
 
-  AnalysisError _findErrorToFix() {
-    List<AnalysisError> errors = context.computeErrors(testSource);
+  Future<AnalysisError> _findErrorToFix() async {
+    List<AnalysisError> errors;
+    if (enableNewAnalysisDriver) {
+      errors = (await driver.getResult(testFile)).errors;
+    } else {
+      errors = context.computeErrors(testSource);
+    }
     if (errorFilter != null) {
       errors = errors.where(errorFilter).toList();
     }
     expect(errors, hasLength(1));
     return errors[0];
   }
 
   List<Position> _findResultPositions(List<String> searchStrings) {
     List<Position> positions = <Position>[];
     for (String search in searchStrings) {
@@ skipping 220 matching lines @@
 // Comment second.
 
 class A {}
 ''';
     addSource('/part.dart', partCode);
     await resolveTestUnit('''
 library my.lib;
 part 'part.dart';
 ''');
     _performAnalysis();
-    AnalysisError error = _findErrorToFix();
+    AnalysisError error = await _findErrorToFix();
     fix = await _assertHasFix(DartFixKind.ADD_PART_OF, error);
     change = fix.change;
     // apply to "file"
     List<SourceFileEdit> fileEdits = change.edits;
     expect(fileEdits, hasLength(1));
     SourceFileEdit fileEdit = change.edits[0];
     expect(fileEdit.file, '/part.dart');
     expect(
         SourceEdit.applySequence(partCode, fileEdit.edits),
         r'''
@@ skipping 454 matching lines @@
 ''';
     addSource('/lib.dart', libCode);
     await resolveTestUnit('''
 import 'lib.dart' as lib;
 
 main() {
   lib.A a = null;
   lib.Test t = null;
 }
 ''');
-    AnalysisError error = _findErrorToFix();
+    AnalysisError error = await _findErrorToFix();
     fix = await _assertHasFix(DartFixKind.CREATE_CLASS, error);
     change = fix.change;
     // apply to "lib.dart"
     List<SourceFileEdit> fileEdits = change.edits;
     expect(fileEdits, hasLength(1));
     SourceFileEdit fileEdit = change.edits[0];
     expect(fileEdit.file, '/lib.dart');
     expect(
         SourceEdit.applySequence(libCode, fileEdit.edits),
         r'''
@@ skipping 862 matching lines @@
   }
 }
 ''');
   }
 
   test_createFile_forImport() async {
     testFile = '/my/project/bin/test.dart';
     await resolveTestUnit('''
 import 'my_file.dart';
 ''');
-    AnalysisError error = _findErrorToFix();
+    AnalysisError error = await _findErrorToFix();
     fix = await _assertHasFix(DartFixKind.CREATE_FILE, error);
     change = fix.change;
     // validate change
     List<SourceFileEdit> fileEdits = change.edits;
     expect(fileEdits, hasLength(1));
     SourceFileEdit fileEdit = change.edits[0];
     expect(fileEdit.file, '/my/project/bin/my_file.dart');
     expect(fileEdit.fileStamp, -1);
     expect(fileEdit.edits, hasLength(1));
     expect(fileEdit.edits[0].replacement, contains('library my_file;'));
@@ skipping 16 matching lines @@
     await assertNoFix(DartFixKind.CREATE_FILE);
   }
 
   test_createFile_forImport_inPackage_lib() async {
     provider.newFile('/projects/my_package/pubspec.yaml', 'name: my_package');
     testFile = '/projects/my_package/lib/test.dart';
     provider.newFolder('/projects/my_package/lib');
     await resolveTestUnit('''
 import 'a/bb/c_cc/my_lib.dart';
 ''');
-    AnalysisError error = _findErrorToFix();
+    AnalysisError error = await _findErrorToFix();
     fix = await _assertHasFix(DartFixKind.CREATE_FILE, error);
     change = fix.change;
     // validate change
     List<SourceFileEdit> fileEdits = change.edits;
     expect(fileEdits, hasLength(1));
     SourceFileEdit fileEdit = change.edits[0];
     expect(fileEdit.file, '/projects/my_package/lib/a/bb/c_cc/my_lib.dart');
     expect(fileEdit.fileStamp, -1);
     expect(fileEdit.edits, hasLength(1));
     expect(fileEdit.edits[0].replacement,
         contains('library my_package.a.bb.c_cc.my_lib;'));
   }
 
   test_createFile_forImport_inPackage_test() async {
     provider.newFile('/projects/my_package/pubspec.yaml', 'name: my_package');
     testFile = '/projects/my_package/test/misc/test_all.dart';
     await resolveTestUnit('''
 import 'a/bb/my_lib.dart';
 ''');
-    AnalysisError error = _findErrorToFix();
+    AnalysisError error = await _findErrorToFix();
     fix = await _assertHasFix(DartFixKind.CREATE_FILE, error);
     change = fix.change;
     // validate change
     List<SourceFileEdit> fileEdits = change.edits;
     expect(fileEdits, hasLength(1));
     SourceFileEdit fileEdit = change.edits[0];
     expect(fileEdit.file, '/projects/my_package/test/misc/a/bb/my_lib.dart');
     expect(fileEdit.fileStamp, -1);
     expect(fileEdit.edits, hasLength(1));
     expect(fileEdit.edits[0].replacement,
         contains('library my_package.test.misc.a.bb.my_lib;'));
   }
 
   test_createFile_forPart() async {
     testFile = '/my/project/bin/test.dart';
     await resolveTestUnit('''
 library my.lib;
 part 'my_part.dart';
 ''');
-    AnalysisError error = _findErrorToFix();
+    AnalysisError error = await _findErrorToFix();
     fix = await _assertHasFix(DartFixKind.CREATE_FILE, error);
     change = fix.change;
     // validate change
     List<SourceFileEdit> fileEdits = change.edits;
     expect(fileEdits, hasLength(1));
     SourceFileEdit fileEdit = change.edits[0];
     expect(fileEdit.file, '/my/project/bin/my_part.dart');
     expect(fileEdit.fileStamp, -1);
     expect(fileEdit.edits, hasLength(1));
     expect(fileEdit.edits[0].replacement, contains('part of my.lib;'));
@@ skipping 13 matching lines @@
 ''',
         Uri.parse('package:my/test.dart'));
     // configure SourceFactory
     UriResolver pkgResolver = new PackageMapUriResolver(provider, {
       'my': <Folder>[provider.getResource('/my/lib')],
     });
     context.sourceFactory = new SourceFactory(
         [AbstractContextTest.SDK_RESOLVER, pkgResolver, resourceResolver]);
     // prepare fix
     testUnit = await resolveLibraryUnit(testSource);
-    AnalysisError error = _findErrorToFix();
+    AnalysisError error = await _findErrorToFix();
     fix = await _assertHasFix(DartFixKind.CREATE_FILE, error);
     change = fix.change;
     // validate change
     List<SourceFileEdit> fileEdits = change.edits;
     expect(fileEdits, hasLength(1));
     SourceFileEdit fileEdit = change.edits[0];
     expect(fileEdit.file, '/my/lib/my_part.dart');
     expect(fileEdit.fileStamp, -1);
     expect(fileEdit.edits, hasLength(1));
     expect(fileEdit.edits[0].replacement, contains('part of my.lib;'));
@@ skipping 3193 matching lines @@
 library test3;
 class E {}
 ''');
     await resolveTestUnit('''
 library test;
 import 'test2.dart' as aaa;
 main(aaa.D d, aaa.E e) {
   d.foo(e);
 }
 ''');
-    AnalysisError error = _findErrorToFix();
+    AnalysisError error = await _findErrorToFix();
     fix = await _assertHasFix(DartFixKind.CREATE_METHOD, error);
     change = fix.change;
     // apply to "test2.dart"
     List<SourceFileEdit> fileEdits = change.edits;
     expect(fileEdits, hasLength(1));
     SourceFileEdit fileEdit = change.edits[0];
     expect(fileEdit.file, '/test2.dart');
     expect(
         SourceEdit.applySequence(code2, fileEdit.edits),
         r'''
@@ skipping 14 matching lines @@
 class E {}
 ''';
     addSource('/test2.dart', code2);
     await resolveTestUnit('''
 library test;
 import 'test2.dart' as test2;
 main(test2.D d, test2.E e) {
   d.foo(e);
 }
 ''');
-    AnalysisError error = _findErrorToFix();
+    AnalysisError error = await _findErrorToFix();
     fix = await _assertHasFix(DartFixKind.CREATE_METHOD, error);
     change = fix.change;
     // apply to "test2.dart"
     List<SourceFileEdit> fileEdits = change.edits;
     expect(fileEdits, hasLength(1));
     SourceFileEdit fileEdit = change.edits[0];
     expect(fileEdit.file, '/test2.dart');
     expect(
         SourceEdit.applySequence(code2, fileEdit.edits),
         r'''
@@ skipping 200 matching lines @@
 import 'dart:math' as pref;
 main() {
   print(pref.E);
   print(pref.PI);
 }
 ''');
   }
 }
 
 @reflectiveTest
+class FixProcessorTest_Driver extends FixProcessorTest {
+  @override
+  bool get enableNewAnalysisDriver => true;
+
+  @failingTest
+  @override
+  test_addFieldFormalParameters_hasRequiredParameter() {
+    return test_addFieldFormalParameters_hasRequiredParameter();
+  }
+
+  @failingTest
+  @override
+  test_addFieldFormalParameters_noParameters() {
+    return test_addFieldFormalParameters_noParameters();
+  }
+
+  @failingTest
+  @override
+  test_addFieldFormalParameters_noRequiredParameter() {
+    return test_addFieldFormalParameters_noRequiredParameter();
+  }
+
+  @failingTest
+  @override
+  test_addPartOfDirective() {
+    return test_addPartOfDirective();
+  }
+
+  @failingTest
+  @override
+  test_addSync_blockFunctionBody() {
+    return test_addSync_blockFunctionBody();
+  }
+
+  @failingTest
+  @override
+  test_createFile_forPart_inPackageLib() {
+    return test_createFile_forPart_inPackageLib();
+  }
+
+  @failingTest
+  @override
+  test_importLibraryPackage_preferDirectOverExport() {
+    return test_importLibraryPackage_preferDirectOverExport();
+  }
+
+  @failingTest
+  @override
+  test_importLibraryPackage_preferDirectOverExport_src() {
+    return test_importLibraryPackage_preferDirectOverExport_src();
+  }
+
+  @failingTest
+  @override
+  test_importLibraryPackage_preferPublicOverPrivate() {
+    return test_importLibraryPackage_preferPublicOverPrivate();
+  }
+
+  @failingTest
+  @override
+  test_importLibraryProject_withClass_annotation() {
+    return test_importLibraryProject_withClass_annotation();
+  }
+
+  @failingTest
+  @override
+  test_importLibraryProject_withClass_constInstanceCreation() {
+    return test_importLibraryProject_withClass_constInstanceCreation();
+  }
+
+  @failingTest
+  @override
+  test_importLibraryProject_withClass_hasOtherLibraryWithPrefix() {
+    return test_importLibraryProject_withClass_hasOtherLibraryWithPrefix();
+  }
+
+  @failingTest
+  @override
+  test_importLibraryProject_withClass_inParentFolder() {
+    return test_importLibraryProject_withClass_inParentFolder();
+  }
+
+  @failingTest
+  @override
+  test_importLibraryProject_withClass_inRelativeFolder() {
+    return test_importLibraryProject_withClass_inRelativeFolder();
+  }
+
+  @failingTest
+  @override
+  test_importLibraryProject_withClass_inSameFolder() {
+    return test_importLibraryProject_withClass_inSameFolder();
+  }
+
+  @failingTest
+  @override
+  test_importLibraryProject_withFunction() {
+    return test_importLibraryProject_withFunction();
+  }
+
+  @failingTest
+  @override
+  test_importLibraryProject_withFunction_unresolvedMethod() {
+    return test_importLibraryProject_withFunction_unresolvedMethod();
+  }
+
+  @failingTest
+  @override
+  test_importLibraryProject_withFunctionTypeAlias() {
+    return test_importLibraryProject_withFunctionTypeAlias();
+  }
+
+  @failingTest
+  @override
+  test_importLibraryProject_withTopLevelVariable() {
+    return test_importLibraryProject_withTopLevelVariable();
+  }
+
+  @failingTest
+  @override
+  test_importLibrarySdk_withClass_itemOfList() {
+    return test_importLibrarySdk_withClass_itemOfList();
+  }
+
+  @failingTest
+  @override
+  test_importLibrarySdk_withTopLevelVariable() {
+    return test_importLibrarySdk_withTopLevelVariable();
+  }
+
+  @failingTest
+  @override
+  test_importLibrarySdk_withTopLevelVariable_annotation() {
+    return test_importLibrarySdk_withTopLevelVariable_annotation();
+  }
+
+  @failingTest
+  @override
+  test_importLibraryShow_project() {
+    return test_importLibraryShow_project();
+  }
+
+  @failingTest
+  @override
+  test_noException_1() {
+    return test_noException_1();
+  }
+
+  @failingTest
+  @override
+  test_replaceImportUri_inProject() {
+    return test_replaceImportUri_inProject();
+  }
+
+  @failingTest
+  @override
+  test_replaceImportUri_package() {
+    return test_replaceImportUri_package();
+  }
+}
+
+@reflectiveTest
 class LintFixTest extends BaseFixProcessorTest {
   AnalysisError error;
 
   Future applyFix(FixKind kind) async {
     fix = await _assertHasFix(kind, error);
     change = fix.change;
     // apply to "file"
     List<SourceFileEdit> fileEdits = change.edits;
     expect(fileEdits, hasLength(1));
     resultCode = SourceEdit.applySequence(testCode, change.edits[0].edits);
@@ skipping 206 matching lines @@
   var v = 42;
   print('v: $v');
 }
 ''');
   }
 
   void verifyResult(String expectedResult) {
     expect(resultCode, expectedResult);
   }
 }
+
+class _DartFixContextImpl implements DartFixContext {
+  @override
+  final ResourceProvider resourceProvider;
+
+  @override
+  final GetTopLevelDeclarations getTopLevelDeclarations;
+
+  @override
+  final AnalysisContext analysisContext;
+
+  @override
+  final CompilationUnit unit;
+
+  @override
+  final AnalysisError error;
+
+  _DartFixContextImpl(this.resourceProvider, this.getTopLevelDeclarations,
+      this.analysisContext, this.unit, this.error);
+}