Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/enqueue.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;
 
 typedef ItemCompilationContext ItemCompilationContextCreator();
 
 class EnqueueTask extends CompilerTask {
   final ResolutionEnqueuer resolution;
   final CodegenEnqueuer codegen;
 
   /// A reverse map from name to *all* elements with that name, not
   /// just instance members of instantiated classes.
   final Map<String, Link<Element>> allElementsByName
       = new Map<String, Link<Element>>();
 
   void ensureAllElementsByName() {
     if (!allElementsByName.isEmpty) return;
 
     void addMemberByName(Element element) {
       element = element.declaration;
       String name = element.name;
       ScopeContainerElement container = null;
-      if (element.isLibrary()) {
+      if (element.isLibrary) {
         LibraryElement library = element;
         // Don't include private implementation libraries.  These
         // libraries contain special classes that cause problems
         // in other parts of the resolver (in particular Null and Void).
         // TODO(ahe): Consider lifting this restriction.
         if (!library.isInternalLibrary) {
           container = library;
           // TODO(ahe): Is this right?  Is this necessary?
           name = library.getLibraryOrScriptName();
         }
-      } else if (element.isClass()) {
+      } else if (element.isClass) {
         ClassElement cls = element;
         cls.ensureResolved(compiler);
         container = cls;
         for (var link = cls.computeTypeParameters(compiler);
              !link.isEmpty;
              link = link.tail) {
           addMemberByName(link.head.element);
         }
       }
       allElementsByName[name] = allElementsByName.putIfAbsent(
@@ skipping 70 matching lines @@
     task.measure(() {
       ClassElement cls = type.element;
       elements.registerDependency(cls);
       cls.ensureResolved(compiler);
       universe.instantiatedTypes.add(type);
       if (!cls.isAbstract
           // We can't use the closed-world assumption with native abstract
           // classes; a native abstract class may have non-abstract subclasses
           // not declared to the program.  Instances of these classes are
           // indistinguishable from the abstract class.
-          || cls.isNative()) {
+          || cls.isNative) {
         universe.instantiatedClasses.add(cls);
       }
       onRegisterInstantiatedClass(cls);
     });
   }
 
   void registerInstantiatedClass(ClassElement cls, TreeElements elements) {
     cls.ensureResolved(compiler);
     registerInstantiatedType(cls.rawType, elements);
   }
@@ skipping 17 matching lines @@
     return true;
   }
 
   void processInstantiatedClass(ClassElement cls) {
     cls.implementation.forEachMember(processInstantiatedClassMember);
   }
 
   void processInstantiatedClassMember(ClassElement cls, Element member) {
     assert(invariant(member, member.isDeclaration));
     if (isProcessed(member)) return;
-    if (!member.isInstanceMember()) return;
+    if (!member.isInstanceMember) return;
 
     String memberName = member.name;
 
     if (member.kind == ElementKind.FIELD) {
-      // The obvious thing to test here would be "member.isNative()",
+      // The obvious thing to test here would be "member.isNative",
       // however, that only works after metadata has been parsed/analyzed,
       // and that may not have happened yet.
       // So instead we use the enclosing class, which we know have had
       // its metadata parsed and analyzed.
       // Note: this assumes that there are no non-native fields on native
       // classes, which may not be the case when a native class is subclassed.
-      if (cls.isNative()) {
+      if (cls.isNative) {
         compiler.world.registerUsedElement(member);
         nativeEnqueuer.handleFieldAnnotations(member);
         if (universe.hasInvokedGetter(member, compiler) ||
             universe.hasInvocation(member, compiler)) {
           nativeEnqueuer.registerFieldLoad(member);
           // In handleUnseenSelector we can't tell if the field is loaded or
           // stored.  We need the basic algorithm to be Church-Rosser, since the
           // resolution 'reduction' order is different to the codegen order. So
           // register that the field is also stored.  In other words: if we
           // don't register the store here during resolution, the store could be
@@ skipping 133 matching lines @@
   /// Called when [:const Symbol(name):] is seen.
   void registerConstSymbol(String name, TreeElements elements) {
     compiler.backend.registerConstSymbol(name, elements);
   }
 
   void pretendElementWasUsed(Element element, TreeElements elements) {
     if (!compiler.backend.isNeededForReflection(element)) return;
     if (Elements.isUnresolved(element)) {
       // Ignore.
     } else if (element.isSynthesized
-               && element.getLibrary().isPlatformLibrary) {
+               && element.library.isPlatformLibrary) {
       // TODO(ahe): Work-around for http://dartbug.com/11205.
-    } else if (element.isConstructor()) {
-      ClassElement cls = element.declaration.getEnclosingClass();
+    } else if (element.isConstructor) {
+      ClassElement cls = element.declaration.enclosingClass;
       registerInstantiatedType(cls.rawType, elements);
       registerStaticUse(element.declaration);
-    } else if (element.isClass()) {
+    } else if (element.isClass) {
       ClassElement cls = element.declaration;
       registerInstantiatedClass(cls, elements);
       // Make sure that even abstract classes are considered instantiated.
       universe.instantiatedClasses.add(cls);
-    } else if (element.impliesType()) {
+    } else if (element.impliesType) {
       // Don't enqueue typedefs, and type variables.
     } else if (Elements.isStaticOrTopLevel(element)) {
       registerStaticUse(element.declaration);
-    } else if (element.isInstanceMember()) {
+    } else if (element.isInstanceMember) {
       Selector selector = new Selector.fromElement(element, compiler);
       registerSelectorUse(selector);
-      if (element.isField()) {
+      if (element.isField) {
         Selector selector =
-            new Selector.setter(element.name, element.getLibrary());
+            new Selector.setter(element.name, element.library);
         registerInvokedSetter(selector);
       }
     }
   }
 
   /// Called when [:new Symbol(...):] is seen.
   void registerNewSymbol(TreeElements elements) {
     compiler.backend.registerNewSymbol(elements);
   }
 
@@ skipping 41 matching lines @@
     processLink(instanceMembersByName, n, f);
   }
 
   processInstanceFunctions(String n, bool f(Element e)) {
     processLink(instanceFunctionsByName, n, f);
   }
 
   void handleUnseenSelector(String methodName, Selector selector) {
     processInstanceMembers(methodName, (Element member) {
       if (selector.appliesUnnamed(member, compiler)) {
-        if (member.isFunction() && selector.isGetter()) {
+        if (member.isFunction && selector.isGetter) {
           registerClosurizedMember(member, compiler.globalDependencies);
         }
-        if (member.isField() && member.getEnclosingClass().isNative()) {
-          if (selector.isGetter() || selector.isCall()) {
+        if (member.isField && member.enclosingClass.isNative) {
+          if (selector.isGetter || selector.isCall) {
             nativeEnqueuer.registerFieldLoad(member);
             // We have to also handle storing to the field because we only get
             // one look at each member and there might be a store we have not
             // seen yet.
             // TODO(sra): Process fields for storing separately.
             nativeEnqueuer.registerFieldStore(member);
           } else {
-            assert(selector.isSetter());
+            assert(selector.isSetter);
             nativeEnqueuer.registerFieldStore(member);
             // We have to also handle loading from the field because we only get
             // one look at each member and there might be a load we have not
             // seen yet.
             // TODO(sra): Process fields for storing separately.
             nativeEnqueuer.registerFieldLoad(member);
           }
         }
         addToWorkList(member);
         return true;
       }
       return false;
     });
-    if (selector.isGetter()) {
+    if (selector.isGetter) {
       processInstanceFunctions(methodName, (Element member) {
         if (selector.appliesUnnamed(member, compiler)) {
           registerClosurizedMember(member, compiler.globalDependencies);
           return true;
         }
         return false;
       });
     }
   }
 
@@ skipping 15 matching lines @@
                               compiler.globalDependencies);
     universe.staticFunctionsNeedingGetter.add(element);
   }
 
   void registerDynamicInvocation(Selector selector) {
     assert(selector != null);
     registerInvocation(selector);
   }
 
   void registerSelectorUse(Selector selector) {
-    if (selector.isGetter()) {
+    if (selector.isGetter) {
       registerInvokedGetter(selector);
-    } else if (selector.isSetter()) {
+    } else if (selector.isSetter) {
       registerInvokedSetter(selector);
     } else {
       registerInvocation(selector);
     }
   }
 
   void registerDynamicGetter(Selector selector) {
     registerInvokedGetter(selector);
   }
 
@@ skipping 12 matching lines @@
   void registerFieldSetter(Element element) {
     universe.fieldSetters.add(element);
   }
 
   void registerIsCheck(DartType type, TreeElements elements) {
     type = universe.registerIsCheck(type, compiler);
     // Even in checked mode, type annotations for return type and argument
     // types do not imply type checks, so there should never be a check
     // against the type variable of a typedef.
     assert(type.kind != TypeKind.TYPE_VARIABLE ||
-           !type.element.enclosingElement.isTypedef());
+           !type.element.enclosingElement.isTypedef);
     compiler.backend.registerIsCheck(type, this, elements);
   }
 
   /**
    * If a factory constructor is used with type arguments, we lose track
    * which arguments could be used to create instances of classes that use their
    * type variables as expressions, so we have to remember if we saw such a use.
    */
   void registerFactoryWithTypeArguments(TreeElements elements) {
     universe.usingFactoryWithTypeArguments = true;
   }
 
   void registerAsCheck(DartType type, TreeElements elements) {
     registerIsCheck(type, elements);
     compiler.backend.registerAsCheck(type, this, elements);
   }
 
   void registerGenericCallMethod(Element element, TreeElements elements) {
     compiler.backend.registerGenericCallMethod(element, this, elements);
     universe.genericCallMethods.add(element);
   }
 
   void registerBoundClosure() {
     registerInstantiatedClass(compiler.boundClosureClass,
                               // Precise dependency is not important here.
                               compiler.globalDependencies);
   }
 
   void registerClosurizedMember(Element element, TreeElements elements) {
-    assert(element.isInstanceMember());
+    assert(element.isInstanceMember);
     registerIfGeneric(element, elements);
     registerBoundClosure();
     universe.closurizedMembers.add(element);
   }
 
 
   void registerIfGeneric(Element element, TreeElements elements) {
     if (element.computeType(compiler).containsTypeVariables) {
       compiler.backend.registerGenericClosure(element, this, elements);
       universe.genericClosures.add(element);
@@ skipping 60 matching lines @@
 
   /// Returns [:true:] if [element] has actually been used.
   bool isLive(Element element) {
     if (seenClasses.contains(element)) return true;
     if (getCachedElements(element) != null) return true;
     return false;
   }
 
   TreeElements getCachedElements(Element element) {
     // TODO(ngeoffray): Get rid of this check.
-    if (element.enclosingElement.isClosure()) {
+    if (element.enclosingElement.isClosure) {
       closureMapping.ClosureClassElement cls = element.enclosingElement;
       element = cls.methodElement;
-    } else if (element.isGenerativeConstructorBody()) {
+    } else if (element.isGenerativeConstructorBody) {
       ConstructorBodyElement body = element;
       element = body.constructor;
     }
-    Element owner = element.getOutermostEnclosingMemberOrTopLevel();
+    Element owner = element.outermostEnclosingMemberOrTopLevel;
     if (owner == null) {
       owner = element;
     }
     return resolvedElements[owner.declaration];
   }
 
   void internalAddToWorkList(Element element) {
     assert(invariant(element, element is AnalyzableElement,
         message: 'Element $element is not analyzable.'));
     if (getCachedElements(element) != null) return;
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(element,
           "Resolution work list is closed. Trying to add $element.");
     }
 
     compiler.world.registerUsedElement(element);
 
     queue.add(new ResolutionWorkItem(element, itemCompilationContextCreator()));
 
     // Enable isolate support if we start using something from the isolate
     // library, or timers for the async library.  We exclude constant fields,
     // which are ending here because their initializing expression is compiled.
-    LibraryElement library = element.getLibrary();
+    LibraryElement library = element.library;
     if (!compiler.hasIsolateSupport() &&
-        (!element.isField() || !element.modifiers.isConst())) {
+        (!element.isField || !element.modifiers.isConst)) {
       String uri = library.canonicalUri.toString();
       if (uri == 'dart:isolate') {
         enableIsolateSupport(library);
       } else if (uri == 'dart:async') {
         if (element.name == '_createTimer' ||
             element.name == '_createPeriodicTimer') {
           // The [:Timer:] class uses the event queue of the isolate
           // library, so we make sure that event queue is generated.
           enableIsolateSupport(library);
         }
       }
     }
 
-    if (element.isGetter() && element.name == Compiler.RUNTIME_TYPE) {
+    if (element.isGetter && element.name == Compiler.RUNTIME_TYPE) {
       // Enable runtime type support if we discover a getter called runtimeType.
       // We have to enable runtime type before hitting the codegen, so
       // that constructors know whether they need to generate code for
       // runtime type.
       compiler.enabledRuntimeType = true;
       // TODO(ahe): Record precise dependency here.
       compiler.backend.registerRuntimeType(this, compiler.globalDependencies);
     } else if (element == compiler.functionApplyMethod) {
       compiler.enabledFunctionApply = true;
     } else if (element == compiler.invokeOnMethod) {
@@ skipping 74 matching lines @@
 
   bool isProcessed(Element member) =>
       member.isAbstract || generatedCode.containsKey(member);
 
   void internalAddToWorkList(Element element) {
     // Don't generate code for foreign elements.
     if (element.isForeign(compiler)) return;
 
     // Codegen inlines field initializers. It only needs to generate
     // code for checked setters.
-    if (element.isField() && element.isInstanceMember()) {
+    if (element.isField && element.isInstanceMember) {
       if (!compiler.enableTypeAssertions
-          || element.enclosingElement.isClosure()) {
+          || element.enclosingElement.isClosure) {
         return;
       }
     }
 
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(element,
           "Codegen work list is closed. Trying to add $element");
     }
     CodegenWorkItem workItem = new CodegenWorkItem(
         element, itemCompilationContextCreator());
     queue.add(workItem);
   }
 
   void _logSpecificSummary(log(message)) {
     log('Compiled ${generatedCode.length} methods.');
   }
 }