merge fasta.Keyword into analyzer.Keyword

pkg/front_end/lib/src/fasta/scanner/keyword.dart

Index: pkg/front_end/lib/src/fasta/scanner/keyword.dart
diff --git a/pkg/front_end/lib/src/fasta/scanner/keyword.dart b/pkg/front_end/lib/src/fasta/scanner/keyword.dart
deleted file mode 100644
index 430484e737ee1180d654d2880ab3ccbe23492238..0000000000000000000000000000000000000000
--- a/pkg/front_end/lib/src/fasta/scanner/keyword.dart
+++ /dev/null
@@ -1,315 +0,0 @@
-// Copyright (c) 2011, 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 fasta.scanner.keywords;
-
-import '../../scanner/token.dart' as analyzer;
-
-import 'characters.dart' show $a, $z, $A, $Z;
-
-import 'precedence.dart' show PrecedenceInfo;
-
-import 'precedence.dart' show AS_INFO, IS_INFO, KEYWORD_INFO;
-
-/**
- * A keyword in the Dart programming language.
- */
-class Keyword extends analyzer.Keyword {
-  static const ASSERT = const Keyword("assert");
-  static const BREAK = const Keyword("break");
-  static const CASE = const Keyword("case");
-  static const CATCH = const Keyword("catch");
-  static const CLASS = const Keyword("class");
-  static const CONST = const Keyword("const");
-  static const CONTINUE = const Keyword("continue");
-  static const DEFAULT = const Keyword("default");
-  static const DO = const Keyword("do");
-  static const ELSE = const Keyword("else");
-  static const ENUM = const Keyword("enum");
-  static const EXTENDS = const Keyword("extends");
-  static const FALSE = const Keyword("false");
-  static const FINAL = const Keyword("final");
-  static const FINALLY = const Keyword("finally");
-  static const FOR = const Keyword("for");
-  static const IF = const Keyword("if");
-  static const IN = const Keyword("in");
-  static const NEW = const Keyword("new");
-  static const NULL = const Keyword("null");
-  static const RETHROW = const Keyword("rethrow");
-  static const RETURN = const Keyword("return");
-  static const SUPER = const Keyword("super");
-  static const SWITCH = const Keyword("switch");
-  static const THIS = const Keyword("this");
-  static const THROW = const Keyword("throw");
-  static const TRUE = const Keyword("true");
-  static const TRY = const Keyword("try");
-  static const VAR = const Keyword("var");
-  static const VOID = const Keyword("void");
-  static const WHILE = const Keyword("while");
-  static const WITH = const Keyword("with");
-
-  // TODO(ahe): Don't think this is a reserved word.
-  // See: http://dartbug.com/5579
-  static const IS = const Keyword("is", info: IS_INFO);
-
-  static const ABSTRACT = const Keyword("abstract", isBuiltIn: true);
-  static const AS = const Keyword("as", info: AS_INFO, isBuiltIn: true);
-  static const COVARIANT = const Keyword("covariant", isBuiltIn: true);
-  static const DYNAMIC = const Keyword("dynamic", isBuiltIn: true);
-  static const EXPORT = const Keyword("export", isBuiltIn: true);
-  static const EXTERNAL = const Keyword("external", isBuiltIn: true);
-  static const FACTORY = const Keyword("factory", isBuiltIn: true);
-  static const GET = const Keyword("get", isBuiltIn: true);
-  static const IMPLEMENTS = const Keyword("implements", isBuiltIn: true);
-  static const IMPORT = const Keyword("import", isBuiltIn: true);
-  static const LIBRARY = const Keyword("library", isBuiltIn: true);
-  static const OPERATOR = const Keyword("operator", isBuiltIn: true);
-  static const PART = const Keyword("part", isBuiltIn: true);
-  static const SET = const Keyword("set", isBuiltIn: true);
-  static const STATIC = const Keyword("static", isBuiltIn: true);
-  static const TYPEDEF = const Keyword("typedef", isBuiltIn: true);
-
-  static const ASYNC = const Keyword("async", isPseudo: true);
-  static const AWAIT = const Keyword("await", isPseudo: true);
-  static const DEFERRED = const Keyword("deferred", isBuiltIn: true);
-  static const FUNCTION = const Keyword("Function", isPseudo: true);
-  static const HIDE = const Keyword("hide", isPseudo: true);
-  static const NATIVE = const Keyword("native", isPseudo: true);
-  static const OF = const Keyword("of", isPseudo: true);
-  static const ON = const Keyword("on", isPseudo: true);
-  static const PATCH = const Keyword("patch", isPseudo: true);
-  static const SHOW = const Keyword("show", isPseudo: true);
-  static const SOURCE = const Keyword("source", isPseudo: true);
-  static const SYNC = const Keyword("sync", isPseudo: true);
-  static const YIELD = const Keyword("yield", isPseudo: true);
-
-  static const List<Keyword> values = const <Keyword>[
-    ASSERT,
-    BREAK,
-    CASE,
-    CATCH,
-    CLASS,
-    CONST,
-    CONTINUE,
-    DEFAULT,
-    DO,
-    ELSE,
-    ENUM,
-    EXTENDS,
-    FALSE,
-    FINAL,
-    FINALLY,
-    FOR,
-    IF,
-    IN,
-    NEW,
-    NULL,
-    RETHROW,
-    RETURN,
-    SUPER,
-    SWITCH,
-    THIS,
-    THROW,
-    TRUE,
-    TRY,
-    VAR,
-    VOID,
-    WHILE,
-    WITH,
-    // ====
-    IS,
-    // ==== Built In
-    ABSTRACT,
-    AS,
-    COVARIANT,
-    DEFERRED,
-    DYNAMIC,
-    EXPORT,
-    EXTERNAL,
-    FACTORY,
-    GET,
-    IMPLEMENTS,
-    IMPORT,
-    LIBRARY,
-    OPERATOR,
-    PART,
-    SET,
-    STATIC,
-    TYPEDEF,
-    // ==== Pseudo
-    ASYNC,
-    AWAIT,
-    FUNCTION,
-    HIDE,
-    NATIVE,
-    OF,
-    ON,
-    PATCH,
-    SHOW,
-    SOURCE,
-    SYNC,
-    YIELD,
-  ];
-
-  static Map<String, Keyword> _keywords;
-  static Map<String, Keyword> get keywords {
-    if (_keywords == null) {
-      _keywords = computeKeywordMap();
-    }
-    return _keywords;
-  }
-
-  const Keyword(String syntax,
-      {bool isPseudo: false,
-      bool isBuiltIn: false,
-      PrecedenceInfo info: KEYWORD_INFO})
-      : super(syntax, info: info, isBuiltIn: isBuiltIn, isPseudo: isPseudo);
-
-  static Map<String, Keyword> computeKeywordMap() {
-    Map<String, Keyword> result = new Map<String, Keyword>();
-    for (Keyword keyword in values) {
-      result[keyword.syntax] = keyword;
-    }
-    return result;
-  }
-}
-
-/**
- * Abstract state in a state machine for scanning keywords.
- */
-abstract class KeywordState {
-  KeywordState next(int c);
-  KeywordState nextCapital(int c);
-
-  Keyword get keyword;
-
-  static KeywordState _KEYWORD_STATE;
-  static KeywordState get KEYWORD_STATE {
-    if (_KEYWORD_STATE == null) {
-      List<String> strings = new List<String>(Keyword.values.length);
-      for (int i = 0; i < Keyword.values.length; i++) {
-        strings[i] = Keyword.values[i].syntax;
-      }
-      strings.sort((a, b) => a.compareTo(b));
-      _KEYWORD_STATE = computeKeywordStateTable(0, strings, 0, strings.length);
-    }
-    return _KEYWORD_STATE;
-  }
-
-  static KeywordState computeKeywordStateTable(
-      int start, List<String> strings, int offset, int length) {
-    bool isLowercase = true;
-
-    List<KeywordState> table = new List<KeywordState>($z - $A + 1);
-    assert(length != 0);
-    int chunk = 0;
-    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 ($A <= c && c <= $Z) {
-          isLowercase = false;
-        }
-        if (chunk != c) {
-          if (chunkStart != -1) {
-            assert(table[chunk - $A] == null);
-            table[chunk - $A] = computeKeywordStateTable(
-                start + 1, strings, chunkStart, i - chunkStart);
-          }
-          chunkStart = i;
-          chunk = c;
-        }
-      }
-    }
-    if (chunkStart != -1) {
-      assert(table[chunk - $A] == null);
-      table[chunk - $A] = computeKeywordStateTable(
-          start + 1, strings, chunkStart, offset + length - chunkStart);
-    } else {
-      assert(length == 1);
-      return new LeafKeywordState(strings[offset]);
-    }
-    String syntax = isLeaf ? strings[offset] : null;
-    if (isLowercase) {
-      table = table.sublist($a - $A);
-      return new LowerCaseArrayKeywordState(table, syntax);
-    } else {
-      return new UpperCaseArrayKeywordState(table, syntax);
-    }
-  }
-}
-
-/**
- * A state with multiple outgoing transitions.
- */
-abstract class ArrayKeywordState implements KeywordState {
-  final List<KeywordState> table;
-  final Keyword keyword;
-
-  ArrayKeywordState(this.table, String syntax)
-      : keyword = ((syntax == null) ? null : Keyword.keywords[syntax]);
-
-  KeywordState next(int c);
-
-  KeywordState nextCapital(int c);
-
-  String toString() {
-    StringBuffer sb = new StringBuffer();
-    sb.write("[");
-    if (keyword != null) {
-      sb.write("*");
-      sb.write(keyword);
-      sb.write(" ");
-    }
-    List<KeywordState> foo = table;
-    for (int i = 0; i < foo.length; i++) {
-      if (foo[i] != null) {
-        sb.write("${new String.fromCharCodes([i + $a])}: "
-            "${foo[i]}; ");
-      }
-    }
-    sb.write("]");
-    return sb.toString();
-  }
-}
-
-class LowerCaseArrayKeywordState extends ArrayKeywordState {
-  LowerCaseArrayKeywordState(List<KeywordState> table, String syntax)
-      : super(table, syntax) {
-    assert(table.length == $z - $a + 1);
-  }
-
-  KeywordState next(int c) => table[c - $a];
-
-  KeywordState nextCapital(int c) => null;
-}
-
-class UpperCaseArrayKeywordState extends ArrayKeywordState {
-  UpperCaseArrayKeywordState(List<KeywordState> table, String syntax)
-      : super(table, syntax) {
-    assert(table.length == $z - $A + 1);
-  }
-
-  KeywordState next(int c) => table[c - $A];
-
-  KeywordState nextCapital(int c) => table[c - $A];
-}
-
-/**
- * A state that has no outgoing transitions.
- */
-class LeafKeywordState implements KeywordState {
-  final Keyword keyword;
-
-  LeafKeywordState(String syntax) : keyword = Keyword.keywords[syntax];
-
-  KeywordState next(int c) => null;
-  KeywordState nextCapital(int c) => null;
-
-  String toString() => keyword.syntax;
-}