java2dart improvements and new analyzer_experimental snapshot.

pkg/analyzer_experimental/lib/src/generated/scanner.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.scanner;
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'source.dart';
 import 'error.dart';
 import 'instrumentation.dart';
 /**
@@ skipping 117 matching lines @@
    * @return the state that follows this state on a transition of the given character
    */
   KeywordState next(int c) => _table[c - 0x61];
 }
 /**
  * The enumeration `ScannerErrorCode` defines the error codes used for errors detected by the
  * scanner.
  *
  * @coverage dart.engine.parser
  */
-class ScannerErrorCode implements Enum<ScannerErrorCode>, ErrorCode {
-  static final ScannerErrorCode CHARACTER_EXPECTED_AFTER_SLASH = new ScannerErrorCode('CHARACTER_EXPECTED_AFTER_SLASH', 0, "Character expected after slash");
-  static final ScannerErrorCode ILLEGAL_CHARACTER = new ScannerErrorCode('ILLEGAL_CHARACTER', 1, "Illegal character %x");
-  static final ScannerErrorCode MISSING_DIGIT = new ScannerErrorCode('MISSING_DIGIT', 2, "Decimal digit expected");
-  static final ScannerErrorCode MISSING_HEX_DIGIT = new ScannerErrorCode('MISSING_HEX_DIGIT', 3, "Hexidecimal digit expected");
-  static final ScannerErrorCode MISSING_QUOTE = new ScannerErrorCode('MISSING_QUOTE', 4, "Expected quote (' or \")");
-  static final ScannerErrorCode UNTERMINATED_MULTI_LINE_COMMENT = new ScannerErrorCode('UNTERMINATED_MULTI_LINE_COMMENT', 5, "Unterminated multi-line comment");
-  static final ScannerErrorCode UNTERMINATED_STRING_LITERAL = new ScannerErrorCode('UNTERMINATED_STRING_LITERAL', 6, "Unterminated string literal");
+class ScannerErrorCode extends Enum<ScannerErrorCode> implements ErrorCode {
+  static final ScannerErrorCode CHARACTER_EXPECTED_AFTER_SLASH = new ScannerErrorCode.con1('CHARACTER_EXPECTED_AFTER_SLASH', 0, "Character expected after slash");
+  static final ScannerErrorCode ILLEGAL_CHARACTER = new ScannerErrorCode.con1('ILLEGAL_CHARACTER', 1, "Illegal character %x");
+  static final ScannerErrorCode MISSING_DIGIT = new ScannerErrorCode.con1('MISSING_DIGIT', 2, "Decimal digit expected");
+  static final ScannerErrorCode MISSING_HEX_DIGIT = new ScannerErrorCode.con1('MISSING_HEX_DIGIT', 3, "Hexidecimal digit expected");
+  static final ScannerErrorCode MISSING_QUOTE = new ScannerErrorCode.con1('MISSING_QUOTE', 4, "Expected quote (' or \")");
+  static final ScannerErrorCode UNTERMINATED_MULTI_LINE_COMMENT = new ScannerErrorCode.con1('UNTERMINATED_MULTI_LINE_COMMENT', 5, "Unterminated multi-line comment");
+  static final ScannerErrorCode UNTERMINATED_STRING_LITERAL = new ScannerErrorCode.con1('UNTERMINATED_STRING_LITERAL', 6, "Unterminated string literal");
   static final List<ScannerErrorCode> values = [
       CHARACTER_EXPECTED_AFTER_SLASH,
       ILLEGAL_CHARACTER,
       MISSING_DIGIT,
       MISSING_HEX_DIGIT,
       MISSING_QUOTE,
       UNTERMINATED_MULTI_LINE_COMMENT,
       UNTERMINATED_STRING_LITERAL];
 
-  /// The name of this enum constant, as declared in the enum declaration.
-  final String name;
-
-  /// The position in the enum declaration.
-  final int ordinal;
+  /**
+   * The template used to create the message to be displayed for this error.
+   */
+  String _message;
 
   /**
-   * The message template used to create the message to be displayed for this error.
+   * The template used to create the correction to be displayed for this error, or `null` if
+   * there is no correction information for this error.
    */
-  String _message;
+  String correction10;
 
   /**
    * Initialize a newly created error code to have the given message.
    *
    * @param message the message template used to create the message to be displayed for this error
    */
-  ScannerErrorCode(this.name, this.ordinal, String message) {
+  ScannerErrorCode.con1(String name, int ordinal, String message) : super(name, ordinal) {
     this._message = message;
   }
+
+  /**
+   * Initialize a newly created error code to have the given message and correction.
+   *
+   * @param message the template used to create the message to be displayed for the error
+   * @param correction the template used to create the correction to be displayed for the error
+   */
+  ScannerErrorCode.con2(String name, int ordinal, String message, String correction) : super(name, ordinal) {
+    this._message = message;
+    this.correction10 = correction;
+  }
+  String get correction => correction10;
   ErrorSeverity get errorSeverity => ErrorSeverity.ERROR;
   String get message => _message;
   ErrorType get type => ErrorType.SYNTACTIC_ERROR;
-  int compareTo(ScannerErrorCode other) => ordinal - other.ordinal;
-  int get hashCode => ordinal;
-  String toString() => name;
 }
 /**
  * Instances of the class `TokenWithComment` represent a string token that is preceded by
  * comments.
  *
  * @coverage dart.engine.parser
  */
 class StringTokenWithComment extends StringToken {
 
   /**
@@ skipping 12 matching lines @@
   StringTokenWithComment(TokenType type, String value, int offset, Token precedingComment) : super(type, value, offset) {
     this._precedingComment = precedingComment;
   }
   Token get precedingComments => _precedingComment;
 }
 /**
  * The enumeration `Keyword` defines the keywords in the Dart programming language.
  *
  * @coverage dart.engine.parser
  */
-class Keyword implements Enum<Keyword> {
+class Keyword extends Enum<Keyword> {
   static final Keyword ASSERT = new Keyword.con1('ASSERT', 0, "assert");
   static final Keyword BREAK = new Keyword.con1('BREAK', 1, "break");
   static final Keyword CASE = new Keyword.con1('CASE', 2, "case");
   static final Keyword CATCH = new Keyword.con1('CATCH', 3, "catch");
   static final Keyword CLASS = new Keyword.con1('CLASS', 4, "class");
   static final Keyword CONST = new Keyword.con1('CONST', 5, "const");
   static final Keyword CONTINUE = new Keyword.con1('CONTINUE', 6, "continue");
   static final Keyword DEFAULT = new Keyword.con1('DEFAULT', 7, "default");
   static final Keyword DO = new Keyword.con1('DO', 8, "do");
   static final Keyword ELSE = new Keyword.con1('ELSE', 9, "else");
@@ skipping 78 matching lines @@
       GET,
       IMPLEMENTS,
       IMPORT,
       LIBRARY,
       OPERATOR,
       PART,
       SET,
       STATIC,
       TYPEDEF];
 
-  /// The name of this enum constant, as declared in the enum declaration.
-  final String name;
-
-  /// The position in the enum declaration.
-  final int ordinal;
-
   /**
    * The lexeme for the keyword.
    */
   String _syntax;
 
   /**
    * A flag indicating whether the keyword is a pseudo-keyword. Pseudo keywords can be used as
    * identifiers.
    */
   bool _isPseudoKeyword2 = false;
@@ skipping 24 matching lines @@
    */
   Keyword.con1(String name, int ordinal, String syntax) : this.con2(name, ordinal, syntax, false);
 
   /**
    * Initialize a newly created keyword to have the given syntax. The keyword is a pseudo-keyword if
    * the given flag is `true`.
    *
    * @param syntax the lexeme for the keyword
    * @param isPseudoKeyword `true` if this keyword is a pseudo-keyword
    */
-  Keyword.con2(this.name, this.ordinal, String syntax, bool isPseudoKeyword) {
+  Keyword.con2(String name, int ordinal, String syntax, bool isPseudoKeyword) : super(name, ordinal) {
     this._syntax = syntax;
     this._isPseudoKeyword2 = isPseudoKeyword;
   }
 
   /**
    * Return the lexeme for the keyword.
    *
    * @return the lexeme for the keyword
    */
   String get syntax => _syntax;
 
   /**
    * Return `true` if this keyword is a pseudo-keyword. Pseudo keywords can be used as
    * identifiers.
    *
    * @return `true` if this keyword is a pseudo-keyword
    */
   bool get isPseudoKeyword => _isPseudoKeyword2;
-  int compareTo(Keyword other) => ordinal - other.ordinal;
-  int get hashCode => ordinal;
-  String toString() => name;
 }
 /**
  * The abstract class `AbstractScanner` implements a scanner for Dart code. Subclasses are
  * required to implement the interface used to access the characters being scanned.
  *
  * The lexical structure of Dart is ambiguous without knowledge of the context in which a token is
  * being scanned. For example, without context we cannot determine whether source of the form "<<"
  * should be scanned as a single left-shift operator or as two left angle brackets. This scanner
  * does not have any context, so it always resolves such conflicts by scanning the longest possible
  * token.
@@ skipping 646 matching lines @@
       beginToken();
       next = tokenizeKeywordOrIdentifier(next, false);
     }
     beginToken();
     return next;
   }
   int tokenizeKeywordOrIdentifier(int next2, bool allowDollar) {
     KeywordState state = KeywordState.KEYWORD_STATE;
     int start = offset;
     while (state != null && 0x61 <= next2 && next2 <= 0x7A) {
-      state = state.next((next2 as int));
+      state = state.next(next2 as int);
       next2 = advance();
     }
     if (state == null || state.keyword() == null) {
       return tokenizeIdentifier(next2, start, allowDollar);
     }
     if ((0x41 <= next2 && next2 <= 0x5A) || (0x30 <= next2 && next2 <= 0x39) || next2 == 0x5F || next2 == 0x24) {
       return tokenizeIdentifier(next2, start, allowDollar);
     } else if (next2 < 128) {
       appendKeywordToken(state.keyword());
       return next2;
@@ skipping 736 matching lines @@
    */
   void set endToken(Token token) {
     this._endToken = token;
   }
 }
 /**
  * The enumeration `TokenClass` represents classes (or groups) of tokens with a similar use.
  *
  * @coverage dart.engine.parser
  */
-class TokenClass implements Enum<TokenClass> {
+class TokenClass extends Enum<TokenClass> {
 
   /**
    * A value used to indicate that the token type is not part of any specific class of token.
    */
   static final TokenClass NO_CLASS = new TokenClass.con1('NO_CLASS', 0);
 
   /**
    * A value used to indicate that the token type is an additive operator.
    */
   static final TokenClass ADDITIVE_OPERATOR = new TokenClass.con2('ADDITIVE_OPERATOR', 1, 12);
@@ skipping 78 matching lines @@
       CONDITIONAL_OPERATOR,
       EQUALITY_OPERATOR,
       LOGICAL_AND_OPERATOR,
       LOGICAL_OR_OPERATOR,
       MULTIPLICATIVE_OPERATOR,
       RELATIONAL_OPERATOR,
       SHIFT_OPERATOR,
       UNARY_POSTFIX_OPERATOR,
       UNARY_PREFIX_OPERATOR];
 
-  /// The name of this enum constant, as declared in the enum declaration.
-  final String name;
-
-  /// The position in the enum declaration.
-  final int ordinal;
-
   /**
    * The precedence of tokens of this class, or `0` if the such tokens do not represent an
    * operator.
    */
   int _precedence = 0;
   TokenClass.con1(String name, int ordinal) : this.con2(name, ordinal, 0);
-  TokenClass.con2(this.name, this.ordinal, int precedence) {
+  TokenClass.con2(String name, int ordinal, int precedence) : super(name, ordinal) {
     this._precedence = precedence;
   }
 
   /**
    * Return the precedence of tokens of this class, or `0` if the such tokens do not represent
    * an operator.
    *
    * @return the precedence of tokens of this class
    */
   int get precedence => _precedence;
-  int compareTo(TokenClass other) => ordinal - other.ordinal;
-  int get hashCode => ordinal;
-  String toString() => name;
 }
 /**
  * Instances of the class `KeywordTokenWithComment` implement a keyword token that is preceded
  * by comments.
  *
  * @coverage dart.engine.parser
  */
 class KeywordTokenWithComment extends KeywordToken {
 
   /**
@@ skipping 13 matching lines @@
     this._precedingComment = precedingComment;
   }
   Token get precedingComments => _precedingComment;
 }
 /**
  * The enumeration `TokenType` defines the types of tokens that can be returned by the
  * scanner.
  *
  * @coverage dart.engine.parser
  */
-class TokenType implements Enum<TokenType> {
+class TokenType extends Enum<TokenType> {
 
   /**
    * The type of the token that marks the end of the input.
    */
   static final TokenType EOF = new TokenType_EOF('EOF', 0, null, "");
   static final TokenType DOUBLE = new TokenType.con1('DOUBLE', 1);
   static final TokenType HEXADECIMAL = new TokenType.con1('HEXADECIMAL', 2);
   static final TokenType IDENTIFIER = new TokenType.con1('IDENTIFIER', 3);
   static final TokenType INT = new TokenType.con1('INT', 4);
   static final TokenType KEYWORD = new TokenType.con1('KEYWORD', 5);
@@ skipping 122 matching lines @@
       STAR_EQ,
       STRING_INTERPOLATION_EXPRESSION,
       STRING_INTERPOLATION_IDENTIFIER,
       TILDE,
       TILDE_SLASH,
       TILDE_SLASH_EQ,
       BACKPING,
       BACKSLASH,
       PERIOD_PERIOD_PERIOD];
 
-  /// The name of this enum constant, as declared in the enum declaration.
-  final String name;
-
-  /// The position in the enum declaration.
-  final int ordinal;
-
   /**
    * The class of the token.
    */
   TokenClass _tokenClass;
 
   /**
    * The lexeme that defines this type of token, or `null` if there is more than one possible
    * lexeme for this type of token.
    */
   String _lexeme;
   TokenType.con1(String name, int ordinal) : this.con2(name, ordinal, TokenClass.NO_CLASS, null);
-  TokenType.con2(this.name, this.ordinal, TokenClass tokenClass, String lexeme) {
+  TokenType.con2(String name, int ordinal, TokenClass tokenClass, String lexeme) : super(name, ordinal) {
     this._tokenClass = tokenClass == null ? TokenClass.NO_CLASS : tokenClass;
     this._lexeme = lexeme;
   }
 
   /**
    * Return the lexeme that defines this type of token, or `null` if there is more than one
    * possible lexeme for this type of token.
    *
    * @return the lexeme that defines this type of token
    */
@@ skipping 89 matching lines @@
    * @return `true` if this type of token represents a unary prefix operator
    */
   bool get isUnaryPrefixOperator => identical(_tokenClass, TokenClass.UNARY_PREFIX_OPERATOR);
 
   /**
    * Return `true` if this token type represents an operator that can be defined by users.
    *
    * @return `true` if this token type represents an operator that can be defined by users
    */
   bool get isUserDefinableOperator => identical(_lexeme, "==") || identical(_lexeme, "~") || identical(_lexeme, "[]") || identical(_lexeme, "[]=") || identical(_lexeme, "*") || identical(_lexeme, "/") || identical(_lexeme, "%") || identical(_lexeme, "~/") || identical(_lexeme, "+") || identical(_lexeme, "-") || identical(_lexeme, "<<") || identical(_lexeme, ">>") || identical(_lexeme, ">=") || identical(_lexeme, ">") || identical(_lexeme, "<=") || identical(_lexeme, "<") || identical(_lexeme, "&") || identical(_lexeme, "^") || identical(_lexeme, "|");
-  int compareTo(TokenType other) => ordinal - other.ordinal;
-  int get hashCode => ordinal;
-  String toString() => name;
 }
 class TokenType_EOF extends TokenType {
   TokenType_EOF(String name, int ordinal, TokenClass arg0, String arg1) : super.con2(name, ordinal, arg0, arg1);
   String toString() => "-eof-";
 }