Report a compile-time error if async/sync/yield used as an identifier.

pkg/analyzer/test/generated/compile_time_error_code_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 engine.compile_time_error_code_test;
 
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:unittest/unittest.dart' as _ut;
@@ skipping 228 matching lines @@
 library lib1;
 class N {}''');
     addNamedSource("/lib2.dart", r'''
 library lib2;
 class N {}''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.AMBIGUOUS_EXPORT]);
     verify([source]);
   }
 
+  void test_async_used_as_identifier_in_annotation() {
+    Source source = addSource('''
+const int async = 0;
+f() async {
+  g(@async x) {}
+  g(0);
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_async_used_as_identifier_in_argument_label() {
+    Source source = addSource('''
+@proxy
+class C {}
+f() async {
+  new C().g(async: 0);
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    // Note: we don't call verify([source]) because verify() doesn't understand
+    // about @proxy.
+  }
+
+  void test_async_used_as_identifier_in_async_method() {
+    Source source = addSource('''
+f() async {
+  var async = 1;
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_async_used_as_identifier_in_async_star_method() {
+    Source source = addSource('''
+f() async* {
+  var async = 1;
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_async_used_as_identifier_in_break_statement() {
+    Source source = addSource('''
+f() async {
+  while (true) {
+    break async;
+  }
+}
+''');
+    resolve(source);
+    assertErrors(
+        source,
+        [
+            ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER,
+            CompileTimeErrorCode.LABEL_UNDEFINED]);
+    // Note: we don't call verify([source]) because the reference to the
+    // "async" label is unresolved.
+  }
+
+  void test_async_used_as_identifier_in_cascaded_invocation() {
+    Source source = addSource('''
+class C {
+  int async() => 1;
+}
+f() async {
+  return new C()..async();
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_async_used_as_identifier_in_cascaded_setter_invocation() {
+    Source source = addSource('''
+class C {
+  void set async(int i) {}
+}
+f() async {
+  return new C()..async = 1;
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_async_used_as_identifier_in_catch_exception_argument() {
+    Source source = addSource('''
+g() {}
+f() async {
+  try {
+    g();
+  } catch (async) { }
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_async_used_as_identifier_in_catch_stacktrace_argument() {
+    Source source = addSource('''
+g() {}
+f() async {
+  try {
+    g();
+  } catch (e, async) { }
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_async_used_as_identifier_in_continue_statement() {
+    Source source = addSource('''
+f() async {
+  while (true) {
+    continue async;
+  }
+}
+''');
+    resolve(source);
+    assertErrors(
+        source,
+        [
+            ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER,
+            CompileTimeErrorCode.LABEL_UNDEFINED]);
+    // Note: we don't call verify([source]) because the reference to the
+    // "async" label is unresolved.
+  }
+
+  void test_async_used_as_identifier_in_for_statement() {
+    Source source = addSource('''
+var async;
+f() async {
+  for (async in []) {}
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_async_used_as_identifier_in_formal_parameter_name() {
+    Source source = addSource('''
+f() async {
+  g(int async) {}
+  g(0);
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_async_used_as_identifier_in_getter_name() {
+    Source source = addSource('''
+class C {
+  int get async => 1;
+}
+f() async {
+  return new C().async;
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_async_used_as_identifier_in_invocation() {
+    Source source = addSource('''
+class C {
+  int async() => 1;
+}
+f() async {
+  return new C().async();
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_async_used_as_identifier_in_local_function_name() {
+    Source source = addSource('''
+f() async {
+  int async() => null;
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_async_used_as_identifier_in_prefix() {
+    Source source = addSource('''
+import 'dart:async' as async;
+f() async {
+  return new async.Future.value(0);
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_async_used_as_identifier_in_setter_name() {
+    Source source = addSource('''
+class C {
+  void set async(int i) {}
+}
+f() async {
+  new C().async = 1;
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_async_used_as_identifier_in_statement_label() {
+    Source source = addSource('''
+f() async {
+  async: g();
+}
+g() {}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_async_used_as_identifier_in_string_interpolation() {
+    Source source = addSource(r'''
+int async = 1;
+f() async {
+  return "$async";
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_async_used_as_identifier_in_suffix() {
+    addNamedSource("/lib1.dart", r'''
+library lib1;
+int async;
+''');
+    Source source = addSource('''
+import 'lib1.dart' as l;
+f() async {
+  return l.async;
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_async_used_as_identifier_in_switch_label() {
+    Source source = addSource('''
+f() async {
+  switch (0) {
+    async: case 0: break;
+  }
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_async_used_as_identifier_in_sync_star_method() {
+    Source source = addSource('''
+f() sync* {
+  var async = 1;
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
   void test_asyncForInWrongContext() {
     Source source = addSource(r'''
 f(list) {
   await for (var e in list) {
   }
 }''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.ASYNC_FOR_IN_WRONG_CONTEXT]);
     verify([source]);
   }
 
+  void test_await_used_as_identifier_in_async_method() {
+    Source source = addSource('''
+f() async {
+  var await = 1;
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_await_used_as_identifier_in_async_star_method() {
+    Source source = addSource('''
+f() async* {
+  var await = 1;
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_await_used_as_identifier_in_sync_star_method() {
+    Source source = addSource('''
+f() sync* {
+  var await = 1;
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
   void test_builtInIdentifierAsMixinName_classTypeAlias() {
     Source source = addSource(r'''
 class A {}
 class B {}
 class as = A with B;''');
     resolve(source);
     assertErrors(
         source,
         [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME]);
     verify([source]);
@@ skipping 376 matching lines @@
   void test_constDeferredClass() {
     resolveWithErrors(<String>[r'''
 library lib1;
 class A {
   const A();
 }''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 main() {
   const a.A();
-}'''],
-          <ErrorCode>[CompileTimeErrorCode.CONST_DEFERRED_CLASS]);
+}'''], <ErrorCode>[CompileTimeErrorCode.CONST_DEFERRED_CLASS]);
   }
 
   void test_constDeferredClass_namedConstructor() {
     resolveWithErrors(<String>[r'''
 library lib1;
 class A {
   const A.b();
 }''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 main() {
   const a.A.b();
-}'''],
-          <ErrorCode>[CompileTimeErrorCode.CONST_DEFERRED_CLASS]);
+}'''], <ErrorCode>[CompileTimeErrorCode.CONST_DEFERRED_CLASS]);
   }
 
   void test_constEval_newInstance_constConstructor() {
     Source source = addSource(r'''
 class A {
   const A();
 }
 const a = new A();''');
     resolve(source);
     assertErrors(
@@ skipping 4658 matching lines @@
 class A {
   set x(a, b) {}
 }''');
     resolve(source);
     assertErrors(
         source,
         [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
     verify([source]);
   }
 
+  void test_yield_used_as_identifier_in_async_method() {
+    Source source = addSource('''
+f() async {
+  var yield = 1;
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_yield_used_as_identifier_in_async_star_method() {
+    Source source = addSource('''
+f() async* {
+  var yield = 1;
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_yield_used_as_identifier_in_sync_star_method() {
+    Source source = addSource('''
+f() sync* {
+  var yield = 1;
+}
+''');
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
+    verify([source]);
+  }
+
   void _check_constEvalThrowsException_binary_null(String expr, bool resolved) {
     Source source = addSource("const C = $expr;");
     resolve(source);
     if (resolved) {
       assertErrors(source, [CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION]);
       verify([source]);
     } else {
       assertErrors(source, [CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION]);
       // no verify(), 'null x' is not resolved
     }
@@ skipping 60 matching lines @@
         [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR]);
     verify([source]);
     reset();
   }
 
   void _check_wrongNumberOfParametersForOperator1(String name) {
     _check_wrongNumberOfParametersForOperator(name, "");
     _check_wrongNumberOfParametersForOperator(name, "a, b");
   }
 }