Quick Fix for adding 'async' to fix invalid 'await'.

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/src/protocol.dart' hide AnalysisError;
 import 'package:analysis_server/src/services/correction/fix.dart';
 import 'package:analysis_server/src/services/index/index.dart';
 import 'package:analysis_server/src/services/index/local_memory_index.dart';
 import 'package:analysis_server/src/services/search/search_engine_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: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 {
   Index index;
   SearchEngineImpl searchEngine;
 
-  bool checkHasSingleError = true;
+  AnalysisErrorFilter errorFilter = null;
 
   Fix fix;
   SourceChange change;
   String resultCode;
 
   void assert_undefinedFunction_create_returnType_bool(String lineWithTest) {
     _indexTestUnit('''
 main() {
   bool b = true;
   $lineWithTest
@@ skipping 52 matching lines @@
     }).toList();
   }
 
   void setUp() {
     super.setUp();
     index = createLocalMemoryIndex();
     searchEngine = new SearchEngineImpl(index);
     verifyNoTestUnitErrors = false;
   }
 
+  void test_addSync_blockFunctionBody() {
+    _indexTestUnit('''
+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(searchEngine, testUnit, error);
+      expect(fixes, isEmpty);
+    }
+    // Undefined name 'await'
+    {
+      AnalysisError error = errors[1];
+      expect(error.message, "Undefined name 'await'");
+      List<Fix> fixes = computeFixes(searchEngine, testUnit, error);
+      // has exactly one fix
+      expect(fixes, hasLength(1));
+      Fix fix = fixes[0];
+      expect(fix.kind, FixKind.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, '''
+foo() {}
+main() async {
+  await foo();
+}
+''');
+    }
+  }
+
+  void test_addSync_expressionFunctionBody() {
+    errorFilter = (AnalysisError error) {
+      return error.errorCode == StaticWarningCode.UNDEFINED_IDENTIFIER;
+    };
+    _indexTestUnit('''
+foo() {}
+main() => await foo();
+''');
+    assertHasFix(FixKind.ADD_ASYNC, '''
+foo() {}
+main() async => await foo();
+''');
+  }
+
   void test_boolean() {
     _indexTestUnit('''
 main() {
   boolean v;
 }
 ''');
     assertHasFix(FixKind.REPLACE_BOOLEAN_WITH_BOOL, '''
 main() {
   bool v;
 }
@@ skipping 712 matching lines @@
   }
 
   void test_createGetter_unqualified_instance_asStatement() {
     _indexTestUnit('''
 class A {
   main() {
     test;
   }
 }
 ''');
-    // TODO
     assertHasFix(FixKind.CREATE_GETTER, '''
 class A {
   get test => null;
 
   main() {
     test;
   }
 }
 ''');
   }
@@ skipping 1135 matching lines @@
     _indexTestUnit('''
 import 'no/matter/my_lib.dart';
 ''');
     performAllAnalysisTasks();
     assertHasFix(FixKind.REPLACE_IMPORT_URI, '''
 import 'package:my_pkg/my_lib.dart';
 ''');
   }
 
   void test_replaceVarWithDynamic() {
-    checkHasSingleError = false;
+    errorFilter = (AnalysisError error) {
+      return error.errorCode == ParserErrorCode.VAR_AS_TYPE_NAME;
+    };
     _indexTestUnit('''
 class A {
   Map<String, var> m;
 }
 ''');
     assertHasFix(FixKind.REPLACE_VAR_WITH_DYNAMIC, '''
 class A {
   Map<String, dynamic> m;
 }
 ''');
@@ skipping 701 matching lines @@
     addSource('/tmp/other.dart', "import 'package:my_pkg/my_lib.dart';");
   }
 
   AnalysisError _findErrorToFix() {
     List<AnalysisError> errors = context.computeErrors(testSource);
     errors.removeWhere((error) {
       return error.errorCode == HintCode.UNUSED_ELEMENT ||
           error.errorCode == HintCode.UNUSED_FIELD ||
           error.errorCode == HintCode.UNUSED_LOCAL_VARIABLE;
     });
-    if (checkHasSingleError) {
-      expect(errors, hasLength(1));
+    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) {
       int offset = resultCode.indexOf(search);
       positions.add(new Position(testFile, offset));
     }
     return positions;
   }
 
   void _indexTestUnit(String code) {
     resolveTestUnit(code);
     index.indexUnit(context, testUnit);
   }
 }