Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/elements/elements.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library elements;
 
 
 import '../tree/tree.dart';
 import '../util/util.dart';
 import '../resolution/resolution.dart';
@@ skipping 176 matching lines @@
   /// Do not use [computeType] outside of the resolver; instead retrieve the
   /// type from the corresponding field:
   /// - `type` for fields, variables, type variable, and function elements.
   /// - `thisType` or `rawType` for [TypeDeclarationElement]s (classes and
   ///    typedefs), depending on the use case.
   /// Trying to access a type that has not been computed in resolution is an
   /// error and calling [computeType] covers that error.
   /// This method will go away!
   @deprecated DartType computeType(Compiler compiler);
 
-  bool isFunction();
-  bool isConstructor();
-  bool isClosure();
-  bool isMember();
-  bool isInstanceMember();
+  bool get isFunction;
+  bool get isConstructor;
+  bool get isClosure;
+  bool get isMember;
+  bool get isInstanceMember;
 
-  bool isFactoryConstructor();
-  bool isGenerativeConstructor();
-  bool isGenerativeConstructorBody();
-  bool isCompilationUnit();
-  bool isClass();
-  bool isPrefix();
-  bool isVariable();
-  bool isParameter();
-  bool isStatement();
-  bool isTypedef();
-  bool isTypeVariable();
-  bool isField();
-  bool isFieldParameter();
-  bool isAbstractField();
-  bool isGetter();
-  bool isSetter();
-  bool isAccessor();
-  bool isLibrary();
-  bool isErroneous();
-  bool isAmbiguous();
-  bool isWarnOnUse();
+  bool get isFactoryConstructor;
+  bool get isGenerativeConstructor;
+  bool get isGenerativeConstructorBody;
+  bool get isCompilationUnit;
+  bool get isClass;
+  bool get isPrefix;
+  bool get isVariable;
+  bool get isParameter;
+  bool get isStatement;
+  bool get isTypedef;
+  bool get isTypeVariable;
+  bool get isField;
+  bool get isFieldParameter;
+  bool get isAbstractField;
+  bool get isGetter;
+  bool get isSetter;
+  bool get isAccessor;
+  bool get isLibrary;
+  bool get isErroneous;
+  bool get isAmbiguous;
+  bool get isWarnOnUse;
 
   /// Returns true if this [Element] is a top level element.
   /// That is, if it is not defined within the scope of a class.
   ///
   /// This means whether the enclosing element is a compilation unit.
   /// With the exception of [ClosureClassElement] that is considered top level
   /// as all other classes.
-  bool isTopLevel();
-  bool isAssignable();
-  bool isNative();
-  bool isDeferredLoaderGetter();
+  bool get isTopLevel;
+  bool get isAssignable;
+  bool get isNative;
+  bool get isDeferredLoaderGetter;
 
-  bool impliesType();
+  bool get impliesType;
 
-  Token position();
+  Token get position;
 
-  CompilationUnitElement getCompilationUnit();
-  LibraryElement getLibrary();
-  LibraryElement getImplementationLibrary();
-  ClassElement getEnclosingClass();
-  Element getEnclosingClassOrCompilationUnit();
-  Element getEnclosingMember();
-  Element getOutermostEnclosingMemberOrTopLevel();
+  CompilationUnitElement get compilationUnit;
+  LibraryElement get library;
+  LibraryElement get implementationLibrary;
+  ClassElement get enclosingClass;
+  Element get enclosingClassOrCompilationUnit;
+  Element get enclosingMember;
+  Element get outermostEnclosingMemberOrTopLevel;
 
   FunctionElement asFunctionElement();
 
   /// Is [:true:] if this element has a corresponding patch.
   ///
   /// If [:true:] this element has a non-null [patch] field.
   ///
   /// See [:patch_parser.dart:] for a description of the terminology.
   bool get isPatched;
 
@@ skipping 33 matching lines @@
 
   /// Returns the origin for this element if this element is a patch.
   ///
   /// See [:patch_parser.dart:] for a description of the terminology.
   Element get origin;
 
   bool get isSynthesized;
   bool get isForwardingConstructor;
   bool get isMixinApplication;
 
-  bool hasFixedBackendName();
-  String fixedBackendName();
+  bool get hasFixedBackendName;
+  String get fixedBackendName;
 
   bool get isAbstract;
   bool isForeign(Compiler compiler);
 
   void addMetadata(MetadataAnnotation annotation);
   void setNative(String name);
   void setFixedBackendName(String name);
 
   Scope buildScope();
 
   /// If the element is a forwarding constructor, [targetConstructor] holds
   /// the generative constructor that the forwarding constructor points to
   /// (possibly via other forwarding constructors).
   FunctionElement get targetConstructor;
 
   void diagnose(Element context, DiagnosticListener listener);
 
   TreeElements get treeElements;
 
   accept(ElementVisitor visitor);
 }
 
 class Elements {
   static bool isUnresolved(Element e) {
-    return e == null || e.isErroneous();
+    return e == null || e.isErroneous;
   }
-  static bool isErroneousElement(Element e) => e != null && e.isErroneous();
+  static bool isErroneousElement(Element e) => e != null && e.isErroneous;
 
   /// Unwraps [element] reporting any warnings attached to it, if any.
   static Element unwrap(Element element,
                         DiagnosticListener listener,
                         Spannable spannable) {
-    if (element != null && element.isWarnOnUse()) {
+    if (element != null && element.isWarnOnUse) {
       WarnOnUseElement wrappedElement = element;
       element = wrappedElement.unwrap(listener, spannable);
     }
     return element;
   }
 
   static bool isClass(Element e) => e != null && e.kind == ElementKind.CLASS;
   static bool isTypedef(Element e) {
     return e != null && e.kind == ElementKind.TYPEDEF;
   }
 
   static bool isLocal(Element element) {
     return !Elements.isUnresolved(element)
-            && !element.isInstanceMember()
+            && !element.isInstanceMember
             && !isStaticOrTopLevelField(element)
             && !isStaticOrTopLevelFunction(element)
             && (identical(element.kind, ElementKind.VARIABLE) ||
                 identical(element.kind, ElementKind.PARAMETER) ||
                 identical(element.kind, ElementKind.FUNCTION));
   }
 
   static bool isInstanceField(Element element) {
     return !Elements.isUnresolved(element)
-           && element.isInstanceMember()
+           && element.isInstanceMember
            && (identical(element.kind, ElementKind.FIELD)
                || identical(element.kind, ElementKind.GETTER)
                || identical(element.kind, ElementKind.SETTER));
   }
 
   static bool isStaticOrTopLevel(Element element) {
     // TODO(ager): This should not be necessary when patch support has
     // been reworked.
     if (!Elements.isUnresolved(element)
-        && element.modifiers.isStatic()) {
+        && element.modifiers.isStatic) {
       return true;
     }
     return !Elements.isUnresolved(element)
-           && !element.isAmbiguous()
-           && !element.isInstanceMember()
-           && !element.isPrefix()
+           && !element.isAmbiguous
+           && !element.isInstanceMember
+           && !element.isPrefix
            && element.enclosingElement != null
            && (element.enclosingElement.kind == ElementKind.CLASS ||
                element.enclosingElement.kind == ElementKind.COMPILATION_UNIT ||
                element.enclosingElement.kind == ElementKind.LIBRARY ||
                element.enclosingElement.kind == ElementKind.PREFIX);
   }
 
   static bool isInStaticContext(Element element) {
     if (isUnresolved(element)) return true;
-    if (element.enclosingElement.isClosure()) {
+    if (element.enclosingElement.isClosure) {
       var closureClass = element.enclosingElement;
       element = closureClass.methodElement;
     }
-    Element outer = element.getOutermostEnclosingMemberOrTopLevel();
+    Element outer = element.outermostEnclosingMemberOrTopLevel;
     if (isUnresolved(outer)) return true;
-    if (outer.isTopLevel()) return true;
-    if (outer.isGenerativeConstructor()) return false;
-    if (outer.isInstanceMember()) return false;
+    if (outer.isTopLevel) return true;
+    if (outer.isGenerativeConstructor) return false;
+    if (outer.isInstanceMember) return false;
     return true;
   }
 
   static bool isStaticOrTopLevelField(Element element) {
     return isStaticOrTopLevel(element)
            && (identical(element.kind, ElementKind.FIELD)
                || identical(element.kind, ElementKind.GETTER)
                || identical(element.kind, ElementKind.SETTER));
   }
 
   static bool isStaticOrTopLevelFunction(Element element) {
     return isStaticOrTopLevel(element)
            && (identical(element.kind, ElementKind.FUNCTION));
   }
 
   static bool isInstanceMethod(Element element) {
     return !Elements.isUnresolved(element)
-           && element.isInstanceMember()
+           && element.isInstanceMember
            && (identical(element.kind, ElementKind.FUNCTION));
   }
 
   static bool isNativeOrExtendsNative(ClassElement element) {
     if (element == null) return false;
-    if (element.isNative()) return true;
+    if (element.isNative) return true;
     assert(element.resolutionState == STATE_DONE);
     return isNativeOrExtendsNative(element.superclass);
   }
 
   static bool isInstanceSend(Send send, TreeElements elements) {
     Element element = elements[send];
     if (element == null) return !isClosureSend(send, element);
     return isInstanceMethod(element) || isInstanceField(element);
   }
 
   static bool isClosureSend(Send send, Element element) {
     if (send.isPropertyAccess) return false;
     if (send.receiver != null) return false;
     Node selector = send.selector;
     // this().
     if (selector.isThis()) return true;
     // (o)() or foo()().
     if (element == null && selector.asIdentifier() == null) return true;
     if (element == null) return false;
     // foo() with foo a local or a parameter.
     return isLocal(element);
   }
 
   static String reconstructConstructorNameSourceString(Element element) {
     if (element.name == '') {
-      return element.getEnclosingClass().name;
+      return element.enclosingClass.name;
     } else {
       return reconstructConstructorName(element);
     }
   }
 
   // TODO(johnniwinther): Remove this method.
   static String reconstructConstructorName(Element element) {
-    String className = element.getEnclosingClass().name;
+    String className = element.enclosingClass.name;
     if (element.name == '') {
       return className;
     } else {
       return '$className\$${element.name}';
     }
   }
 
   /**
    * Map an operator-name to a valid Dart identifier.
    *
@@ skipping 102 matching lines @@
 
   static bool isListSupertype(Element element, Compiler compiler) {
     LibraryElement coreLibrary = compiler.coreLibrary;
     return element == coreLibrary.find('Iterable');
   }
 
   /// A `compareTo` function that places [Element]s in a consistent order based
   /// on the source code order.
   static int compareByPosition(Element a, Element b) {
     if (identical(a, b)) return 0;
-    int r = a.getLibrary().compareTo(b.getLibrary());
+    int r = a.library.compareTo(b.library);
     if (r != 0) return r;
-    r = a.getCompilationUnit().compareTo(b.getCompilationUnit());
+    r = a.compilationUnit.compareTo(b.compilationUnit);
     if (r != 0) return r;
-    Token positionA = a.position();
-    Token positionB = b.position();
+    Token positionA = a.position;
+    Token positionB = b.position;
     int offsetA = positionA == null ? -1 : positionA.charOffset;
     int offsetB = positionB == null ? -1 : positionB.charOffset;
     r = offsetA.compareTo(offsetB);
     if (r != 0) return r;
     r = a.name.compareTo(b.name);
     if (r != 0) return r;
     // Same file, position and name.  If this happens, we should find out why
     // and make the order total and independent of hashCode.
     return a.hashCode.compareTo(b.hashCode);
   }
@@ skipping 25 matching lines @@
     return element == compiler.filledListConstructor
         && node.isCall
         && !node.arguments.isEmpty
         && !node.arguments.tail.isEmpty
         && node.arguments.tail.tail.isEmpty;
   }
 
   static bool isConstructorOfTypedArraySubclass(Element element,
                                                 Compiler compiler) {
     if (compiler.typedDataLibrary == null) return false;
-    if (!element.isConstructor()) return false;
+    if (!element.isConstructor) return false;
     FunctionElement constructor = element;
     constructor = constructor.redirectionTarget;
-    ClassElement cls = constructor.getEnclosingClass();
-    return cls.getLibrary() == compiler.typedDataLibrary
-        && cls.isNative()
+    ClassElement cls = constructor.enclosingClass;
+    return cls.library == compiler.typedDataLibrary
+        && cls.isNative
         && compiler.world.isSubtype(compiler.typedDataClass, cls)
         && compiler.world.isSubtype(compiler.listClass, cls)
         && constructor.name == '';
   }
 
   static bool switchStatementHasContinue(SwitchStatement node,
                                          TreeElements elements) {
     for (SwitchCase switchCase in node.cases) {
       for (Node labelOrCase in switchCase.labelsAndCases) {
         Node label = labelOrCase.asLabel();
@@ skipping 531 matching lines @@
   bool get isDeclaredByField;
 
   /// Returns `true` if this member is abstract.
   bool get isAbstract;
 
   /// If abstract, [implementation] points to the overridden concrete member,
   /// if any. Otherwise [implementation] points to the member itself.
   Member get implementation;
 }