Convert isX() methods to isX getter.

pkg/analyzer_experimental/lib/src/generated/ast.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.ast;
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'error.dart';
 import 'source.dart' show LineInfo;
 import 'scanner.dart';
 import 'engine.dart' show AnalysisEngine;
@@ skipping 127 matching lines @@
     }
     return root;
   }
 
   /**
    * Return `true` if this node is a synthetic node. A synthetic node is a node that was
    * introduced by the parser in order to recover from an error in the code. Synthetic nodes always
    * have a length of zero (`0`).
    * @return `true` if this node is a synthetic node
    */
-  bool isSynthetic() => false;
+  bool get isSynthetic => false;
 
   /**
    * Set the value of the property with the given name to the given value. If the value is`null`, the property will effectively be removed.
    * @param propertyName the name of the property whose value is to be set
    * @param propertyValue the new value of the property
    */
   void setProperty(String propertyName, Object propertyValue) {
     if (propertyValue == null) {
       if (_propertyMap != null) {
         _propertyMap.remove(propertyName);
@@ skipping 1506 matching lines @@
    * Return the token representing the literal.
    * @return the token representing the literal
    */
   Token get literal => _literal;
 
   /**
    * Return the value of the literal.
    * @return the value of the literal
    */
   bool get value => _value;
-  bool isSynthetic() => _literal.isSynthetic();
+  bool get isSynthetic => _literal.isSynthetic;
 
   /**
    * Set the token representing the literal to the given token.
    * @param literal the token representing the literal
    */
   void set literal(Token literal2) {
     this._literal = literal2;
   }
 
   /**
@@ skipping 1035 matching lines @@
   /**
    * Return the tokens representing the comment.
    * @return the tokens representing the comment
    */
   List<Token> get tokens => _tokens;
 
   /**
    * Return `true` if this is a block comment.
    * @return `true` if this is a block comment
    */
-  bool isBlock() => identical(_type, CommentType.BLOCK);
+  bool get isBlock => identical(_type, CommentType.BLOCK);
 
   /**
    * Return `true` if this is a documentation comment.
    * @return `true` if this is a documentation comment
    */
-  bool isDocumentation() => identical(_type, CommentType.DOCUMENTATION);
+  bool get isDocumentation => identical(_type, CommentType.DOCUMENTATION);
 
   /**
    * Return `true` if this is an end-of-line comment.
    * @return `true` if this is an end-of-line comment
    */
-  bool isEndOfLine() => identical(_type, CommentType.END_OF_LINE);
+  bool get isEndOfLine => identical(_type, CommentType.END_OF_LINE);
   void visitChildren(ASTVisitor<Object> visitor) {
     _references.accept(visitor);
   }
 }
 /**
  * The enumeration `CommentType` encodes all the different types of comments that are
  * recognized by the parser.
  */
 class CommentType implements Comparable<CommentType> {
 
@@ skipping 1354 matching lines @@
    * Return the name of the declared type of the parameter, or `null` if the parameter does
    * not have a declared type.
    * @return the name of the declared type of the parameter
    */
   TypeName get type => _type;
 
   /**
    * Return `true` if this variable was declared with the 'const' modifier.
    * @return `true` if this variable was declared with the 'const' modifier
    */
-  bool isConst() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
+  bool get isConst => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
 
   /**
    * Return `true` if this variable was declared with the 'final' modifier. Variables that are
    * declared with the 'const' modifier will return `false` even though they are implicitly
    * final.
    * @return `true` if this variable was declared with the 'final' modifier
    */
-  bool isFinal() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
+  bool get isFinal => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
 
   /**
    * Set the token representing either the 'final', 'const' or 'var' keyword to the given token.
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
    */
   void set keyword(Token keyword2) {
     this._keyword = keyword2;
   }
 
   /**
@@ skipping 101 matching lines @@
    * Return the token separating the parameter from the default value, or `null` if there is
    * no default value.
    * @return the token separating the parameter from the default value
    */
   Token get separator => _separator;
 
   /**
    * Return `true` if this parameter was declared with the 'const' modifier.
    * @return `true` if this parameter was declared with the 'const' modifier
    */
-  bool isConst() => _parameter != null && _parameter.isConst();
+  bool get isConst => _parameter != null && _parameter.isConst;
 
   /**
    * Return `true` if this parameter was declared with the 'final' modifier. Parameters that
    * are declared with the 'const' modifier will return `false` even though they are
    * implicitly final.
    * @return `true` if this parameter was declared with the 'final' modifier
    */
-  bool isFinal() => _parameter != null && _parameter.isFinal();
+  bool get isFinal => _parameter != null && _parameter.isFinal;
 
   /**
    * Set the expression computing the default value for the parameter to the given expression.
    * @param expression the expression computing the default value for the parameter
    */
   void set defaultValue(Expression expression) {
     _defaultValue = becomeParentOf(expression);
   }
 
   /**
@@ skipping 578 matching lines @@
    * Return the static type of this expression, or `null` if the AST structure has not been
    * resolved.
    * @return the static type of this expression
    */
   Type2 get staticType => _staticType;
 
   /**
    * Return `true` if this expression is syntactically valid for the LHS of an[AssignmentExpression assignment expression].
    * @return `true` if this expression matches the `assignableExpression` production
    */
-  bool isAssignable() => false;
+  bool get isAssignable => false;
 
   /**
    * Set the propagated type of this expression to the given type.
    * @param propagatedType the propagated type of this expression
    */
   void set propagatedType(Type2 propagatedType2) {
     this._propagatedType = propagatedType2;
   }
 
   /**
@@ skipping 155 matching lines @@
    * Return the expression that comprises the statement.
    * @return the expression that comprises the statement
    */
   Expression get expression => _expression;
 
   /**
    * Return the semicolon terminating the statement.
    * @return the semicolon terminating the statement
    */
   Token get semicolon => _semicolon;
-  bool isSynthetic() => _expression.isSynthetic() && _semicolon.isSynthetic();
+  bool get isSynthetic => _expression.isSynthetic && _semicolon.isSynthetic;
 
   /**
    * Set the expression that comprises the statement to the given expression.
    * @param expression the expression that comprises the statement
    */
   void set expression(Expression expression2) {
     this._expression = becomeParentOf(expression2);
   }
 
   /**
@@ skipping 147 matching lines @@
   /**
    * Return the semicolon terminating the declaration.
    * @return the semicolon terminating the declaration
    */
   Token get semicolon => _semicolon;
 
   /**
    * Return `true` if the fields are static.
    * @return `true` if the fields are declared to be static
    */
-  bool isStatic() => _keyword != null;
+  bool get isStatic => _keyword != null;
 
   /**
    * Set the fields being declared to the given list of variables.
    * @param fieldList the fields being declared
    */
   void set fields(VariableDeclarationList fieldList) {
     fieldList = becomeParentOf(fieldList);
   }
 
   /**
@@ skipping 109 matching lines @@
    * @return the token representing the 'this' keyword
    */
   Token get thisToken => _thisToken;
 
   /**
    * Return the name of the declared type of the parameter, or `null` if the parameter does
    * not have a declared type.
    * @return the name of the declared type of the parameter
    */
   TypeName get type => _type;
-  bool isConst() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
-  bool isFinal() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
+  bool get isConst => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
+  bool get isFinal => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
 
   /**
    * Set the token representing either the 'final', 'const' or 'var' keyword to the given token.
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
    */
   void set keyword(Token keyword2) {
     this._keyword = keyword2;
   }
 
   /**
@@ skipping 764 matching lines @@
   /**
    * Return the return type of the function, or `null` if no return type was declared.
    * @return the return type of the function
    */
   TypeName get returnType => _returnType;
 
   /**
    * Return `true` if this function declares a getter.
    * @return `true` if this function declares a getter
    */
-  bool isGetter() => _propertyKeyword != null && identical(((_propertyKeyword as KeywordToken)).keyword, Keyword.GET);
+  bool get isGetter => _propertyKeyword != null && identical(((_propertyKeyword as KeywordToken)).keyword, Keyword.GET);
 
   /**
    * Return `true` if this function declares a setter.
    * @return `true` if this function declares a setter
    */
-  bool isSetter() => _propertyKeyword != null && identical(((_propertyKeyword as KeywordToken)).keyword, Keyword.SET);
+  bool get isSetter => _propertyKeyword != null && identical(((_propertyKeyword as KeywordToken)).keyword, Keyword.SET);
 
   /**
    * Set the token representing the 'external' keyword to the given token.
    * @param externalKeyword the token representing the 'external' keyword
    */
   void set externalKeyword(Token externalKeyword2) {
     this._externalKeyword = externalKeyword2;
   }
 
   /**
@@ skipping 503 matching lines @@
    * @return the parameters of the function-typed parameter
    */
   FormalParameterList get parameters => _parameters;
 
   /**
    * Return the return type of the function, or `null` if the function does not have a return
    * type.
    * @return the return type of the function
    */
   TypeName get returnType => _returnType;
-  bool isConst() => false;
-  bool isFinal() => false;
+  bool get isConst => false;
+  bool get isFinal => false;
 
   /**
    * Set the parameters of the function-typed parameter to the given parameters.
    * @param parameters the parameters of the function-typed parameter
    */
   void set parameters(FormalParameterList parameters2) {
     this._parameters = becomeParentOf(parameters2);
   }
 
   /**
@@ skipping 85 matching lines @@
    */
   String get name;
 
   /**
    * Return the element associated with this identifier based on static type information, or`null` if the AST structure has not been resolved or if this identifier could not be
    * resolved. One example of the latter case is an identifier that is not defined within the scope
    * in which it appears
    * @return the element associated with the operator
    */
   Element get staticElement;
-  bool isAssignable() => true;
+  bool get isAssignable => true;
 }
 /**
  * Instances of the class `IfStatement` represent an if statement.
  * <pre>
  * ifStatement ::=
  * 'if' '(' [Expression expression] ')' [Statement thenStatement] ('else' [Statement elseStatement])?
  * </pre>
  * @coverage dart.engine.ast
  */
 class IfStatement extends Statement {
@@ skipping 482 matching lines @@
 
   /**
    * Return the expression used to compute the object being indexed. If this index expression is not
    * part of a cascade expression, then this is the same as [getArray]. If this index
    * expression is part of a cascade expression, then the target expression stored with the cascade
    * expression is returned.
    * @return the expression used to compute the object being indexed
    * @see #getArray()
    */
   Expression get realTarget {
-    if (isCascaded()) {
+    if (isCascaded) {
       ASTNode ancestor = parent;
       while (ancestor is! CascadeExpression) {
         if (ancestor == null) {
           return _target;
         }
         ancestor = ancestor.parent;
       }
       return ((ancestor as CascadeExpression)).target;
     }
     return _target;
@@ skipping 35 matching lines @@
    * Return `true` if this expression is computing a left-hand value.
    *
    * Note that [inGetterContext] and [inSetterContext] are not opposites, nor are
    * they mutually exclusive. In other words, it is possible for both methods to return `true`when invoked on the same node.
    * @return `true` if this expression is in a context where the operator '\[\]=' will be
    * invoked
    */
   bool inSetterContext() {
     ASTNode parent = this.parent;
     if (parent is PrefixExpression) {
-      return ((parent as PrefixExpression)).operator.type.isIncrementOperator();
+      return ((parent as PrefixExpression)).operator.type.isIncrementOperator;
     } else if (parent is PostfixExpression) {
       return true;
     } else if (parent is AssignmentExpression) {
       return identical(((parent as AssignmentExpression)).leftHandSide, this);
     }
     return false;
   }
-  bool isAssignable() => true;
+  bool get isAssignable => true;
 
   /**
    * Return `true` if this expression is cascaded. If it is, then the target of this
    * expression is not stored locally but is stored in the nearest ancestor that is a[CascadeExpression].
    * @return `true` if this expression is cascaded
    */
-  bool isCascaded() => _period != null;
+  bool get isCascaded => _period != null;
 
   /**
    * Set the expression used to compute the object being indexed to the given expression.
    * @param expression the expression used to compute the object being indexed
    */
   void set array(Expression expression) {
     _target = becomeParentOf(expression);
   }
 
   /**
@@ skipping 178 matching lines @@
    * Return the element associated with the constructor based on static type information, or`null` if the AST structure has not been resolved or if the constructor could not be
    * resolved.
    * @return the element associated with the constructor
    */
   ConstructorElement get staticElement => _staticElement;
 
   /**
    * Return `true` if this creation expression is used to invoke a constant constructor.
    * @return `true` if this creation expression is used to invoke a constant constructor
    */
-  bool isConst() => _keyword is KeywordToken && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
+  bool get isConst => _keyword is KeywordToken && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
 
   /**
    * Set the list of arguments to the constructor to the given list.
    * @param argumentList the list of arguments to the constructor
    */
   void set argumentList(ArgumentList argumentList2) {
     this._argumentList = becomeParentOf(argumentList2);
   }
 
   /**
@@ skipping 1163 matching lines @@
   /**
    * Return the return type of the method, or `null` if no return type was declared.
    * @return the return type of the method
    */
   TypeName get returnType => _returnType;
 
   /**
    * Return `true` if this method is declared to be an abstract method.
    * @return `true` if this method is declared to be an abstract method
    */
-  bool isAbstract() => _externalKeyword == null && (_body is EmptyFunctionBody);
+  bool get isAbstract => _externalKeyword == null && (_body is EmptyFunctionBody);
 
   /**
    * Return `true` if this method declares a getter.
    * @return `true` if this method declares a getter
    */
-  bool isGetter() => _propertyKeyword != null && identical(((_propertyKeyword as KeywordToken)).keyword, Keyword.GET);
+  bool get isGetter => _propertyKeyword != null && identical(((_propertyKeyword as KeywordToken)).keyword, Keyword.GET);
 
   /**
    * Return `true` if this method declares an operator.
    * @return `true` if this method declares an operator
    */
-  bool isOperator() => _operatorKeyword != null;
+  bool get isOperator => _operatorKeyword != null;
 
   /**
    * Return `true` if this method declares a setter.
    * @return `true` if this method declares a setter
    */
-  bool isSetter() => _propertyKeyword != null && identical(((_propertyKeyword as KeywordToken)).keyword, Keyword.SET);
+  bool get isSetter => _propertyKeyword != null && identical(((_propertyKeyword as KeywordToken)).keyword, Keyword.SET);
 
   /**
    * Return `true` if this method is declared to be a static method.
    * @return `true` if this method is declared to be a static method
    */
-  bool isStatic() => _modifierKeyword != null && identical(((_modifierKeyword as KeywordToken)).keyword, Keyword.STATIC);
+  bool get isStatic => _modifierKeyword != null && identical(((_modifierKeyword as KeywordToken)).keyword, Keyword.STATIC);
 
   /**
    * Set the body of the method to the given function body.
    * @param functionBody the body of the method
    */
   void set body(FunctionBody functionBody) {
     _body = becomeParentOf(functionBody);
   }
 
   /**
@@ skipping 158 matching lines @@
 
   /**
    * Return the expression used to compute the receiver of the invocation. If this invocation is not
    * part of a cascade expression, then this is the same as [getTarget]. If this invocation
    * is part of a cascade expression, then the target stored with the cascade expression is
    * returned.
    * @return the expression used to compute the receiver of the invocation
    * @see #getTarget()
    */
   Expression get realTarget {
-    if (isCascaded()) {
+    if (isCascaded) {
       ASTNode ancestor = parent;
       while (ancestor is! CascadeExpression) {
         if (ancestor == null) {
           return _target;
         }
         ancestor = ancestor.parent;
       }
       return ((ancestor as CascadeExpression)).target;
     }
     return _target;
   }
 
   /**
    * Return the expression producing the object on which the method is defined, or `null` if
    * there is no target (that is, the target is implicitly `this`) or if this method
    * invocation is part of a cascade expression.
    * @return the expression producing the object on which the method is defined
    * @see #getRealTarget()
    */
   Expression get target => _target;
 
   /**
    * Return `true` if this expression is cascaded. If it is, then the target of this
    * expression is not stored locally but is stored in the nearest ancestor that is a[CascadeExpression].
    * @return `true` if this expression is cascaded
    */
-  bool isCascaded() => _period != null && identical(_period.type, TokenType.PERIOD_PERIOD);
+  bool get isCascaded => _period != null && identical(_period.type, TokenType.PERIOD_PERIOD);
 
   /**
    * Set the list of arguments to the method to the given list.
    * @param argumentList the list of arguments to the method
    */
   void set argumentList(ArgumentList argumentList2) {
     this._argumentList = becomeParentOf(argumentList2);
   }
 
   /**
@@ skipping 328 matching lines @@
   /**
    * Return the annotations associated with this parameter.
    * @return the annotations associated with this parameter
    */
   NodeList<Annotation> get metadata => _metadata;
 
   /**
    * Return `true` if this parameter was declared with the 'const' modifier.
    * @return `true` if this parameter was declared with the 'const' modifier
    */
-  bool isConst();
+  bool get isConst;
 
   /**
    * Return `true` if this parameter was declared with the 'final' modifier. Parameters that
    * are declared with the 'const' modifier will return `false` even though they are
    * implicitly final.
    * @return `true` if this parameter was declared with the 'final' modifier
    */
-  bool isFinal();
+  bool get isFinal;
 
   /**
    * Set the documentation comment associated with this parameter to the given comment
    * @param comment the documentation comment to be associated with this parameter
    */
   void set documentationComment(Comment comment2) {
     this._comment = becomeParentOf(comment2);
   }
 
   /**
@@ skipping 863 matching lines @@
 
   /**
    * Return the expression used to compute the receiver of the invocation. If this invocation is not
    * part of a cascade expression, then this is the same as [getTarget]. If this invocation
    * is part of a cascade expression, then the target stored with the cascade expression is
    * returned.
    * @return the expression used to compute the receiver of the invocation
    * @see #getTarget()
    */
   Expression get realTarget {
-    if (isCascaded()) {
+    if (isCascaded) {
       ASTNode ancestor = parent;
       while (ancestor is! CascadeExpression) {
         if (ancestor == null) {
           return _target;
         }
         ancestor = ancestor.parent;
       }
       return ((ancestor as CascadeExpression)).target;
     }
     return _target;
   }
 
   /**
    * Return the expression computing the object defining the property being accessed, or`null` if this property access is part of a cascade expression.
    * @return the expression computing the object defining the property being accessed
    * @see #getRealTarget()
    */
   Expression get target => _target;
-  bool isAssignable() => true;
+  bool get isAssignable => true;
 
   /**
    * Return `true` if this expression is cascaded. If it is, then the target of this
    * expression is not stored locally but is stored in the nearest ancestor that is a[CascadeExpression].
    * @return `true` if this expression is cascaded
    */
-  bool isCascaded() => _operator != null && identical(_operator.type, TokenType.PERIOD_PERIOD);
+  bool get isCascaded => _operator != null && identical(_operator.type, TokenType.PERIOD_PERIOD);
 
   /**
    * Set the property access operator to the given token.
    * @param operator the property access operator
    */
   void set operator(Token operator2) {
     this._operator = operator2;
   }
 
   /**
@@ skipping 477 matching lines @@
    * @return the token representing either the 'final', 'const' or 'var' keyword
    */
   Token get keyword => _keyword;
 
   /**
    * Return the name of the declared type of the parameter, or `null` if the parameter does
    * not have a declared type.
    * @return the name of the declared type of the parameter
    */
   TypeName get type => _type;
-  bool isConst() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
-  bool isFinal() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
+  bool get isConst => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
+  bool get isFinal => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
 
   /**
    * Set the token representing either the 'final', 'const' or 'var' keyword to the given token.
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
    */
   void set keyword(Token keyword2) {
     this._keyword = keyword2;
   }
 
   /**
@@ skipping 152 matching lines @@
       target = prefixed;
     } else if (parent is PropertyAccess) {
       PropertyAccess access = parent as PropertyAccess;
       if (identical(access.target, this)) {
         return false;
       }
       parent = access.parent;
       target = access;
     }
     if (parent is PrefixExpression) {
-      return ((parent as PrefixExpression)).operator.type.isIncrementOperator();
+      return ((parent as PrefixExpression)).operator.type.isIncrementOperator;
     } else if (parent is PostfixExpression) {
       return true;
     } else if (parent is AssignmentExpression) {
       return identical(((parent as AssignmentExpression)).leftHandSide, target);
     }
     return false;
   }
-  bool isSynthetic() => _token.isSynthetic();
+  bool get isSynthetic => _token.isSynthetic;
 
   /**
    * Set the element associated with this identifier based on propagated type information to the
    * given element.
    * @param element the element to be associated with this identifier
    */
   void set element(Element element2) {
     _propagatedElement = element2;
   }
 
@@ skipping 78 matching lines @@
   /**
    * Return the value of the literal.
    * @return the value of the literal
    */
   String get value => _value;
 
   /**
    * Return `true` if this string literal is a multi-line string.
    * @return `true` if this string literal is a multi-line string
    */
-  bool isMultiline() {
+  bool get isMultiline {
     if (_value.length < 6) {
       return false;
     }
     return _value.endsWith("\"\"\"") || _value.endsWith("'''");
   }
 
   /**
    * Return `true` if this string literal is a raw string.
    * @return `true` if this string literal is a raw string
    */
-  bool isRaw() => _value.codeUnitAt(0) == 0x40;
-  bool isSynthetic() => _literal.isSynthetic();
+  bool get isRaw => _value.codeUnitAt(0) == 0x40;
+  bool get isSynthetic => _literal.isSynthetic;
 
   /**
    * Set the token representing the literal to the given token.
    * @param literal the token representing the literal
    */
   void set literal(Token literal2) {
     this._literal = literal2;
   }
 
   /**
@@ skipping 1250 matching lines @@
    * @return the type being named
    */
   Type2 get type => _type;
 
   /**
    * Return the type arguments associated with the type, or `null` if there are no type
    * arguments.
    * @return the type arguments associated with the type
    */
   TypeArgumentList get typeArguments => _typeArguments;
-  bool isSynthetic() => _name.isSynthetic() && _typeArguments == null;
+  bool get isSynthetic => _name.isSynthetic && _typeArguments == null;
 
   /**
    * Set the name of the type to the given identifier.
    * @param identifier the name of the type
    */
   void set name(Identifier identifier) {
     _name = becomeParentOf(identifier);
   }
 
   /**
@@ skipping 416 matching lines @@
   /**
    * Return the name of the variable being declared.
    * @return the name of the variable being declared
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Return `true` if this variable was declared with the 'const' modifier.
    * @return `true` if this variable was declared with the 'const' modifier
    */
-  bool isConst() {
+  bool get isConst {
     ASTNode parent = this.parent;
-    return parent is VariableDeclarationList && ((parent as VariableDeclarationList)).isConst();
+    return parent is VariableDeclarationList && ((parent as VariableDeclarationList)).isConst;
   }
 
   /**
    * Return `true` if this variable was declared with the 'final' modifier. Variables that are
    * declared with the 'const' modifier will return `false` even though they are implicitly
    * final.
    * @return `true` if this variable was declared with the 'final' modifier
    */
-  bool isFinal() {
+  bool get isFinal {
     ASTNode parent = this.parent;
-    return parent is VariableDeclarationList && ((parent as VariableDeclarationList)).isFinal();
+    return parent is VariableDeclarationList && ((parent as VariableDeclarationList)).isFinal;
   }
 
   /**
    * Set the equal sign separating the variable name from the initial value to the given token.
    * @param equals the equal sign separating the variable name from the initial value
    */
   void set equals(Token equals2) {
     this._equals = equals2;
   }
 
@@ skipping 93 matching lines @@
   /**
    * Return a list containing the individual variables being declared.
    * @return a list containing the individual variables being declared
    */
   NodeList<VariableDeclaration> get variables => _variables;
 
   /**
    * Return `true` if the variables in this list were declared with the 'const' modifier.
    * @return `true` if the variables in this list were declared with the 'const' modifier
    */
-  bool isConst() => _keyword is KeywordToken && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
+  bool get isConst => _keyword is KeywordToken && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
 
   /**
    * Return `true` if the variables in this list were declared with the 'final' modifier.
    * Variables that are declared with the 'const' modifier will return `false` even though
    * they are implicitly final.
    * @return `true` if the variables in this list were declared with the 'final' modifier
    */
-  bool isFinal() => _keyword is KeywordToken && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
+  bool get isFinal => _keyword is KeywordToken && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
 
   /**
    * Set the token representing the 'final', 'const' or 'var' keyword to the given token.
    * @param keyword the token representing the 'final', 'const' or 'var' keyword
    */
   void set keyword(Token keyword2) {
     this._keyword = keyword2;
   }
 
   /**
@@ skipping 591 matching lines @@
   }
 
   /**
    * Return the constant value of the static constant represented by the given element.
    * @param element the element whose value is to be returned
    * @return the constant value of the static constant
    */
   Object getConstantValue(Element element) {
     if (element is FieldElement) {
       FieldElement field = element as FieldElement;
-      if (field.isStatic() && field.isConst()) {
+      if (field.isStatic && field.isConst) {
       }
     }
     return NOT_A_CONSTANT;
   }
 }
 /**
  * Instances of the class `ElementLocator` locate the [Element Dart model element]associated with a given [ASTNode AST node].
  * @coverage dart.engine.ast
  */
 class ElementLocator {
@@ skipping 1210 matching lines @@
   }
   Object visitImportDirective(ImportDirective node) {
     _writer.print("import ");
     visit(node.uri);
     visit3(" as ", node.prefix);
     visitList4(" ", node.combinators, " ");
     _writer.print(';');
     return null;
   }
   Object visitIndexExpression(IndexExpression node) {
-    if (node.isCascaded()) {
+    if (node.isCascaded) {
       _writer.print("..");
     } else {
       visit(node.array);
     }
     _writer.print('[');
     visit(node.index);
     _writer.print(']');
     return null;
   }
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
@@ skipping 79 matching lines @@
     visit(node.value);
     return null;
   }
   Object visitMethodDeclaration(MethodDeclaration node) {
     visit5(node.externalKeyword, " ");
     visit5(node.modifierKeyword, " ");
     visit2(node.returnType, " ");
     visit5(node.propertyKeyword, " ");
     visit5(node.operatorKeyword, " ");
     visit(node.name);
-    if (!node.isGetter()) {
+    if (!node.isGetter) {
       visit(node.parameters);
     }
     visit4(" ", node.body);
     return null;
   }
   Object visitMethodInvocation(MethodInvocation node) {
-    if (node.isCascaded()) {
+    if (node.isCascaded) {
       _writer.print("..");
     } else {
       visit2(node.target, ".");
     }
     visit(node.methodName);
     visit(node.argumentList);
     return null;
   }
   Object visitNamedExpression(NamedExpression node) {
     visit(node.name);
@@ skipping 38 matching lines @@
     _writer.print('.');
     visit(node.identifier);
     return null;
   }
   Object visitPrefixExpression(PrefixExpression node) {
     _writer.print(node.operator.lexeme);
     visit(node.operand);
     return null;
   }
   Object visitPropertyAccess(PropertyAccess node) {
-    if (node.isCascaded()) {
+    if (node.isCascaded) {
       _writer.print("..");
     } else {
       visit(node.target);
       _writer.print('.');
     }
     visit(node.propertyName);
     return null;
   }
   Object visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     _writer.print("this");
@@ skipping 288 matching lines @@
   BinaryExpression visitBinaryExpression(BinaryExpression node) => new BinaryExpression.full(clone2(node.leftOperand), node.operator, clone2(node.rightOperand));
   Block visitBlock(Block node) => new Block.full(node.leftBracket, clone3(node.statements), node.rightBracket);
   BlockFunctionBody visitBlockFunctionBody(BlockFunctionBody node) => new BlockFunctionBody.full(clone2(node.block));
   BooleanLiteral visitBooleanLiteral(BooleanLiteral node) => new BooleanLiteral.full(node.literal, node.value);
   BreakStatement visitBreakStatement(BreakStatement node) => new BreakStatement.full(node.keyword, clone2(node.label), node.semicolon);
   CascadeExpression visitCascadeExpression(CascadeExpression node) => new CascadeExpression.full(clone2(node.target), clone3(node.cascadeSections));
   CatchClause visitCatchClause(CatchClause node) => new CatchClause.full(node.onKeyword, clone2(node.exceptionType), node.catchKeyword, node.leftParenthesis, clone2(node.exceptionParameter), node.comma, clone2(node.stackTraceParameter), node.rightParenthesis, clone2(node.body));
   ClassDeclaration visitClassDeclaration(ClassDeclaration node) => new ClassDeclaration.full(clone2(node.documentationComment), clone3(node.metadata), node.abstractKeyword, node.classKeyword, clone2(node.name), clone2(node.typeParameters), clone2(node.extendsClause), clone2(node.withClause), clone2(node.implementsClause), node.leftBracket, clone3(node.members), node.rightBracket);
   ClassTypeAlias visitClassTypeAlias(ClassTypeAlias node) => new ClassTypeAlias.full(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.name), clone2(node.typeParameters), node.equals, node.abstractKeyword, clone2(node.superclass), clone2(node.withClause), clone2(node.implementsClause), node.semicolon);
   Comment visitComment(Comment node) {
-    if (node.isDocumentation()) {
+    if (node.isDocumentation) {
       return Comment.createDocumentationComment2(node.tokens, clone3(node.references));
-    } else if (node.isBlock()) {
+    } else if (node.isBlock) {
       return Comment.createBlockComment(node.tokens);
     }
     return Comment.createEndOfLineComment(node.tokens);
   }
   CommentReference visitCommentReference(CommentReference node) => new CommentReference.full(node.newKeyword, clone2(node.identifier));
   CompilationUnit visitCompilationUnit(CompilationUnit node) {
     CompilationUnit clone = new CompilationUnit.full(node.beginToken, clone2(node.scriptTag), clone3(node.directives), clone3(node.declarations), node.endToken);
     clone.lineInfo = node.lineInfo;
     clone.parsingErrors = node.parsingErrors;
     clone.resolutionErrors = node.resolutionErrors;
@@ skipping 301 matching lines @@
     return elements[elements.length - 1].endToken;
   }
   /**
    * Return the node that is the parent of each of the elements in the list.
    * @return the node that is the parent of each of the elements in the list
    */
   ASTNode getOwner() {
     return owner;
   }
 }