java2dart improvement - use field if getter/setter are trivial.

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 302 matching lines @@
       LIBRARY,
       OPERATOR,
       PART,
       SET,
       STATIC,
       TYPEDEF];
 
   /**
    * The lexeme for the keyword.
    */
-  String _syntax;
+  String syntax;
 
   /**
    * A flag indicating whether the keyword is a pseudo-keyword. Pseudo keywords can be used as
    * identifiers.
    */
-  bool _isPseudoKeyword2 = false;
+  bool isPseudoKeyword = false;
 
   /**
    * A table mapping the lexemes of keywords to the corresponding keyword.
    */
   static Map<String, Keyword> keywords = createKeywordMap();
 
   /**
    * Create a table mapping the lexemes of keywords to the corresponding keyword.
    *
    * @return the table that was created
    */
   static Map<String, Keyword> createKeywordMap() {
     LinkedHashMap<String, Keyword> result = new LinkedHashMap<String, Keyword>();
     for (Keyword keyword in values) {
-      result[keyword._syntax] = keyword;
+      result[keyword.syntax] = keyword;
     }
     return result;
   }
 
   /**
    * Initialize a newly created keyword to have the given syntax. The keyword is not a
    * pseudo-keyword.
    *
    * @param syntax the lexeme for the keyword
    */
   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(String name, int ordinal, String syntax, bool isPseudoKeyword) : super(name, ordinal) {
-    this._syntax = syntax;
-    this._isPseudoKeyword2 = isPseudoKeyword;
+    this.syntax = syntax;
+    this.isPseudoKeyword = 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;
 }
 /**
  * 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.
  *
  * @coverage dart.engine.parser
  */
 abstract class AbstractScanner {
 
   /**
    * The source being scanned.
    */
-  Source _source;
+  Source source;
 
   /**
    * The error listener that will be informed of any errors that are found during the scan.
    */
   AnalysisErrorListener _errorListener;
 
   /**
    * The token pointing to the head of the linked list of tokens.
    */
   Token _tokens;
@@ skipping 34 matching lines @@
    */
   bool _hasUnmatchedGroups2 = false;
 
   /**
    * Initialize a newly created scanner.
    *
    * @param source the source being scanned
    * @param errorListener the error listener that will be informed of any errors that are found
    */
   AbstractScanner(Source source, AnalysisErrorListener errorListener) {
-    this._source = source;
+    this.source = source;
     this._errorListener = errorListener;
     _tokens = new Token(TokenType.EOF, -1);
     _tokens.setNext(_tokens);
     _tail = _tokens;
     _tokenStart = -1;
     _lineStarts.add(0);
   }
 
   /**
    * Return an array containing the offsets of the first character of each line in the source code.
@@ skipping 331 matching lines @@
       }
       _hasUnmatchedGroups2 = true;
       _groupingStack.removeAt(last);
       last--;
     }
     return null;
   }
   Token firstToken() => _tokens.next;
 
   /**
-   * Return the source being scanned.
-   *
-   * @return the source being scanned
-   */
-  Source get source => _source;
-
-  /**
    * Report an error at the current offset.
    *
    * @param errorCode the error code indicating the nature of the error
    * @param arguments any arguments needed to complete the error message
    */
   void reportError(ScannerErrorCode errorCode, List<Object> arguments) {
     _errorListener.onError(new AnalysisError.con2(source, offset, 1, errorCode, arguments));
   }
   int select(int choice, TokenType yesType, TokenType noType) {
     int next = advance();
@@ skipping 624 matching lines @@
  * Instances of the class `Token` represent a token that was scanned from the input. Each
  * token knows which token follows it, acting as the head of a linked list of tokens.
  *
  * @coverage dart.engine.parser
  */
 class Token {
 
   /**
    * The type of the token.
    */
-  TokenType _type;
+  TokenType type;
 
   /**
    * The offset from the beginning of the file to the first character in the token.
    */
-  int _offset = 0;
+  int offset = 0;
 
   /**
    * The previous token in the token stream.
    */
-  Token _previous;
+  Token previous;
 
   /**
    * The next token in the token stream.
    */
-  Token _next;
+  Token next;
 
   /**
    * Initialize a newly created token to have the given type and offset.
    *
    * @param type the type of the token
    * @param offset the offset from the beginning of the file to the first character in the token
    */
   Token(TokenType type, int offset) {
-    this._type = type;
-    this._offset = offset;
+    this.type = type;
+    this.offset = offset;
   }
 
   /**
    * Return the offset from the beginning of the file to the character after last character of the
    * token.
    *
    * @return the offset from the beginning of the file to the first character after last character
    *         of the token
    */
-  int get end => _offset + length;
+  int get end => offset + length;
 
   /**
    * Return the number of characters in the node's source range.
    *
    * @return the number of characters in the node's source range
    */
   int get length => lexeme.length;
 
   /**
    * Return the lexeme that represents this token.
    *
    * @return the lexeme that represents this token
    */
-  String get lexeme => _type.lexeme;
-
-  /**
-   * Return the next token in the token stream.
-   *
-   * @return the next token in the token stream
-   */
-  Token get next => _next;
-
-  /**
-   * Return the offset from the beginning of the file to the first character in the token.
-   *
-   * @return the offset from the beginning of the file to the first character in the token
-   */
-  int get offset => _offset;
+  String get lexeme => type.lexeme;
 
   /**
    * Return the first comment in the list of comments that precede this token, or `null` if
    * there are no comments preceding this token. Additional comments can be reached by following the
    * token stream using [getNext] until `null` is returned.
    *
    * @return the first comment in the list of comments that precede this token
    */
   Token get precedingComments => null;
 
   /**
-   * Return the previous token in the token stream.
-   *
-   * @return the previous token in the token stream
-   */
-  Token get previous => _previous;
-
-  /**
-   * Return the type of the token.
-   *
-   * @return the type of the token
-   */
-  TokenType get type => _type;
-
-  /**
    * Return `true` if this token represents an operator.
    *
    * @return `true` if this token represents an operator
    */
-  bool get isOperator => _type.isOperator;
+  bool get isOperator => type.isOperator;
 
   /**
    * Return `true` if this token is a synthetic token. A synthetic token is a token that was
    * introduced by the parser in order to recover from an error in the code. Synthetic tokens always
    * have a length of zero (`0`).
    *
    * @return `true` if this token is a synthetic token
    */
   bool get isSynthetic => length == 0;
 
   /**
    * Return `true` if this token represents an operator that can be defined by users.
    *
    * @return `true` if this token represents an operator that can be defined by users
    */
-  bool get isUserDefinableOperator => _type.isUserDefinableOperator;
+  bool get isUserDefinableOperator => type.isUserDefinableOperator;
 
   /**
    * Set the next token in the token stream to the given token. This has the side-effect of setting
    * this token to be the previous token for the given token.
    *
    * @param token the next token in the token stream
    * @return the token that was passed in
    */
   Token setNext(Token token) {
-    _next = token;
+    next = token;
     token.previous = this;
     return token;
   }
 
   /**
    * Set the next token in the token stream to the given token without changing which token is the
    * previous token for the given token.
    *
    * @param token the next token in the token stream
    * @return the token that was passed in
    */
   Token setNextWithoutSettingPrevious(Token token) {
-    _next = token;
+    next = token;
     return token;
   }
-
-  /**
-   * Set the offset from the beginning of the file to the first character in the token to the given
-   * offset.
-   *
-   * @param offset the offset from the beginning of the file to the first character in the token
-   */
-  void set offset(int offset2) {
-    this._offset = offset2;
-  }
   String toString() => lexeme;
 
   /**
    * Return the value of this token. For keyword tokens, this is the keyword associated with the
    * token, for other tokens it is the lexeme associated with the token.
    *
    * @return the value of this token
    */
-  Object value() => _type.lexeme;
-
-  /**
-   * Set the previous token in the token stream to the given token.
-   *
-   * @param previous the previous token in the token stream
-   */
-  void set previous(Token previous2) {
-    this._previous = previous2;
-  }
+  Object value() => type.lexeme;
 }
 /**
  * Instances of the class `StringScanner` implement a scanner that reads from a string. The
  * scanning logic is in the superclass.
  *
  * @coverage dart.engine.parser
  */
 class StringScanner extends AbstractScanner {
 
   /**
@@ skipping 99 matching lines @@
 /**
  * Instances of the class `KeywordToken` represent a keyword in the language.
  *
  * @coverage dart.engine.parser
  */
 class KeywordToken extends Token {
 
   /**
    * The keyword being represented by this token.
    */
-  Keyword _keyword;
+  Keyword keyword;
 
   /**
    * Initialize a newly created token to represent the given keyword.
    *
    * @param keyword the keyword being represented by this token
    * @param offset the offset from the beginning of the file to the first character in the token
    */
   KeywordToken(Keyword keyword, int offset) : super(TokenType.KEYWORD, offset) {
-    this._keyword = keyword;
+    this.keyword = keyword;
   }
-
-  /**
-   * Return the keyword being represented by this token.
-   *
-   * @return the keyword being represented by this token
-   */
-  Keyword get keyword => _keyword;
-  String get lexeme => _keyword.syntax;
-  Keyword value() => _keyword;
+  String get lexeme => keyword.syntax;
+  Keyword value() => keyword;
 }
 /**
  * Instances of the class `BeginToken` represent the opening half of a grouping pair of
  * tokens. This is used for curly brackets ('{'), parentheses ('('), and square brackets ('[').
  *
  * @coverage dart.engine.parser
  */
 class BeginToken extends Token {
 
   /**
    * The token that corresponds to this token.
    */
-  Token _endToken;
+  Token endToken;
 
   /**
    * Initialize a newly created token representing the opening half of a grouping pair of tokens.
    *
    * @param type the type of the token
    * @param offset the offset from the beginning of the file to the first character in the token
    */
   BeginToken(TokenType type, int offset) : super(type, offset) {
     assert((identical(type, TokenType.OPEN_CURLY_BRACKET) || identical(type, TokenType.OPEN_PAREN) || identical(type, TokenType.OPEN_SQUARE_BRACKET) || identical(type, TokenType.STRING_INTERPOLATION_EXPRESSION)));
   }
-
-  /**
-   * Return the token that corresponds to this token.
-   *
-   * @return the token that corresponds to this token
-   */
-  Token get endToken => _endToken;
-
-  /**
-   * Set the token that corresponds to this token to the given token.
-   *
-   * @param token the token that corresponds to this token
-   */
-  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 extends Enum<TokenClass> {
 
   /**
    * A value used to indicate that the token type is not part of any specific class of token.
@@ skipping 89 matching lines @@
       MULTIPLICATIVE_OPERATOR,
       RELATIONAL_OPERATOR,
       SHIFT_OPERATOR,
       UNARY_POSTFIX_OPERATOR,
       UNARY_PREFIX_OPERATOR];
 
   /**
    * The precedence of tokens of this class, or `0` if the such tokens do not represent an
    * operator.
    */
-  int _precedence = 0;
+  int precedence = 0;
   TokenClass.con1(String name, int ordinal) : this.con2(name, ordinal, 0);
   TokenClass.con2(String name, int ordinal, int precedence) : super(name, ordinal) {
-    this._precedence = precedence;
+    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;
 }
 /**
  * Instances of the class `KeywordTokenWithComment` implement a keyword token that is preceded
  * by comments.
  *
  * @coverage dart.engine.parser
  */
 class KeywordTokenWithComment extends KeywordToken {
 
   /**
@@ skipping 165 matching lines @@
 
   /**
    * 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;
+  String lexeme;
   TokenType.con1(String name, int ordinal) : this.con2(name, ordinal, TokenClass.NO_CLASS, null);
   TokenType.con2(String name, int ordinal, TokenClass tokenClass, String lexeme) : super(name, ordinal) {
     this._tokenClass = tokenClass == null ? TokenClass.NO_CLASS : tokenClass;
-    this._lexeme = lexeme;
+    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
-   */
-  String get lexeme => _lexeme;
-
-  /**
    * Return the precedence of the token, or `0` if the token does not represent an operator.
    *
    * @return the precedence of the token
    */
   int get precedence => _tokenClass.precedence;
 
   /**
    * Return `true` if this type of token represents an additive operator.
    *
    * @return `true` if this type of token represents an additive operator
@@ skipping 26 matching lines @@
    *
    * @return `true` if this type of token represents an equality operator
    */
   bool get isEqualityOperator => identical(_tokenClass, TokenClass.EQUALITY_OPERATOR);
 
   /**
    * Return `true` if this type of token represents an increment operator.
    *
    * @return `true` if this type of token represents an increment operator
    */
-  bool get isIncrementOperator => identical(_lexeme, "++") || identical(_lexeme, "--");
+  bool get isIncrementOperator => identical(lexeme, "++") || identical(lexeme, "--");
 
   /**
    * Return `true` if this type of token represents a multiplicative operator.
    *
    * @return `true` if this type of token represents a multiplicative operator
    */
   bool get isMultiplicativeOperator => identical(_tokenClass, TokenClass.MULTIPLICATIVE_OPERATOR);
 
   /**
    * Return `true` if this token type represents an operator.
@@ skipping 28 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, "|");
+  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, "|");
 }
 class TokenType_EOF extends TokenType {
   TokenType_EOF(String name, int ordinal, TokenClass arg0, String arg1) : super.con2(name, ordinal, arg0, arg1);
   String toString() => "-eof-";
 }