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

pkg/front_end/lib/src/scanner/scanner.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:charcode/ascii.dart';
 import 'package:front_end/src/scanner/errors.dart';
 import 'package:front_end/src/scanner/reader.dart';
 import 'package:front_end/src/scanner/string_utilities.dart';
 import 'package:front_end/src/scanner/token.dart';
 
 /**
  * A state in a state machine used to scan keywords.
  */
 class KeywordState {
   /**
    * An empty transition table used by leaf states.
    */
-  static List<KeywordState> _EMPTY_TABLE = new List<KeywordState>(26);
+  static List<KeywordState> _EMPTY_TABLE = new List<KeywordState>($z - $A + 1);
 
   /**
    * The initial state in the state machine.
    */
   static final KeywordState KEYWORD_STATE = _createKeywordStateTable();
 
   /**
    * A table mapping characters to the states to which those characters will
    * transition. (The index into the array is the offset from the character
    * `'a'` to the transitioning character.)
@@ skipping 18 matching lines @@
    * Return the keyword that was recognized by this state, or `null` if this
    * state does not recognized a keyword.
    */
   Keyword keyword() => _keyword;
 
   /**
    * Return the state that follows this state on a transition of the given
    * [character], or `null` if there is no valid state reachable from this state
    * with such a transition.
    */
-  KeywordState next(int character) => _table[character - $a];
+  KeywordState next(int character) => _table[character - $A];
 
   /**
    * Create the next state in the state machine where we have already recognized
    * the subset of strings in the given array of [strings] starting at the given
    * [offset] and having the given [length]. All of these strings have a common
    * prefix and the next character is at the given [start] index.
    */
   static KeywordState _computeKeywordStateTable(
       int start, List<String> strings, int offset, int length) {
-    List<KeywordState> result = new List<KeywordState>(26);
+    List<KeywordState> result = new List<KeywordState>($z - $A + 1);
     assert(length != 0);
     int chunk = $nul;
     int chunkStart = -1;
     bool isLeaf = false;
     for (int i = offset; i < offset + length; i++) {
       if (strings[i].length == start) {
         isLeaf = true;
       }
       if (strings[i].length > start) {
         int c = strings[i].codeUnitAt(start);
         if (chunk != c) {
           if (chunkStart != -1) {
-            result[chunk - $a] = _computeKeywordStateTable(
+            result[chunk - $A] = _computeKeywordStateTable(
                 start + 1, strings, chunkStart, i - chunkStart);
           }
           chunkStart = i;
           chunk = c;
         }
       }
     }
     if (chunkStart != -1) {
-      assert(result[chunk - $a] == null);
-      result[chunk - $a] = _computeKeywordStateTable(
+      assert(result[chunk - $A] == null);
+      result[chunk - $A] = _computeKeywordStateTable(
           start + 1, strings, chunkStart, offset + length - chunkStart);
     } else {
       assert(length == 1);
       return new KeywordState(_EMPTY_TABLE, strings[offset]);
     }
     if (isLeaf) {
       return new KeywordState(result, strings[offset]);
     } else {
       return new KeywordState(result, null);
     }
@@ skipping 175 matching lines @@
     }
     if (next == $r) {
       // 'r'
       int peek = _reader.peek();
       if (peek == $double_quote || peek == $single_quote) {
         // '"' || "'"
         int start = _reader.offset;
         return _tokenizeString(_reader.advance(), start, true);
       }
     }
-    if ($a <= next && next <= $z) {
-      // 'a'-'z'
+    if (($A <= next && next <= $Z) || ($a <= next && next <= $z)) {
+      // 'A'-'Z' || 'a'-'z'
       return _tokenizeKeywordOrIdentifier(next, true);
     }
-    if (($A <= next && next <= $Z) || next == $_ || next == $$) {
-      // 'A'-'Z' || '_' || '$'
+    if (next == $_ || next == $$) {
+      // '_' || '$'
       return _tokenizeIdentifier(next, _reader.offset, true);
     }
     if (next == $lt) {
       // '<'
       return _tokenizeLessThan(next);
     }
     if (next == $gt) {
       // '>'
       return _tokenizeGreaterThan(next);
     }
@@ skipping 632 matching lines @@
       _beginToken();
       next = _tokenizeKeywordOrIdentifier(next, false);
     }
     _beginToken();
     return next;
   }
 
   int _tokenizeKeywordOrIdentifier(int next, bool allowDollar) {
     KeywordState state = KeywordState.KEYWORD_STATE;
     int start = _reader.offset;
-    while (state != null && $a <= next && next <= $z) {
+    while (state != null &&
+        (($A <= next && next <= $Z) || $a <= next && next <= $z)) {
       state = state.next(next);
       next = _reader.advance();
     }
     if (state == null || state.keyword() == null) {
       return _tokenizeIdentifier(next, start, allowDollar);
     }
-    if (($A <= next && next <= $Z) ||
-        ($0 <= next && next <= $9) ||
-        next == $_ ||
-        next == $$) {
+    if (($0 <= next && next <= $9) || next == $_ || next == $$) {
       return _tokenizeIdentifier(next, start, allowDollar);
     } else if (next < 128) {
       _appendKeywordToken(state.keyword());
       return next;
     } else {
       return _tokenizeIdentifier(next, start, allowDollar);
     }
   }
 
   int _tokenizeLessThan(int next) {
@@ skipping 373 matching lines @@
   }
 
   /**
    * Checks if [value] is a single-line or multi-line comment.
    */
   static bool _isDocumentationComment(String value) {
     return StringUtilities.startsWith3(value, 0, $slash, $slash, $slash) ||
         StringUtilities.startsWith3(value, 0, $slash, $asterisk, $asterisk);
   }
 }