Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/world.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.
 
 part of dart2js;
 
 class World {
   final Compiler compiler;
   final FunctionSet allFunctions;
   final Set<Element> functionsCalledInLoop = new Set<Element>();
@@ skipping 123 matching lines @@
     Set<ClassElement> classes = subclassesOf(cls);
     return classes != null && !classes.isEmpty;
   }
 
   bool hasAnySubtype(ClassElement cls) {
     Set<ClassElement> classes = subtypesOf(cls);
     return classes != null && !classes.isEmpty;
   }
 
   bool hasAnyUserDefinedGetter(Selector selector) {
-    return allFunctions.filter(selector).any((each) => each.isGetter());
+    return allFunctions.filter(selector).any((each) => each.isGetter);
   }
 
   // Returns whether a subclass of [superclass] implements [type].
   bool hasAnySubclassThatImplements(ClassElement superclass,
                                     ClassElement type) {
     Set<ClassElement> subclasses = typesImplementedBySubclassesOf(superclass);
     if (subclasses == null) return false;
     return subclasses.contains(type);
   }
 
@@ skipping 18 matching lines @@
     Set<ClassElement> subtypes = subtypesOf(supertype);
     return subtypes != null && subtypes.contains(test.declaration);
   }
 
   bool isSubclass(ClassElement superclass, ClassElement test) {
     Set<ClassElement> subclasses = subclassesOf(superclass);
     return subclasses != null && subclasses.contains(test.declaration);
   }
 
   void registerUsedElement(Element element) {
-    if (element.isInstanceMember() && !element.isAbstract) {
+    if (element.isInstanceMember && !element.isAbstract) {
       allFunctions.add(element);
     }
   }
 
   VariableElement locateSingleField(Selector selector) {
     Element result = locateSingleElement(selector);
-    return (result != null && result.isField()) ? result : null;
+    return (result != null && result.isField) ? result : null;
   }
 
   Element locateSingleElement(Selector selector) {
     ti.TypeMask mask = selector.mask == null
         ? new ti.TypeMask.subclass(compiler.objectClass)
         : selector.mask;
     return mask.locateSingleElement(selector, compiler);
   }
 
   void addFunctionCalledInLoop(Element element) {
     functionsCalledInLoop.add(element.declaration);
   }
 
   bool isCalledInLoop(Element element) {
     return functionsCalledInLoop.contains(element.declaration);
   }
 
   bool fieldNeverChanges(Element element) {
-    if (!element.isField()) return false;
-    if (element.isNative()) {
+    if (!element.isField) return false;
+    if (element.isNative) {
       // Some native fields are views of data that may be changed by operations.
       // E.g. node.firstChild depends on parentNode.removeBefore(n1, n2).
       // TODO(sra): Refine the effect classification so that native effects are
       // distinct from ordinary Dart effects.
       return false;
     }
 
-    return element.modifiers.isFinal()
-        || element.modifiers.isConst()
-        || (element.isInstanceMember()
+    return element.modifiers.isFinal
+        || element.modifiers.isConst
+        || (element.isInstanceMember
             && !compiler.resolverWorld.hasInvokedSetter(element, compiler));
   }
 
   SideEffects getSideEffectsOfElement(Element element) {
     // The type inferrer (where the side effects are being computed),
     // does not see generative constructor bodies because they are
     // created by the backend. Also, it does not make any distinction
     // between a constructor and its body for side effects. This
     // implies that currently, the side effects of a constructor body
     // contain the side effects of the initializers.
-    assert(!element.isGenerativeConstructorBody());
-    assert(!element.isField());
+    assert(!element.isGenerativeConstructorBody);
+    assert(!element.isField);
     return sideEffects.putIfAbsent(element.declaration, () {
       return new SideEffects();
     });
   }
 
   void registerSideEffects(Element element, SideEffects effects) {
     if (sideEffectsFreeElements.contains(element)) return;
     sideEffects[element.declaration] = effects;
   }
 
   void registerSideEffectsFree(Element element) {
     sideEffects[element.declaration] = new SideEffects.empty();
     sideEffectsFreeElements.add(element);
   }
 
   SideEffects getSideEffectsOfSelector(Selector selector) {
     // We're not tracking side effects of closures.
-    if (selector.isClosureCall()) return new SideEffects();
+    if (selector.isClosureCall) return new SideEffects();
     SideEffects sideEffects = new SideEffects.empty();
     for (Element e in allFunctions.filter(selector)) {
-      if (e.isField()) {
-        if (selector.isGetter()) {
+      if (e.isField) {
+        if (selector.isGetter) {
           if (!fieldNeverChanges(e)) {
             sideEffects.setDependsOnInstancePropertyStore();
           }
-        } else if (selector.isSetter()) {
+        } else if (selector.isSetter) {
           sideEffects.setChangesInstanceProperty();
         } else {
-          assert(selector.isCall());
+          assert(selector.isCall);
           sideEffects.setAllSideEffects();
           sideEffects.setDependsOnSomething();
         }
       } else {
         sideEffects.add(getSideEffectsOfElement(e));
       }
     }
     return sideEffects;
   }
 
@@ skipping 20 matching lines @@
     // method of function classes that were generated for function
     // expressions. In such a case, we have to look at the original
     // function expressions's element.
     // TODO(herhut): Generate classes for function expressions earlier.
     if (element is SynthesizedCallMethodElementX) {
       return getMightBePassedToApply(element.expression);
     }
     return functionsThatMightBePassedToApply.contains(element);
   }
 }