Convert isX() methods to isX getter.

pkg/analyzer_experimental/lib/src/generated/element.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.element;
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'source.dart';
 import 'scanner.dart' show Keyword;
 import 'ast.dart' show Identifier, LibraryIdentifier;
 import 'sdk.dart' show DartSdk;
@@ skipping 144 matching lines @@
    * mixin).
    * @return `true` if this class has reference to super
    */
   bool hasReferenceToSuper();
 
   /**
    * Return `true` if this class is abstract. A class is abstract if it has an explicit`abstract` modifier. Note, that this definition of <i>abstract</i> is different from
    * <i>has unimplemented members</i>.
    * @return `true` if this class is abstract
    */
-  bool isAbstract();
+  bool get isAbstract;
 
   /**
    * Return `true` if this class is defined by a typedef construct.
    * @return `true` if this class is defined by a typedef construct
    */
-  bool isTypedef();
+  bool get isTypedef;
 
   /**
    * Return `true` if this class can validly be used as a mixin when defining another class.
    * The behavior of this method is defined by the Dart Language Specification in section 9:
    * <blockquote>It is a compile-time error if a declared or derived mixin refers to super. It is a
    * compile-time error if a declared or derived mixin explicitly declares a constructor. It is a
    * compile-time error if a mixin is derived from a class whose superclass is not
    * Object.</blockquote>
    * @return `true` if this class can validly be used as a mixin
    */
-  bool isValidMixin();
+  bool get isValidMixin;
 
   /**
    * Return the element representing the getter that results from looking up the given getter in
    * this class with respect to the given library, or `null` if the look up fails. The
    * behavior of this method is defined by the Dart Language Specification in section 12.15.1:
    * <blockquote>The result of looking up getter (respectively setter) <i>m</i> in class <i>C</i>
    * with respect to library <i>L</i> is:
    *
    * * If <i>C</i> declares an instance getter (respectively setter) named <i>m</i> that is
    * accessible to <i>L</i>, then that getter (respectively setter) is the result of the lookup.
@@ skipping 124 matching lines @@
   /**
    * Return the constructor to which this constructor is redirecting.
    * @return the constructor to which this constructor is redirecting
    */
   ConstructorElement get redirectedConstructor;
 
   /**
    * Return `true` if this constructor is a const constructor.
    * @return `true` if this constructor is a const constructor
    */
-  bool isConst();
+  bool get isConst;
 
   /**
    * Return `true` if this constructor can be used as a default constructor - unnamed and has
    * no required parameters.
    * @return `true` if this constructor can be used as a default constructor.
    */
-  bool isDefaultConstructor();
+  bool get isDefaultConstructor;
 
   /**
    * Return `true` if this constructor represents a factory constructor.
    * @return `true` if this constructor represents a factory constructor
    */
-  bool isFactory();
+  bool get isFactory;
 }
 /**
  * The interface `Element` defines the behavior common to all of the elements in the element
  * model. Generally speaking, the element model is a semantic model of the program that represents
  * things that are declared with a name and hence can be referenced elsewhere in the code.
  *
  * There are two exceptions to the general case. First, there are elements in the element model that
  * are created for the convenience of various kinds of analysis but that do not have any
  * corresponding declaration within the source code. Such elements are marked as being
  * <i>synthetic</i>. Examples of synthetic elements include
@@ skipping 121 matching lines @@
    * @return `true` if this element is accessible to code in the given library
    */
   bool isAccessibleIn(LibraryElement library);
 
   /**
    * Return `true` if this element is synthetic. A synthetic element is an element that is not
    * represented in the source code explicitly, but is implied by the source code, such as the
    * default constructor for a class that does not explicitly define any constructors.
    * @return `true` if this element is synthetic
    */
-  bool isSynthetic();
+  bool get isSynthetic;
 
   /**
    * Use the given visitor to visit all of the children of this element. There is no guarantee of
    * the order in which the children will be visited.
    * @param visitor the visitor that will be used to visit the children of this element
    */
   void visitChildren(ElementVisitor<Object> visitor);
 }
 /**
  * The interface `ElementAnnotation` defines the behavior of objects representing a single
@@ skipping 180 matching lines @@
    * @return the type of function defined by this executable element
    */
   FunctionType get type;
 
   /**
    * Return `true` if this executable element is an operator. The test may be based on the
    * name of the executable element, in which case the result will be correct when the name is
    * legal.
    * @return `true` if this executable element is an operator
    */
-  bool isOperator();
+  bool get isOperator;
 
   /**
    * Return `true` if this element is a static element. A static element is an element that is
    * not associated with a particular instance, but rather with an entire library or class.
    * @return `true` if this executable element is a static element
    */
-  bool isStatic();
+  bool get isStatic;
 }
 /**
  * The interface `ExportElement` defines the behavior of objects representing information
  * about a single export directive within a library.
  * @coverage dart.engine.element
  */
 abstract class ExportElement implements Element, UriReferencedElement {
 
   /**
    * An empty array of export elements.
@@ skipping 237 matching lines @@
    * library does not define a class with the given name.
    * @param className the name of the class to be returned
    * @return the class with the given name that is defined in this library
    */
   ClassElement getType(String className);
 
   /**
    * Answer `true` if this library is an application that can be run in the browser.
    * @return `true` if this library is an application that can be run in the browser
    */
-  bool isBrowserApplication();
+  bool get isBrowserApplication;
 
   /**
    * Return `true` if this library is the dart:core library.
    * @return `true` if this library is the dart:core library
    */
-  bool isDartCore();
+  bool get isDartCore;
 
   /**
    * Return `true` if this library is up to date with respect to the given time stamp. If any
    * transitively referenced Source is newer than the time stamp, this method returns false.
    * @param timeStamp the time stamp to compare against
    * @return `true` if this library is up to date with respect to the given time stamp
    */
   bool isUpToDate2(int timeStamp);
 }
 /**
@@ skipping 33 matching lines @@
  * defined within a type.
  * @coverage dart.engine.element
  */
 abstract class MethodElement implements ClassMemberElement, ExecutableElement {
 
   /**
    * Return `true` if this method is abstract. Methods are abstract if they are not external
    * and have no body.
    * @return `true` if this method is abstract
    */
-  bool isAbstract();
+  bool get isAbstract;
 }
 /**
  * The interface `MultiplyDefinedElement` defines the behavior of pseudo-elements that
  * represent multiple elements defined within a single scope that have the same name. This situation
  * is not allowed by the language, so objects implementing this interface always represent an error.
  * As a result, most of the normal operations on elements do not make sense and will return useless
  * results.
  * @coverage dart.engine.element
  */
 abstract class MultiplyDefinedElement implements Element {
@@ skipping 41 matching lines @@
    * Return an array containing all of the parameters defined by this parameter. A parameter will
    * only define other parameters if it is a function typed parameter.
    * @return the parameters defined by this parameter element
    */
   List<ParameterElement> get parameters;
 
   /**
    * Return `true` if this parameter is an initializing formal parameter.
    * @return `true` if this parameter is an initializing formal parameter
    */
-  bool isInitializingFormal();
+  bool get isInitializingFormal;
 }
 /**
  * The interface `PrefixElement` defines the behavior common to elements that represent a
  * prefix used to import one or more libraries into another library.
  * @coverage dart.engine.element
  */
 abstract class PrefixElement implements Element {
 
   /**
    * Return the library into which other libraries are imported using this prefix.
@@ skipping 45 matching lines @@
    * explicitly defined (is not synthetic) then the variable associated with it will be synthetic.
    * @return the variable associated with this accessor
    */
   PropertyInducingElement get variable;
 
   /**
    * Return `true` if this accessor is abstract. Accessors are abstract if they are not
    * external and have no body.
    * @return `true` if this accessor is abstract
    */
-  bool isAbstract();
+  bool get isAbstract;
 
   /**
    * Return `true` if this accessor represents a getter.
    * @return `true` if this accessor represents a getter
    */
-  bool isGetter();
+  bool get isGetter;
 
   /**
    * Return `true` if this accessor represents a setter.
    * @return `true` if this accessor represents a setter
    */
-  bool isSetter();
+  bool get isSetter;
 }
 /**
  * The interface `PropertyInducingElement` defines the behavior of elements representing a
  * variable that has an associated getter and possibly a setter. Note that explicitly defined
  * variables implicitly define a synthetic getter and that non-`final` explicitly defined
  * variables implicitly define a synthetic setter. Symmetrically, synthetic fields are implicitly
  * created for explicitly defined getters and setters. The following rules apply:
  *
  * * Every explicit variable is represented by a non-synthetic [PropertyInducingElement].
  * * Every explicit variable induces a getter and possibly a setter, both of which are represented
@@ skipping 20 matching lines @@
    * explicitly defined (is not synthetic) then the setter associated with it will be synthetic.
    * @return the setter associated with this variable
    */
   PropertyAccessorElement get setter;
 
   /**
    * Return `true` if this element is a static element. A static element is an element that is
    * not associated with a particular instance, but rather with an entire library or class.
    * @return `true` if this executable element is a static element
    */
-  bool isStatic();
+  bool get isStatic;
 }
 /**
  * The interface `ShowElementCombinator` defines the behavior of combinators that cause some
  * of the names in a namespace to be visible (and the rest hidden) when being imported.
  * @coverage dart.engine.element
  */
 abstract class ShowElementCombinator implements NamespaceCombinator {
 
   /**
    * Return an array containing the names that are to be made visible in the importing library if
@@ skipping 70 matching lines @@
    * Return the declared type of this variable, or `null` if the variable did not have a
    * declared type (such as if it was declared using the keyword 'var').
    * @return the declared type of this variable
    */
   Type2 get 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();
+  bool get 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;
 }
 /**
  * Instances of the class `GeneralizingElementVisitor` implement an element visitor that will
  * recursively visit all of the elements in an element model (like instances of the class[RecursiveElementVisitor]). In addition, when an element of a specific type is visited not
  * only will the visit method for that specific type of element be invoked, but additional methods
  * for the supertypes of that element will also be invoked. For example, using an instance of this
  * class to visit a [MethodElement] will cause the method[visitMethodElement] to be invoked but will also cause the methods[visitExecutableElement] and [visitElement] to be
  * subsequently invoked. This allows visitors to be written that visit all executable elements
  * without needing to override the visit method for each of the specific subclasses of[ExecutableElement].
  *
@@ skipping 323 matching lines @@
     for (FieldElement fieldElement in _fields) {
       if (name2 == fieldElement.name) {
         return fieldElement;
       }
     }
     return null;
   }
   List<FieldElement> get fields => _fields;
   PropertyAccessorElement getGetter(String getterName) {
     for (PropertyAccessorElement accessor in _accessors) {
-      if (accessor.isGetter() && accessor.name == getterName) {
+      if (accessor.isGetter && accessor.name == getterName) {
         return accessor;
       }
     }
     return null;
   }
   List<InterfaceType> get interfaces => _interfaces;
   ElementKind get kind => ElementKind.CLASS;
   MethodElement getMethod(String methodName) {
     for (MethodElement method in _methods) {
       if (method.name == methodName) {
@@ skipping 11 matching lines @@
         return element;
       }
     }
     return null;
   }
   PropertyAccessorElement getSetter(String setterName) {
     if (!setterName.endsWith("=")) {
       setterName += '=';
     }
     for (PropertyAccessorElement accessor in _accessors) {
-      if (accessor.isSetter() && accessor.name == setterName) {
+      if (accessor.isSetter && accessor.name == setterName) {
         return accessor;
       }
     }
     return null;
   }
   InterfaceType get supertype => _supertype;
   InterfaceType get type => _type;
   List<TypeVariableElement> get typeVariables => _typeVariables;
   ConstructorElement get unnamedConstructor {
     for (ConstructorElement element in constructors) {
       String name = element.displayName;
       if (name == null || name.isEmpty) {
         return element;
       }
     }
     return null;
   }
   bool hasDefaultConstructor() {
     for (ConstructorElement constructor in constructors) {
-      if (constructor.isDefaultConstructor()) {
+      if (constructor.isDefaultConstructor) {
         return true;
       }
     }
     return false;
   }
   bool hasNonFinalField() {
     List<ClassElement> classesToVisit = new List<ClassElement>();
     Set<ClassElement> visitedClasses = new Set<ClassElement>();
     classesToVisit.add(this);
     while (!classesToVisit.isEmpty) {
       ClassElement currentElement = classesToVisit.removeAt(0);
       if (javaSetAdd(visitedClasses, currentElement)) {
         for (FieldElement field in currentElement.fields) {
-          if (!field.isFinal() && !field.isConst() && !field.isStatic() && !field.isSynthetic()) {
+          if (!field.isFinal && !field.isConst && !field.isStatic && !field.isSynthetic) {
             return true;
           }
         }
         for (InterfaceType mixinType in currentElement.mixins) {
           ClassElement mixinElement = mixinType.element;
           classesToVisit.add(mixinElement);
         }
         InterfaceType supertype = currentElement.supertype;
         if (supertype != null) {
           ClassElement superElement = supertype.element;
           if (superElement != null) {
             classesToVisit.add(superElement);
           }
         }
       }
     }
     return false;
   }
   bool hasReferenceToSuper() => hasModifier(Modifier.REFERENCES_SUPER);
-  bool isAbstract() => hasModifier(Modifier.ABSTRACT);
-  bool isTypedef() => hasModifier(Modifier.TYPEDEF);
-  bool isValidMixin() => hasModifier(Modifier.MIXIN);
+  bool get isAbstract => hasModifier(Modifier.ABSTRACT);
+  bool get isTypedef => hasModifier(Modifier.TYPEDEF);
+  bool get isValidMixin => hasModifier(Modifier.MIXIN);
   PropertyAccessorElement lookUpGetter(String getterName, LibraryElement library) {
     Set<ClassElement> visitedClasses = new Set<ClassElement>();
     ClassElement currentElement = this;
     while (currentElement != null && !visitedClasses.contains(currentElement)) {
       javaSetAdd(visitedClasses, currentElement);
       PropertyAccessorElement element = currentElement.getGetter(getterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
       for (InterfaceType mixin in currentElement.mixins) {
@@ skipping 516 matching lines @@
   /**
    * Initialize a newly created constructor element to have the given name.
    * @param name the name of this element
    */
   ConstructorElementImpl(Identifier name) : super.con1(name) {
   }
   accept(ElementVisitor visitor) => visitor.visitConstructorElement(this);
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
   ElementKind get kind => ElementKind.CONSTRUCTOR;
   ConstructorElement get redirectedConstructor => _redirectedConstructor;
-  bool isConst() => hasModifier(Modifier.CONST);
-  bool isDefaultConstructor() {
+  bool get isConst => hasModifier(Modifier.CONST);
+  bool get isDefaultConstructor {
     String name = this.name;
     if (name != null && name.length != 0) {
       return false;
     }
     for (ParameterElement parameter in parameters) {
       if (identical(parameter.parameterKind, ParameterKind.REQUIRED)) {
         return false;
       }
     }
     return true;
   }
-  bool isFactory() => hasModifier(Modifier.FACTORY);
-  bool isStatic() => false;
+  bool get isFactory => hasModifier(Modifier.FACTORY);
+  bool get isStatic => false;
 
   /**
    * Set whether this constructor represents a 'const' constructor to the given value.
    * @param isConst `true` if this constructor represents a 'const' constructor
    */
   void set const2(bool isConst) {
     setModifier(Modifier.CONST, isConst);
   }
 
   /**
@@ skipping 244 matching lines @@
       _cachedHashCode = location.hashCode;
     }
     return _cachedHashCode;
   }
   bool isAccessibleIn(LibraryElement library2) {
     if (Identifier.isPrivateName(_name)) {
       return library2 == library;
     }
     return true;
   }
-  bool isSynthetic() => hasModifier(Modifier.SYNTHETIC);
+  bool get isSynthetic => hasModifier(Modifier.SYNTHETIC);
 
   /**
    * Set the metadata associate with this element to the given array of annotations.
    * @param metadata the metadata to be associated with this element
    */
   void set metadata(List<ElementAnnotation> metadata2) {
     this._metadata = metadata2;
   }
 
   /**
@@ skipping 373 matching lines @@
       }
     }
     return null;
   }
   List<FunctionElement> get functions => _functions;
   List<LabelElement> get labels => _labels;
   List<LocalVariableElement> get localVariables => _localVariables;
   List<ParameterElement> get parameters => _parameters;
   Type2 get returnType => _returnType;
   FunctionType get type => _type;
-  bool isOperator() => false;
+  bool get isOperator => false;
 
   /**
    * Set the functions defined within this executable element to the given functions.
    * @param functions the functions defined within this executable element
    */
   void set functions(List<FunctionElement> functions2) {
     for (FunctionElement function in functions2) {
       ((function as FunctionElementImpl)).enclosingElement = this;
     }
     this._functions = functions2;
@@ skipping 189 matching lines @@
    * @param name the name of this element
    */
   FieldElementImpl.con2(String name) : super.con2(name) {
     _jtd_constructor_205_impl(name);
   }
   _jtd_constructor_205_impl(String name) {
   }
   accept(ElementVisitor visitor) => visitor.visitFieldElement(this);
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
   ElementKind get kind => ElementKind.FIELD;
-  bool isStatic() => hasModifier(Modifier.STATIC);
+  bool get isStatic => hasModifier(Modifier.STATIC);
 
   /**
    * Set whether this field is static to correspond to the given value.
    * @param isStatic `true` if the field is static
    */
   void set static(bool isStatic) {
     setModifier(Modifier.STATIC, isStatic);
   }
 }
 /**
  * Instances of the class `FieldFormalParameterElementImpl` extend[ParameterElementImpl] to provide the additional information of the [FieldElement]associated with the parameter.
  * @coverage dart.engine.element
  */
 class FieldFormalParameterElementImpl extends ParameterElementImpl implements FieldFormalParameterElement {
 
   /**
    * The field associated with this field formal parameter.
    */
   FieldElement _field;
 
   /**
    * Initialize a newly created parameter element to have the given name.
    * @param name the name of this element
    */
   FieldFormalParameterElementImpl(Identifier name) : super(name) {
   }
   accept(ElementVisitor visitor) => visitor.visitFieldFormalParameterElement(this);
   FieldElement get field => _field;
-  bool isInitializingFormal() => true;
+  bool get isInitializingFormal => true;
 
   /**
    * Set the field element associated with this field formal parameter to the given element.
    * @param field the new field element
    */
   void set field(FieldElement field2) {
     this._field = field2;
   }
 }
 /**
@@ skipping 51 matching lines @@
   }
   accept(ElementVisitor visitor) => visitor.visitFunctionElement(this);
   String get identifier => "${name}@${nameOffset}";
   ElementKind get kind => ElementKind.FUNCTION;
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
-  bool isStatic() => enclosingElement is CompilationUnitElement;
+  bool get isStatic => enclosingElement is CompilationUnitElement;
 
   /**
    * Set the visible range for this element to the range starting at the given offset with the given
    * length.
    * @param offset the offset to the beginning of the visible range for this element
    * @param length the length of the visible range for this element, or `-1` if this element
    * does not have a visible range
    */
   void setVisibleRange(int offset, int length) {
     _visibleRangeOffset = offset;
@@ skipping 380 matching lines @@
     this._onSwitchMember = onSwitchMember;
   }
   accept(ElementVisitor visitor) => visitor.visitLabelElement(this);
   ExecutableElement get enclosingElement => super.enclosingElement as ExecutableElement;
   ElementKind get kind => ElementKind.LABEL;
 
   /**
    * Return `true` if this label is associated with a `switch` member (`case` or`default`).
    * @return `true` if this label is associated with a `switch` member
    */
-  bool isOnSwitchMember() => _onSwitchMember;
+  bool get isOnSwitchMember => _onSwitchMember;
 
   /**
    * Return `true` if this label is associated with a `switch` statement.
    * @return `true` if this label is associated with a `switch` statement
    */
-  bool isOnSwitchStatement() => _onSwitchStatement;
+  bool get isOnSwitchStatement => _onSwitchStatement;
 }
 /**
  * Instances of the class `LibraryElementImpl` implement a `LibraryElement`.
  * @coverage dart.engine.element
  */
 class LibraryElementImpl extends ElementImpl implements LibraryElement {
 
   /**
    * An empty array of library elements.
    */
@@ skipping 143 matching lines @@
     }
     for (CompilationUnitElement part in _parts) {
       type = part.getType(className);
       if (type != null) {
         return type;
       }
     }
     return null;
   }
   int get hashCode => _definingCompilationUnit.hashCode;
-  bool isBrowserApplication() => _entryPoint != null && isOrImportsBrowserLibrary();
-  bool isDartCore() => name == "dart.core";
+  bool get isBrowserApplication => _entryPoint != null && isOrImportsBrowserLibrary;
+  bool get isDartCore => name == "dart.core";
   bool isUpToDate2(int timeStamp) {
     Set<LibraryElement> visitedLibraries = new Set();
     return isUpToDate(this, timeStamp, visitedLibraries);
   }
 
   /**
    * Set the compilation unit that defines this library to the given compilation unit.
    * @param definingCompilationUnit the compilation unit that defines this library
    */
   void set definingCompilationUnit(CompilationUnitElement definingCompilationUnit2) {
@@ skipping 50 matching lines @@
     safelyVisitChild(_definingCompilationUnit, visitor);
     safelyVisitChildren(_exports, visitor);
     safelyVisitChildren(_imports, visitor);
     safelyVisitChildren(_parts, visitor);
   }
 
   /**
    * Answer `true` if the receiver directly or indirectly imports the dart:html libraries.
    * @return `true` if the receiver directly or indirectly imports the dart:html libraries
    */
-  bool isOrImportsBrowserLibrary() {
+  bool get isOrImportsBrowserLibrary {
     List<LibraryElement> visited = new List<LibraryElement>();
     Source htmlLibSource = _context.sourceFactory.forUri(DartSdk.DART_HTML);
     visited.add(this);
     for (int index = 0; index < visited.length; index++) {
       LibraryElement library = visited[index];
       Source source = library.definingCompilationUnit.source;
       if (source == htmlLibSource) {
         return true;
       }
       for (LibraryElement importedLibrary in library.importedLibraries) {
@@ skipping 95 matching lines @@
   MethodElementImpl.con2(String name, int nameOffset) : super.con2(name, nameOffset) {
     _jtd_constructor_219_impl(name, nameOffset);
   }
   _jtd_constructor_219_impl(String name, int nameOffset) {
   }
   accept(ElementVisitor visitor) => visitor.visitMethodElement(this);
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
   ElementKind get kind => ElementKind.METHOD;
   String get name {
     String name = super.name;
-    if (isOperator() && name == "-") {
+    if (isOperator && name == "-") {
       if (parameters.length == 0) {
         return "unary-";
       }
     }
     return super.name;
   }
-  bool isAbstract() => hasModifier(Modifier.ABSTRACT);
-  bool isOperator() {
+  bool get isAbstract => hasModifier(Modifier.ABSTRACT);
+  bool get isOperator {
     String name = displayName;
     if (name.isEmpty) {
       return false;
     }
     int first = name.codeUnitAt(0);
     return !((0x61 <= first && first <= 0x7A) || (0x41 <= first && first <= 0x5A) || first == 0x5F || first == 0x24);
   }
-  bool isStatic() => hasModifier(Modifier.STATIC);
+  bool get isStatic => hasModifier(Modifier.STATIC);
 
   /**
    * Set whether this method is abstract to correspond to the given value.
    * @param isAbstract `true` if the method is abstract
    */
   void set abstract(bool isAbstract) {
     setModifier(Modifier.ABSTRACT, isAbstract);
   }
 
   /**
@@ skipping 87 matching lines @@
   int get nameOffset => -1;
   Source get source => null;
   bool isAccessibleIn(LibraryElement library) {
     for (Element element in _conflictingElements) {
       if (element.isAccessibleIn(library)) {
         return true;
       }
     }
     return false;
   }
-  bool isSynthetic() => true;
+  bool get isSynthetic => true;
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append("[");
     int count = _conflictingElements.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
         builder.append(", ");
       }
       ((_conflictingElements[i] as ElementImpl)).appendTo(builder);
     }
@@ skipping 93 matching lines @@
   }
   ElementKind get kind => ElementKind.PARAMETER;
   ParameterKind get parameterKind => _parameterKind;
   List<ParameterElement> get parameters => _parameters;
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
-  bool isInitializingFormal() => false;
+  bool get isInitializingFormal => false;
 
   /**
    * Set the range of the default value for this parameter to the range starting at the given offset
    * with the given length.
    * @param offset the offset to the beginning of the default value range for this element
    * @param length the length of the default value range for this element, or `-1` if this
    * element does not have a default value
    */
   void setDefaultValueRange(int offset, int length) {
     _defaultValueRangeOffset = offset;
@@ skipping 128 matching lines @@
    * @param variable the variable with which this access is associated
    */
   PropertyAccessorElementImpl.con2(PropertyInducingElementImpl variable2) : super.con2(variable2.name, variable2.nameOffset) {
     _jtd_constructor_225_impl(variable2);
   }
   _jtd_constructor_225_impl(PropertyInducingElementImpl variable2) {
     this._variable = variable2;
     synthetic = true;
   }
   accept(ElementVisitor visitor) => visitor.visitPropertyAccessorElement(this);
-  bool operator ==(Object object) => super == object && identical(isGetter(), ((object as PropertyAccessorElement)).isGetter());
+  bool operator ==(Object object) => super == object && identical(isGetter, ((object as PropertyAccessorElement)).isGetter);
   PropertyAccessorElement get correspondingGetter {
-    if (isGetter() || _variable == null) {
+    if (isGetter || _variable == null) {
       return null;
     }
     return _variable.getter;
   }
   PropertyAccessorElement get correspondingSetter {
-    if (isSetter() || _variable == null) {
+    if (isSetter || _variable == null) {
       return null;
     }
     return _variable.setter;
   }
   ElementKind get kind {
-    if (isGetter()) {
+    if (isGetter) {
       return ElementKind.GETTER;
     }
     return ElementKind.SETTER;
   }
   String get name {
-    if (isSetter()) {
+    if (isSetter) {
       return "${super.name}=";
     }
     return super.name;
   }
   PropertyInducingElement get variable => _variable;
-  bool isAbstract() => hasModifier(Modifier.ABSTRACT);
-  bool isGetter() => hasModifier(Modifier.GETTER);
-  bool isSetter() => hasModifier(Modifier.SETTER);
-  bool isStatic() => hasModifier(Modifier.STATIC);
+  bool get isAbstract => hasModifier(Modifier.ABSTRACT);
+  bool get isGetter => hasModifier(Modifier.GETTER);
+  bool get isSetter => hasModifier(Modifier.SETTER);
+  bool get isStatic => hasModifier(Modifier.STATIC);
 
   /**
    * Set whether this accessor is abstract to correspond to the given value.
    * @param isAbstract `true` if the accessor is abstract
    */
   void set abstract(bool isAbstract) {
     setModifier(Modifier.ABSTRACT, isAbstract);
   }
 
   /**
@@ skipping 21 matching lines @@
   }
 
   /**
    * Set the variable associated with this accessor to the given variable.
    * @param variable the variable associated with this accessor
    */
   void set variable(PropertyInducingElement variable2) {
     this._variable = variable2;
   }
   void appendTo(JavaStringBuilder builder) {
-    builder.append(isGetter() ? "get " : "set ");
+    builder.append(isGetter ? "get " : "set ");
     builder.append(variable.displayName);
     super.appendTo(builder);
   }
 }
 /**
  * Instances of the class `PropertyInducingElementImpl` implement a`PropertyInducingElement`.
  * @coverage dart.engine.element
  */
 abstract class PropertyInducingElementImpl extends VariableElementImpl implements PropertyInducingElement {
 
@@ skipping 110 matching lines @@
    * Initialize a newly created synthetic top-level variable element to have the given name.
    * @param name the name of this element
    */
   TopLevelVariableElementImpl.con2(String name) : super.con2(name) {
     _jtd_constructor_230_impl(name);
   }
   _jtd_constructor_230_impl(String name) {
   }
   accept(ElementVisitor visitor) => visitor.visitTopLevelVariableElement(this);
   ElementKind get kind => ElementKind.TOP_LEVEL_VARIABLE;
-  bool isStatic() => true;
+  bool get isStatic => true;
 }
 /**
  * Instances of the class `TypeVariableElementImpl` implement a `TypeVariableElement`.
  * @coverage dart.engine.element
  */
 class TypeVariableElementImpl extends ElementImpl implements TypeVariableElement {
 
   /**
    * The type defined by this type variable.
    */
@@ skipping 90 matching lines @@
 
   /**
    * Return the result of evaluating this variable's initializer as a compile-time constant
    * expression, or `null` if this variable is not a 'const' variable or does not have an
    * initializer.
    * @return the result of evaluating this variable's initializer
    */
   EvaluationResultImpl get evaluationResult => null;
   FunctionElement get initializer => _initializer;
   Type2 get type => _type;
-  bool isConst() => hasModifier(Modifier.CONST);
-  bool isFinal() => hasModifier(Modifier.FINAL);
+  bool get isConst => hasModifier(Modifier.CONST);
+  bool get isFinal => hasModifier(Modifier.FINAL);
 
   /**
    * Set whether this variable is const to correspond to the given value.
    * @param isConst `true` if the variable is const
    */
   void set const3(bool isConst) {
     setModifier(Modifier.CONST, isConst);
   }
 
   /**
@@ skipping 75 matching lines @@
    * Initialize a newly created element to represent a constructor of the given parameterized type.
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
   ConstructorMember(ConstructorElement baseElement, InterfaceType definingType) : super(baseElement, definingType) {
   }
   accept(ElementVisitor visitor) => visitor.visitConstructorElement(this);
   ConstructorElement get baseElement => super.baseElement as ConstructorElement;
   ClassElement get enclosingElement => baseElement.enclosingElement;
   ConstructorElement get redirectedConstructor => from(baseElement.redirectedConstructor, definingType);
-  bool isConst() => baseElement.isConst();
-  bool isDefaultConstructor() => baseElement.isDefaultConstructor();
-  bool isFactory() => baseElement.isFactory();
+  bool get isConst => baseElement.isConst;
+  bool get isDefaultConstructor => baseElement.isDefaultConstructor;
+  bool get isFactory => baseElement.isFactory;
   String toString() {
     ConstructorElement baseElement = this.baseElement;
     List<ParameterElement> parameters = this.parameters;
     FunctionType type = this.type;
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append(baseElement.enclosingElement.displayName);
     String name = displayName;
     if (name != null && !name.isEmpty) {
       builder.append(".");
       builder.append(name);
@@ skipping 45 matching lines @@
       return baseParameters;
     }
     List<ParameterElement> parameterizedParameters = new List<ParameterElement>(parameterCount);
     for (int i = 0; i < parameterCount; i++) {
       parameterizedParameters[i] = ParameterMember.from(baseParameters[i], definingType);
     }
     return parameterizedParameters;
   }
   Type2 get returnType => substituteFor(baseElement.returnType);
   FunctionType get type => substituteFor(baseElement.type);
-  bool isOperator() => baseElement.isOperator();
-  bool isStatic() => baseElement.isStatic();
+  bool get isOperator => baseElement.isOperator;
+  bool get isStatic => baseElement.isStatic;
   void visitChildren(ElementVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(baseElement.functions, visitor);
     safelyVisitChildren(labels, visitor);
     safelyVisitChildren(baseElement.localVariables, visitor);
     safelyVisitChildren(parameters, visitor);
   }
 }
 /**
  * Instances of the class `FieldMember` represent a field element defined in a parameterized
@@ skipping 33 matching lines @@
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
   FieldMember(FieldElement baseElement, InterfaceType definingType) : super(baseElement, definingType) {
   }
   accept(ElementVisitor visitor) => visitor.visitFieldElement(this);
   FieldElement get baseElement => super.baseElement as FieldElement;
   ClassElement get enclosingElement => baseElement.enclosingElement;
   PropertyAccessorElement get getter => PropertyAccessorMember.from(baseElement.getter, definingType);
   PropertyAccessorElement get setter => PropertyAccessorMember.from(baseElement.setter, definingType);
-  bool isStatic() => baseElement.isStatic();
+  bool get isStatic => baseElement.isStatic;
   InterfaceType get definingType => super.definingType as InterfaceType;
 }
 /**
  * The abstract class `Member` defines the behavior common to elements that represent members
  * of parameterized types.
  */
 abstract class Member implements Element {
 
   /**
    * The element on which the parameterized element was created.
@@ skipping 25 matching lines @@
   AnalysisContext get context => _baseElement.context;
   String get displayName => _baseElement.displayName;
   ElementKind get kind => _baseElement.kind;
   LibraryElement get library => _baseElement.library;
   ElementLocation get location => _baseElement.location;
   List<ElementAnnotation> get metadata => _baseElement.metadata;
   String get name => _baseElement.name;
   int get nameOffset => _baseElement.nameOffset;
   Source get source => _baseElement.source;
   bool isAccessibleIn(LibraryElement library) => _baseElement.isAccessibleIn(library);
-  bool isSynthetic() => _baseElement.isSynthetic();
+  bool get isSynthetic => _baseElement.isSynthetic;
   void visitChildren(ElementVisitor<Object> visitor) {
   }
 
   /**
    * Return the type in which the element is defined.
    * @return the type in which the element is defined
    */
   ParameterizedType get definingType => _definingType;
 
   /**
@@ skipping 80 matching lines @@
   /**
    * Initialize a newly created element to represent a method of the given parameterized type.
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
   MethodMember(MethodElement baseElement, InterfaceType definingType) : super(baseElement, definingType) {
   }
   accept(ElementVisitor visitor) => visitor.visitMethodElement(this);
   MethodElement get baseElement => super.baseElement as MethodElement;
   ClassElement get enclosingElement => baseElement.enclosingElement;
-  bool isAbstract() => baseElement.isAbstract();
+  bool get isAbstract => baseElement.isAbstract;
   String toString() {
     MethodElement baseElement = this.baseElement;
     List<ParameterElement> parameters = this.parameters;
     FunctionType type = this.type;
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append(baseElement.enclosingElement.displayName);
     builder.append(".");
     builder.append(baseElement.displayName);
     builder.append("(");
     int parameterCount = parameters.length;
@@ skipping 74 matching lines @@
     if (parameterCount == 0) {
       return baseParameters;
     }
     List<ParameterElement> parameterizedParameters = new List<ParameterElement>(parameterCount);
     for (int i = 0; i < parameterCount; i++) {
       parameterizedParameters[i] = ParameterMember.from(baseParameters[i], definingType);
     }
     return parameterizedParameters;
   }
   SourceRange get visibleRange => baseElement.visibleRange;
-  bool isInitializingFormal() => baseElement.isInitializingFormal();
+  bool get isInitializingFormal => baseElement.isInitializingFormal;
   String toString() {
     ParameterElement baseElement = this.baseElement;
     String left = "";
     String right = "";
     while (true) {
       if (baseElement.parameterKind == ParameterKind.NAMED) {
         left = "{";
         right = "}";
       } else if (baseElement.parameterKind == ParameterKind.POSITIONAL) {
         left = "[";
@@ skipping 57 matching lines @@
   PropertyAccessorElement get correspondingGetter => from(baseElement.correspondingGetter, definingType);
   PropertyAccessorElement get correspondingSetter => from(baseElement.correspondingSetter, definingType);
   Element get enclosingElement => baseElement.enclosingElement;
   PropertyInducingElement get variable {
     PropertyInducingElement variable = baseElement.variable;
     if (variable is FieldElement) {
       return FieldMember.from(((variable as FieldElement)), definingType);
     }
     return variable;
   }
-  bool isAbstract() => baseElement.isAbstract();
-  bool isGetter() => baseElement.isGetter();
-  bool isSetter() => baseElement.isSetter();
+  bool get isAbstract => baseElement.isAbstract;
+  bool get isGetter => baseElement.isGetter;
+  bool get isSetter => baseElement.isSetter;
   InterfaceType get definingType => super.definingType as InterfaceType;
 }
 /**
  * The abstract class `VariableMember` defines the behavior common to members that represent a
  * variable element defined in a parameterized type where the values of the type parameters are
  * known.
  */
 abstract class VariableMember extends Member implements VariableElement {
 
   /**
    * Initialize a newly created element to represent an executable element of the given
    * parameterized type.
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
   VariableMember(VariableElement baseElement, ParameterizedType definingType) : super(baseElement, definingType) {
   }
   VariableElement get baseElement => super.baseElement as VariableElement;
   FunctionElement get initializer {
     throw new UnsupportedOperationException();
   }
   Type2 get type => substituteFor(baseElement.type);
-  bool isConst() => baseElement.isConst();
-  bool isFinal() => baseElement.isFinal();
+  bool get isConst => baseElement.isConst;
+  bool get isFinal => baseElement.isFinal;
   void visitChildren(ElementVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(baseElement.initializer, visitor);
   }
 }
 /**
  * The unique instance of the class `BottomTypeImpl` implements the type `bottom`.
  * @coverage dart.engine.type
  */
 class BottomTypeImpl extends TypeImpl {
@@ skipping 37 matching lines @@
    */
   static DynamicTypeImpl get instance => _INSTANCE;
 
   /**
    * Prevent the creation of instances of this class.
    */
   DynamicTypeImpl() : super(new DynamicElementImpl(), Keyword.DYNAMIC.syntax) {
     ((element as DynamicElementImpl)).type = this;
   }
   bool operator ==(Object object) => object is DynamicTypeImpl;
-  bool isDynamic() => true;
+  bool get isDynamic => true;
   bool isMoreSpecificThan(Type2 type) => false;
   bool isSubtypeOf(Type2 type) => identical(this, type);
   bool isSupertypeOf(Type2 type) => true;
   DynamicTypeImpl substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes) => this;
 }
 /**
  * Instances of the class `FunctionTypeImpl` defines the behavior common to objects
  * representing the type of a function, method, constructor, getter, or setter.
  * @coverage dart.engine.type
  */
@@ skipping 193 matching lines @@
   int get hashCode {
     Element element = this.element;
     if (element == null) {
       return 0;
     }
     return element.hashCode;
   }
   bool isSubtypeOf(Type2 type) {
     if (type == null) {
       return false;
-    } else if (identical(this, type) || type.isDynamic() || type.isDartCoreFunction() || type.isObject()) {
+    } else if (identical(this, type) || type.isDynamic || type.isDartCoreFunction || type.isObject) {
       return true;
     } else if (type is! FunctionType) {
       return false;
     } else if (this == type) {
       return true;
     }
     FunctionType t = this;
     FunctionType s = type as FunctionType;
     List<Type2> tTypes = t.normalParameterTypes;
     List<Type2> tOpTypes = t.optionalParameterTypes;
@@ skipping 481 matching lines @@
   }
   List<Type2> get typeArguments => _typeArguments;
   List<TypeVariableElement> get typeVariables => element.typeVariables;
   int get hashCode {
     ClassElement element = this.element;
     if (element == null) {
       return 0;
     }
     return element.hashCode;
   }
-  bool isDartCoreFunction() {
+  bool get isDartCoreFunction {
     ClassElement element = this.element;
     if (element == null) {
       return false;
     }
-    return element.name == "Function" && element.library.isDartCore();
+    return element.name == "Function" && element.library.isDartCore;
   }
   bool isDirectSupertypeOf(InterfaceType type) {
     ClassElement i = element;
     ClassElement j = type.element;
     InterfaceType supertype = j.supertype;
     if (supertype == null) {
       return false;
     }
     ClassElement supertypeElement = supertype.element;
     if (supertypeElement == i) {
@@ skipping 12 matching lines @@
     return false;
   }
   bool isMoreSpecificThan(Type2 type) {
     if (identical(type, DynamicTypeImpl.instance)) {
       return true;
     } else if (type is! InterfaceType) {
       return false;
     }
     return isMoreSpecificThan2((type as InterfaceType), new Set<ClassElement>());
   }
-  bool isObject() => element.supertype == null;
+  bool get isObject => element.supertype == null;
   bool isSubtypeOf(Type2 type2) {
     if (identical(type2, DynamicTypeImpl.instance)) {
       return true;
     } else if (type2 is TypeVariableType) {
       return true;
     } else if (type2 is FunctionType) {
       ClassElement element = this.element;
       MethodElement callMethod = element.lookUpMethod("call", element.library);
       if (callMethod != null) {
         return callMethod.type.isSubtypeOf(type2);
@@ skipping 213 matching lines @@
       List<Type2> typeSArgs = typeS.typeArguments;
       if (typeTArgs.length != typeSArgs.length) {
         return false;
       }
       for (int i = 0; i < typeTArgs.length; i++) {
         if (!typeTArgs[i].isSubtypeOf(typeSArgs[i])) {
           return false;
         }
       }
       return true;
-    } else if (typeS.isDartCoreFunction() && elementT.getMethod("call") != null) {
+    } else if (typeS.isDartCoreFunction && elementT.getMethod("call") != null) {
       return true;
     }
     InterfaceType supertype = elementT.supertype;
     if (supertype != null && ((supertype as InterfaceTypeImpl)).isSubtypeOf2(typeS, visitedClasses)) {
       return true;
     }
     List<InterfaceType> interfaceTypes = elementT.interfaces;
     for (InterfaceType interfaceType in interfaceTypes) {
       if (((interfaceType as InterfaceTypeImpl)).isSubtypeOf2(typeS, visitedClasses)) {
         return true;
@@ skipping 58 matching lines @@
    */
   TypeImpl(Element element, String name) {
     this._element = element;
     this._name = name;
   }
   String get displayName => name;
   Element get element => _element;
   Type2 getLeastUpperBound(Type2 type) => null;
   String get name => _name;
   bool isAssignableTo(Type2 type) => this.isSubtypeOf(type) || type.isSubtypeOf(this);
-  bool isDartCoreFunction() => false;
-  bool isDynamic() => false;
+  bool get isDartCoreFunction => false;
+  bool get isDynamic => false;
   bool isMoreSpecificThan(Type2 type) => false;
-  bool isObject() => false;
+  bool get isObject => false;
   bool isSupertypeOf(Type2 type) => type.isSubtypeOf(this);
-  bool isVoid() => false;
+  bool get isVoid => false;
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     appendTo(builder);
     return builder.toString();
   }
 
   /**
    * Append a textual representation of this type to the given builder.
    * @param builder the builder to which the text is to be appended
    */
@@ skipping 77 matching lines @@
    */
   static VoidTypeImpl get instance => _INSTANCE;
 
   /**
    * Prevent the creation of instances of this class.
    */
   VoidTypeImpl() : super(null, Keyword.VOID.syntax) {
   }
   bool operator ==(Object object) => identical(object, this);
   bool isSubtypeOf(Type2 type) => identical(type, this) || identical(type, DynamicTypeImpl.instance);
-  bool isVoid() => true;
+  bool get isVoid => true;
   VoidTypeImpl substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes) => this;
 }
 /**
  * The interface `FunctionType` defines the behavior common to objects representing the type
  * of a function, method, constructor, getter, or setter. Function types come in three variations:
  * <ol>
  * * The types of functions that only have required parameters. These have the general form
  * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>) &rarr; T</i>.
  * * The types of functions with optional positional parameters. These have the general form
  * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, \[T<sub>n+1</sub>, &hellip;, T<sub>n+k</sub>\]) &rarr;
@@ skipping 466 matching lines @@
    * @return `true` if this type is assignable to the given type
    */
   bool isAssignableTo(Type2 type);
 
   /**
    * Return `true` if this type represents the type 'Function' defined in the dart:core
    * library.
    * @return `true` if this type represents the type 'Function' defined in the dart:core
    * library
    */
-  bool isDartCoreFunction();
+  bool get isDartCoreFunction;
 
   /**
    * Return `true` if this type represents the type 'dynamic'.
    * @return `true` if this type represents the type 'dynamic'
    */
-  bool isDynamic();
+  bool get isDynamic;
 
   /**
    * Return `true` if this type is more specific than the given type.
    * @param type the type being compared with this type
    * @return `true` if this type is more specific than the given type
    */
   bool isMoreSpecificThan(Type2 type);
 
   /**
    * Return `true` if this type represents the type 'Object'.
    * @return `true` if this type represents the type 'Object'
    */
-  bool isObject();
+  bool get isObject;
 
   /**
    * Return `true` if this type is a subtype of the given type.
    * @param type the type being compared with this type
    * @return `true` if this type is a subtype of the given type
    */
   bool isSubtypeOf(Type2 type);
 
   /**
    * Return `true` if this type is a supertype of the given type. A type <i>S</i> is a
    * supertype of <i>T</i>, written <i>S</i> :> <i>T</i>, iff <i>T</i> is a subtype of <i>S</i>.
    * @param type the type being compared with this type
    * @return `true` if this type is a supertype of the given type
    */
   bool isSupertypeOf(Type2 type);
 
   /**
    * Return `true` if this type represents the type 'void'.
    * @return `true` if this type represents the type 'void'
    */
-  bool isVoid();
+  bool get isVoid;
 
   /**
    * Return the type resulting from substituting the given arguments for the given parameters in
    * this type. The specification defines this operation in section 2: <blockquote> The notation
    * <i>\[x<sub>1</sub>, ..., x<sub>n</sub>/y<sub>1</sub>, ..., y<sub>n</sub>\]E</i> denotes a copy of
    * <i>E</i> in which all occurrences of <i>y<sub>i</sub>, 1 <= i <= n</i> have been replaced with
    * <i>x<sub>i</sub></i>.</blockquote> Note that, contrary to the specification, this method will
    * not create a copy of this type if no substitutions were required, but will return this type
    * directly.
    * @param argumentTypes the actual type arguments being substituted for the parameters
@@ skipping 10 matching lines @@
 abstract class TypeVariableType implements Type2 {
   TypeVariableElement get element;
 }
 /**
  * The interface `VoidType` defines the behavior of the unique object representing the type`void`.
  * @coverage dart.engine.type
  */
 abstract class VoidType implements Type2 {
   VoidType substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
 }