Issue 23184. Fix for exception when 'async' is used outside of a function body.

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 'package:analysis_server/edit/fix/fix_core.dart';
-import 'package:analysis_server/src/plugin/server_plugin.dart';
 import 'package:analysis_server/src/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/file_system/file_system.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/source.dart';
-import 'package:analyzer/src/plugin/plugin_impl.dart';
 import 'package:unittest/unittest.dart';
 
 import '../../abstract_context.dart';
 import '../../abstract_single_unit.dart';
 import '../../reflective_tests.dart';
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(FixProcessorTest);
 }
 
 typedef bool AnalysisErrorFilter(AnalysisError error);
 
 @reflectiveTest
 class FixProcessorTest extends AbstractSingleUnitTest {
   AnalysisErrorFilter errorFilter = (AnalysisError error) {
     return error.errorCode != HintCode.UNUSED_CATCH_CLAUSE &&
         error.errorCode != HintCode.UNUSED_CATCH_STACK &&
         error.errorCode != HintCode.UNUSED_ELEMENT &&
         error.errorCode != HintCode.UNUSED_FIELD &&
         error.errorCode != HintCode.UNUSED_LOCAL_VARIABLE;
   };
 
-  ServerPlugin plugin;
   Fix fix;
   SourceChange change;
   String resultCode;
 
   void assert_undefinedFunction_create_returnType_bool(String lineWithTest) {
     resolveTestUnit('''
 main() {
   bool b = true;
   $lineWithTest
 }
@@ skipping 16 matching lines @@
     // apply to "file"
     List<SourceFileEdit> fileEdits = change.edits;
     expect(fileEdits, hasLength(1));
     resultCode = SourceEdit.applySequence(testCode, change.edits[0].edits);
     // verify
     expect(resultCode, expected);
   }
 
   void assertNoFix(FixKind kind) {
     AnalysisError error = _findErrorToFix();
-    List<Fix> fixes = computeFixes(plugin, context, error);
+    List<Fix> fixes = _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);
     return new Position(testFile, offset);
@@ skipping 10 matching lines @@
   List<LinkedEditSuggestion> expectedSuggestions(
       LinkedEditSuggestionKind kind, List<String> values) {
     return values.map((value) {
       return new LinkedEditSuggestion(value, kind);
     }).toList();
   }
 
   void setUp() {
     super.setUp();
     verifyNoTestUnitErrors = false;
-    ExtensionManager manager = new ExtensionManager();
-    plugin = new ServerPlugin();
-    manager.processPlugins([plugin]);
   }
 
   void test_addFieldFormalParameters_hasRequiredParameter() {
     resolveTestUnit('''
 class Test {
   final int a;
   final int b;
   final int c;
   Test(this.a);
 }
@@ skipping 39 matching lines @@
     assertHasFix(DartFixKind.ADD_FIELD_FORMAL_PARAMETERS, '''
 class Test {
   final int a;
   final int b;
   final int c;
   Test(this.a, this.b, [this.c]);
 }
 ''');
   }
 
+  void test_addSync_BAD_nullFunctionBody() {
+    resolveTestUnit('''
+var F = await;
+''');
+    assertNoFix(DartFixKind.ADD_ASYNC);
+  }
+
   void test_addSync_blockFunctionBody() {
     resolveTestUnit('''
 foo() {}
 main() {
   await foo();
 }
 ''');
     List<AnalysisError> errors = context.computeErrors(testSource);
     expect(errors, hasLength(2));
     // ParserError: Expected to find ';'
     {
       AnalysisError error = errors[0];
       expect(error.message, "Expected to find ';'");
-      List<Fix> fixes = computeFixes(plugin, context, error);
+      List<Fix> fixes = _computeFixes(error);
       expect(fixes, isEmpty);
     }
     // Undefined name 'await'
     {
       AnalysisError error = errors[1];
       expect(error.message, "Undefined name 'await'");
-      List<Fix> fixes = computeFixes(plugin, context, error);
+      List<Fix> fixes = _computeFixes(error);
       // has exactly one fix
       expect(fixes, hasLength(1));
       Fix fix = fixes[0];
       expect(fix.kind, DartFixKind.ADD_ASYNC);
       // apply to "file"
       List<SourceFileEdit> fileEdits = fix.change.edits;
       expect(fileEdits, hasLength(1));
       resultCode = SourceEdit.applySequence(testCode, fileEdits[0].edits);
       // verify
       expect(resultCode, '''
@@ skipping 2218 matching lines @@
 ''');
   }
 
   void test_noException_1() {
     resolveTestUnit('''
 main(p) {
   p i s Null;
 }''');
     List<AnalysisError> errors = context.computeErrors(testSource);
     for (var error in errors) {
-      computeFixes(plugin, context, error);
+      _computeFixes(error);
     }
   }
 
   void test_removeParentheses_inGetterDeclaration() {
     resolveTestUnit('''
 class A {
   int get foo() => 0;
 }
 ''');
     assertHasFix(DartFixKind.REMOVE_PARAMETERS_IN_GETTER_DECLARATION, '''
@@ skipping 1037 matching lines @@
   var b = 2;
   print(a ~/ b);
 }
 ''');
   }
 
   /**
    * Computes fixes and verifies that there is a fix of the given kind.
    */
   Fix _assertHasFix(FixKind kind, AnalysisError error) {
-    List<Fix> fixes = computeFixes(plugin, context, error);
+    List<Fix> fixes = _computeFixes(error);
     for (Fix fix in fixes) {
       if (fix.kind == kind) {
         return fix;
       }
     }
     throw fail('Expected to find fix $kind in\n${fixes.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));
     }
   }
 
   /**
+   * Computes fixes for the given [error] in [testUnit].
+   */
+  List<Fix> _computeFixes(AnalysisError error) {
+    FixProcessor processor = new FixProcessor(testUnit, error);
+    return processor.compute();
+  }
+
+  /**
    * Configures the [SourceFactory] to have the `my_pkg` package in
    * `/packages/my_pkg/lib` folder.
    */
   void _configureMyPkg(String myLibCode) {
     provider.newFile('/packages/my_pkg/lib/my_lib.dart', myLibCode);
     // configure SourceFactory
     Folder myPkgFolder = provider.getResource('/packages/my_pkg/lib');
     UriResolver pkgResolver =
         new PackageMapUriResolver(provider, {'my_pkg': [myPkgFolder]});
     context.sourceFactory = new SourceFactory(
@@ skipping 13 matching lines @@
 
   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;
   }
 }