Use the new StaticWarningCode.UNDEFINED_IDENTIFIER_AWAIT error.

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';
@@ skipping 445 matching lines @@
 
   test_addSync_blockFunctionBody() async {
     resolveTestUnit('''
 foo() {}
 main() {
   await foo();
 }
 ''');
     List<AnalysisError> errors = context.computeErrors(testSource);
     expect(errors, hasLength(2));
-    String message1 = "Expected to find ';'";
-    String message2 = "Undefined name 'await'";
-    expect(errors.map((e) => e.message), unorderedEquals([message1, message2]));
-    for (AnalysisError error in errors) {
-      if (error.message == message1) {
-        List<Fix> fixes = await _computeFixes(error);
-        expect(fixes, isEmpty);
-      }
-      if (error.message == message2) {
-        List<Fix> fixes = await _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,
-            '''
+    errors.sort((a, b) => a.message.compareTo(b.message));
+    // No fix for ";".
+    {
+      AnalysisError error = errors[0];
+      expect(error.message, "Expected to find ';'");
+      List<Fix> fixes = await _computeFixes(error);
+      expect(fixes, isEmpty);
+    }
+    // Has fix for "await".
+    {
+      AnalysisError error = errors[1];
+      expect(error.message, startsWith("Undefined name 'await';"));
+      List<Fix> fixes = await _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,
+          '''
 foo() {}
 main() async {
   await foo();
 }
 ''');
-      }
     }
   }
 
   test_addSync_expressionFunctionBody() async {
     errorFilter = (AnalysisError error) {
-      return error.errorCode == StaticWarningCode.UNDEFINED_IDENTIFIER;
+      return error.errorCode == StaticWarningCode.UNDEFINED_IDENTIFIER_AWAIT;
     };
     resolveTestUnit('''
 foo() {}
 main() => await foo();
 ''');
     await assertHasFix(
         DartFixKind.ADD_ASYNC,
         '''
 foo() {}
 main() async => await foo();
 ''');
   }
 
   test_addSync_returnFuture() async {
     errorFilter = (AnalysisError error) {
-      return error.errorCode == StaticWarningCode.UNDEFINED_IDENTIFIER;
+      return error.errorCode == StaticWarningCode.UNDEFINED_IDENTIFIER_AWAIT;
     };
     resolveTestUnit('''
 foo() {}
 int main() {
   await foo();
   return 42;
 }
 ''');
     await assertHasFix(
         DartFixKind.ADD_ASYNC,
         '''
 import 'dart:async';
 
 foo() {}
 Future<int> main() async {
   await foo();
   return 42;
 }
 ''');
   }
 
   test_addSync_returnFuture_alreadyFuture() async {
     errorFilter = (AnalysisError error) {
-      return error.errorCode == StaticWarningCode.UNDEFINED_IDENTIFIER;
+      return error.errorCode == StaticWarningCode.UNDEFINED_IDENTIFIER_AWAIT;
     };
     resolveTestUnit('''
 import 'dart:async';
 foo() {}
 Future<int> main() {
   await foo();
   return 42;
 }
 ''');
     await assertHasFix(
         DartFixKind.ADD_ASYNC,
         '''
 import 'dart:async';
 foo() {}
 Future<int> main() async {
   await foo();
   return 42;
 }
 ''');
   }
 
   test_addSync_returnFuture_dynamic() async {
     errorFilter = (AnalysisError error) {
-      return error.errorCode == StaticWarningCode.UNDEFINED_IDENTIFIER;
+      return error.errorCode == StaticWarningCode.UNDEFINED_IDENTIFIER_AWAIT;
     };
     resolveTestUnit('''
 foo() {}
 dynamic main() {
   await foo();
   return 42;
 }
 ''');
     await assertHasFix(
         DartFixKind.ADD_ASYNC,
         '''
 foo() {}
 dynamic main() async {
   await foo();
   return 42;
 }
 ''');
   }
 
   test_addSync_returnFuture_noType() async {
     errorFilter = (AnalysisError error) {
-      return error.errorCode == StaticWarningCode.UNDEFINED_IDENTIFIER;
+      return error.errorCode == StaticWarningCode.UNDEFINED_IDENTIFIER_AWAIT;
     };
     resolveTestUnit('''
 foo() {}
 main() {
   await foo();
   return 42;
 }
 ''');
     await assertHasFix(
         DartFixKind.ADD_ASYNC,
@@ skipping 4734 matching lines @@
   @override
   void t() { }
 }
 ''');
   }
 
   void verifyResult(String expectedResult) {
     expect(resultCode, expectedResult);
   }
 }