Convert isX() methods to isX getter.

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 293 matching lines @@
    * 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 isPseudoKeyword() => _isPseudoKeyword2;
+  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 "<<"
@@ skipping 1128 matching lines @@
   /**
    * 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 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 isSynthetic() => length == 0;
+  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 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;
     token.previous = this;
@@ skipping 467 matching lines @@
   /**
    * 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
    */
-  bool isAdditiveOperator() => identical(_tokenClass, TokenClass.ADDITIVE_OPERATOR);
+  bool get isAdditiveOperator => identical(_tokenClass, TokenClass.ADDITIVE_OPERATOR);
 
   /**
    * Return `true` if this type of token represents an assignment operator.
    * @return `true` if this type of token represents an assignment operator
    */
-  bool isAssignmentOperator() => identical(_tokenClass, TokenClass.ASSIGNMENT_OPERATOR);
+  bool get isAssignmentOperator => identical(_tokenClass, TokenClass.ASSIGNMENT_OPERATOR);
 
   /**
    * Return `true` if this type of token represents an associative operator. An associative
    * operator is an operator for which the following equality is true:`(a * b) * c == a * (b * c)`. In other words, if the result of applying the operator to
    * multiple operands does not depend on the order in which those applications occur.
    *
    * Note: This method considers the logical-and and logical-or operators to be associative, even
    * though the order in which the application of those operators can have an effect because
    * evaluation of the right-hand operand is conditional.
    * @return `true` if this type of token represents an associative operator
    */
-  bool isAssociativeOperator() => identical(this, AMPERSAND) || identical(this, AMPERSAND_AMPERSAND) || identical(this, BAR) || identical(this, BAR_BAR) || identical(this, CARET) || identical(this, PLUS) || identical(this, STAR);
+  bool get isAssociativeOperator => identical(this, AMPERSAND) || identical(this, AMPERSAND_AMPERSAND) || identical(this, BAR) || identical(this, BAR_BAR) || identical(this, CARET) || identical(this, PLUS) || identical(this, STAR);
 
   /**
    * Return `true` if this type of token represents an equality operator.
    * @return `true` if this type of token represents an equality operator
    */
-  bool isEqualityOperator() => identical(_tokenClass, TokenClass.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 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 isMultiplicativeOperator() => identical(_tokenClass, TokenClass.MULTIPLICATIVE_OPERATOR);
+  bool get isMultiplicativeOperator => identical(_tokenClass, TokenClass.MULTIPLICATIVE_OPERATOR);
 
   /**
    * Return `true` if this token type represents an operator.
    * @return `true` if this token type represents an operator
    */
-  bool isOperator() => _tokenClass != TokenClass.NO_CLASS && this != OPEN_PAREN && this != OPEN_SQUARE_BRACKET && this != PERIOD;
+  bool get isOperator => _tokenClass != TokenClass.NO_CLASS && this != OPEN_PAREN && this != OPEN_SQUARE_BRACKET && this != PERIOD;
 
   /**
    * Return `true` if this type of token represents a relational operator.
    * @return `true` if this type of token represents a relational operator
    */
-  bool isRelationalOperator() => identical(_tokenClass, TokenClass.RELATIONAL_OPERATOR);
+  bool get isRelationalOperator => identical(_tokenClass, TokenClass.RELATIONAL_OPERATOR);
 
   /**
    * Return `true` if this type of token represents a shift operator.
    * @return `true` if this type of token represents a shift operator
    */
-  bool isShiftOperator() => identical(_tokenClass, TokenClass.SHIFT_OPERATOR);
+  bool get isShiftOperator => identical(_tokenClass, TokenClass.SHIFT_OPERATOR);
 
   /**
    * Return `true` if this type of token represents a unary postfix operator.
    * @return `true` if this type of token represents a unary postfix operator
    */
-  bool isUnaryPostfixOperator() => identical(_tokenClass, TokenClass.UNARY_POSTFIX_OPERATOR);
+  bool get isUnaryPostfixOperator => identical(_tokenClass, TokenClass.UNARY_POSTFIX_OPERATOR);
 
   /**
    * Return `true` if this type of token represents a unary prefix operator.
    * @return `true` if this type of token represents a unary prefix operator
    */
-  bool isUnaryPrefixOperator() => identical(_tokenClass, TokenClass.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 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, "|");
   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-";
 }