Unify fasta->analyzer token translation logic.

pkg/front_end/test/scanner_test.dart

 // Copyright (c) 2016, 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.
 
 import 'package:front_end/src/base/errors.dart';
 import 'package:front_end/src/base/jenkins_smi_hash.dart';
 import 'package:front_end/src/scanner/errors.dart';
 import 'package:front_end/src/scanner/reader.dart';
 import 'package:front_end/src/scanner/scanner.dart';
 import 'package:front_end/src/scanner/token.dart';
@@ skipping 147 matching lines @@
 
   void test_ampersand_ampersand_eq() {
     _assertToken(TokenType.AMPERSAND_AMPERSAND_EQ, "&&=",
         lazyAssignmentOperators: true);
   }
 
   void test_ampersand_eq() {
     _assertToken(TokenType.AMPERSAND_EQ, "&=");
   }
 
+  void test_async_star() {
+    Token token = _scan("async*");
+    expect(token.type, TokenType.IDENTIFIER);
+    expect(token.lexeme, 'async');
+    expect(token.next.type, TokenType.STAR);
+    expect(token.next.next.type, TokenType.EOF);
+  }
+
   void test_at() {
     _assertToken(TokenType.AT, "@");
   }
 
   void test_backping() {
     _assertToken(TokenType.BACKPING, "`");
   }
 
   void test_backslash() {
     _assertToken(TokenType.BACKSLASH, "\\");
@@ skipping 260 matching lines @@
   }
 
   void test_keyword_as() {
     _assertKeywordToken("as");
   }
 
   void test_keyword_assert() {
     _assertKeywordToken("assert");
   }
 
+  void test_keyword_async() {
+    _assertIdentifierToken("async");
+  }
+
+  void test_keyword_await() {
+    _assertIdentifierToken("await");
+  }
+
   void test_keyword_break() {
     _assertKeywordToken("break");
   }
 
   void test_keyword_case() {
     _assertKeywordToken("case");
   }
 
   void test_keyword_catch() {
     _assertKeywordToken("catch");
@@ skipping 124 matching lines @@
   }
 
   void test_keyword_super() {
     _assertKeywordToken("super");
   }
 
   void test_keyword_switch() {
     _assertKeywordToken("switch");
   }
 
+  void test_keyword_sync() {
+    _assertIdentifierToken("sync");
+  }
+
   void test_keyword_this() {
     _assertKeywordToken("this");
   }
 
   void test_keyword_throw() {
     _assertKeywordToken("throw");
   }
 
   void test_keyword_true() {
     _assertKeywordToken("true");
@@ skipping 404 matching lines @@
   void test_string_simple_unterminated_interpolation_identifier() {
     _assertErrorAndTokens(
         ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 5, "'\$name", [
       new StringToken(TokenType.STRING, "'", 0),
       new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 1),
       new StringToken(TokenType.IDENTIFIER, "name", 2),
       new StringToken(TokenType.STRING, "", 6)
     ]);
   }
 
+  void test_sync_star() {
+    Token token = _scan("sync*");
+    expect(token.type, TokenType.IDENTIFIER);
+    expect(token.lexeme, 'sync');
+    expect(token.next.type, TokenType.STAR);
+    expect(token.next.next.type, TokenType.EOF);
+  }
+
   void test_tilde() {
     _assertToken(TokenType.TILDE, "~");
   }
 
   void test_tilde_slash() {
     _assertToken(TokenType.TILDE_SLASH, "~/");
   }
 
   void test_tilde_slash_eq() {
     _assertToken(TokenType.TILDE_SLASH_EQ, "~/=");
@@ skipping 61 matching lines @@
   void _assertErrorAndTokens(ScannerErrorCode expectedError, int expectedOffset,
       String source, List<Token> expectedTokens) {
     ErrorListener listener = new ErrorListener();
     Token token = scanWithListener(source, listener);
     listener
         .assertErrors([new TestError(expectedOffset, 1, expectedError, null)]);
     _checkTokens(token, expectedTokens);
   }
 
   /**
+   * Assert that when scanned the given [source] contains a single identifier
+   * token with the same lexeme as the original source.
+   */
+  void _assertIdentifierToken(String source) {
+    void check(String s, int expectedOffset) {
+      Token token = _scan(s);
+      expect(token, isNotNull);
+      expect(token.type, TokenType.IDENTIFIER);
+      expect(token.offset, expectedOffset);
+      expect(token.length, source.length);
+      expect(token.lexeme, source);
+      expect(token.value(), source);
+      expect(token.next.type, TokenType.EOF);
+    }
+
+    check(source, 0);
+    check(' $source ', 1);
+  }
+
+  /**
    * Assert that when scanned the given [source] contains a single keyword token
    * with the same lexeme as the original source.
    */
   void _assertKeywordToken(String source) {
     Token token = _scan(source);
     expect(token, isNotNull);
     expect(token.type, TokenType.KEYWORD);
     expect(token.offset, 0);
     expect(token.length, source.length);
     expect(token.lexeme, source);
@@ skipping 224 matching lines @@
   _TestScanner(CharacterReader reader, [this.listener]) : super(reader);
 
   @override
   void reportError(
       ScannerErrorCode errorCode, int offset, List<Object> arguments) {
     if (listener != null) {
       listener.errors.add(new TestError(offset, 1, errorCode, arguments));
     }
   }
 }