enhance analyzer to parse uppercase and built-in/pseudo keywords

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 162 matching lines @@
     // Analyzer's token streams don't consider "<" to be an opener
     // but fasta does.
     if (lessThan is BeginToken) {
       expect(lessThan.endToken, greaterThan);
     }
     expect(greaterThan, isNot(new isInstanceOf<BeginToken>()));
   }
 
   void test_async_star() {
     Token token = _scan("async*");
-    expect(token.type, TokenType.IDENTIFIER);
+    expect(token.type, TokenType.KEYWORD);
     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() {
@@ skipping 270 matching lines @@
 
   void test_keyword_as() {
     _assertKeywordToken("as");
   }
 
   void test_keyword_assert() {
     _assertKeywordToken("assert");
   }
 
   void test_keyword_async() {
-    _assertIdentifierToken("async");
+    _assertKeywordToken("async");
   }
 
   void test_keyword_await() {
-    _assertIdentifierToken("await");
+    _assertKeywordToken("await");
   }
 
   void test_keyword_break() {
     _assertKeywordToken("break");
   }
 
   void test_keyword_case() {
     _assertKeywordToken("case");
   }
 
@@ skipping 63 matching lines @@
 
   void test_keyword_for() {
     _assertKeywordToken("for");
   }
 
   void test_keyword_get() {
     _assertKeywordToken("get");
   }
 
   void test_keyword_hide() {
-    _assertIdentifierToken("hide");
+    _assertKeywordToken("hide");
   }
 
   void test_keyword_if() {
     _assertKeywordToken("if");
   }
 
   void test_keyword_implements() {
     _assertKeywordToken("implements");
   }
 
   void test_keyword_import() {
     _assertKeywordToken("import");
   }
 
   void test_keyword_in() {
     _assertKeywordToken("in");
   }
 
   void test_keyword_is() {
     _assertKeywordToken("is");
   }
 
   void test_keyword_library() {
     _assertKeywordToken("library");
   }
 
   void test_keyword_native() {
-    _assertIdentifierToken("native");
+    _assertKeywordToken("native");
   }
 
   void test_keyword_new() {
     _assertKeywordToken("new");
   }
 
   void test_keyword_null() {
     _assertKeywordToken("null");
   }
 
   void test_keyword_of() {
-    _assertIdentifierToken("of");
+    _assertKeywordToken("of");
   }
 
   void test_keyword_on() {
-    _assertIdentifierToken("on");
+    _assertKeywordToken("on");
   }
 
   void test_keyword_operator() {
     _assertKeywordToken("operator");
   }
 
   void test_keyword_part() {
     _assertKeywordToken("part");
   }
 
   void test_keyword_patch() {
-    _assertIdentifierToken("patch");
+    _assertKeywordToken("patch");
   }
 
   void test_keyword_rethrow() {
     _assertKeywordToken("rethrow");
   }
 
   void test_keyword_return() {
     _assertKeywordToken("return");
   }
 
   void test_keyword_set() {
     _assertKeywordToken("set");
   }
 
   void test_keyword_show() {
-    _assertIdentifierToken("show");
+    _assertKeywordToken("show");
   }
 
   void test_keyword_source() {
-    _assertIdentifierToken("source");
+    _assertKeywordToken("source");
   }
 
   void test_keyword_static() {
     _assertKeywordToken("static");
   }
 
   void test_keyword_super() {
     _assertKeywordToken("super");
   }
 
   void test_keyword_switch() {
     _assertKeywordToken("switch");
   }
 
   void test_keyword_sync() {
-    _assertIdentifierToken("sync");
+    _assertKeywordToken("sync");
   }
 
   void test_keyword_this() {
     _assertKeywordToken("this");
   }
 
   void test_keyword_throw() {
     _assertKeywordToken("throw");
   }
 
@@ skipping 19 matching lines @@
 
   void test_keyword_while() {
     _assertKeywordToken("while");
   }
 
   void test_keyword_with() {
     _assertKeywordToken("with");
   }
 
   void test_keyword_yield() {
-    _assertIdentifierToken("yield");
+    _assertKeywordToken("yield");
   }
 
   void test_lt() {
     _assertToken(TokenType.LT, "<");
   }
 
   void test_lt_eq() {
     _assertToken(TokenType.LT_EQ, "<=");
   }
 
@@ skipping 456 matching lines @@
         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.type, TokenType.KEYWORD);
     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() {
@@ skipping 75 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, 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 222 matching lines @@
   _TestScanner(CharacterReader reader, [this.listener]) : super.create(reader);
 
   @override
   void reportError(
       ScannerErrorCode errorCode, int offset, List<Object> arguments) {
     if (listener != null) {
       listener.errors.add(new TestError(offset, errorCode, arguments));
     }
   }
 }