Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/dart_backend/placeholder_collector.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 dart_backend;
 
 class LocalPlaceholder {
   final String identifier;
   final Set<Node> nodes;
   LocalPlaceholder(this.identifier) : nodes = new Set<Node>();
@@ skipping 37 matching lines @@
       : this.collector = collector,
         super(elements, collector.compiler);
 
   visitOperatorSend(Send node) {
   }
 
   visitForeignSend(Send node) {}
 
   visitSuperSend(Send node) {
     Element element = elements[node];
-    if (element != null && element.isConstructor()) {
+    if (element != null && element.isConstructor) {
       collector.makeRedirectingConstructorPlaceholder(node.selector, element);
     } else {
       collector.tryMakeMemberPlaceholder(node.selector);
     }
   }
 
   visitDynamicSend(Send node) {
     final element = elements[node];
-    if (element == null || !element.isErroneous()) {
+    if (element == null || !element.isErroneous) {
       collector.tryMakeMemberPlaceholder(node.selector);
     }
   }
 
   visitClosureSend(Send node) {
     final element = elements[node];
     if (element != null) {
       collector.tryMakeLocalPlaceholder(element, node.selector);
     }
   }
 
   visitGetterSend(Send node) {
     final element = elements[node];
     // element == null means dynamic property access.
     if (element == null) {
       collector.tryMakeMemberPlaceholder(node.selector);
-    } else if (element.isErroneous()) {
+    } else if (element.isErroneous) {
       return;
-    } else if (element.isPrefix()) {
+    } else if (element.isPrefix) {
       // Node is prefix part in case of source 'lib.somesetter = 5;'
       collector.makeNullPlaceholder(node);
     } else if (Elements.isStaticOrTopLevel(element)) {
       // Unqualified or prefixed top level or static.
       collector.makeElementPlaceholder(node.selector, element);
-    } else if (!element.isTopLevel()) {
-      if (element.isInstanceMember()) {
+    } else if (!element.isTopLevel) {
+      if (element.isInstanceMember) {
         collector.tryMakeMemberPlaceholder(node.selector);
       } else {
         // May get FunctionExpression here in selector
         // in case of A(int this.f());
         if (node.selector is Identifier) {
           collector.tryMakeLocalPlaceholder(element, node.selector);
         } else {
           assert(node.selector is FunctionExpression);
         }
       }
     }
   }
 
   visitAssert(node) {
     visitStaticSend(node);
   }
 
   visitStaticSend(Send node) {
     final element = elements[node];
     collector.backend.registerStaticSend(element, node);
 
     if (Elements.isUnresolved(element)
         || identical(element, compiler.assertMethod)
-        || element.isDeferredLoaderGetter()) {
+        || element.isDeferredLoaderGetter) {
       return;
     }
-    if (element.isConstructor() || element.isFactoryConstructor()) {
+    if (element.isConstructor || element.isFactoryConstructor) {
       // Rename named constructor in redirection position:
       // class C { C.named(); C.redirecting() : this.named(); }
       if (node.receiver is Identifier
           && node.receiver.asIdentifier().isThis()) {
         assert(node.selector is Identifier);
         collector.makeRedirectingConstructorPlaceholder(node.selector, element);
       }
       return;
     }
     collector.makeElementPlaceholder(node.selector, element);
     // Another ugly case: <lib prefix>.<top level> is represented as
     // receiver: lib prefix, selector: top level.
-    if (element.isTopLevel() && node.receiver != null) {
-      assert(elements[node.receiver].isPrefix());
+    if (element.isTopLevel && node.receiver != null) {
+      assert(elements[node.receiver].isPrefix);
       // Hack: putting null into map overrides receiver of original node.
       collector.makeNullPlaceholder(node.receiver);
     }
   }
 
   internalError(String reason, {Node node}) {
     collector.internalError(reason, node: node);
   }
 
   visitTypeReferenceSend(Send node) {
@@ skipping 31 matching lines @@
       elementNodes = new Map<Element, Set<Node>>(),
       functionScopes = new Map<FunctionElement, FunctionScope>(),
       privateNodes = new Map<LibraryElement, Set<Identifier>>(),
       declarationTypePlaceholders = new List<DeclarationTypePlaceholder>(),
       memberPlaceholders = new Map<String, Set<Identifier>>(),
       constructorPlaceholders =
           new Map<Element, List<ConstructorPlaceholder>>();
 
   void collectFunctionDeclarationPlaceholders(
       FunctionElement element, FunctionExpression node) {
-    if (element.isGenerativeConstructor() || element.isFactoryConstructor()) {
-      DartType type = element.getEnclosingClass().thisType.asRaw();
+    if (element.isGenerativeConstructor || element.isFactoryConstructor) {
+      DartType type = element.enclosingClass.thisType.asRaw();
       makeConstructorPlaceholder(node.name, element, type);
       Return bodyAsReturn = node.body.asReturn();
       if (bodyAsReturn != null && bodyAsReturn.isRedirectingFactoryBody) {
         // Factory redirection.
         FunctionElement redirectTarget = element.defaultImplementation;
         assert(redirectTarget != null && redirectTarget != element);
-        type = redirectTarget.getEnclosingClass().thisType.asRaw();
+        type = redirectTarget.enclosingClass.thisType.asRaw();
         makeConstructorPlaceholder(
             bodyAsReturn.expression, redirectTarget, type);
       }
     } else if (Elements.isStaticOrTopLevel(element)) {
       // Note: this code should only rename private identifiers for class'
       // fields/getters/setters/methods.  Top-level identifiers are renamed
       // just to escape conflicts and that should be enough as we shouldn't
       // be able to resolve private identifiers for other libraries.
       makeElementPlaceholder(node.name, element);
-    } else if (element.isMember()) {
+    } else if (element.isMember) {
       if (node.name is Identifier) {
         tryMakeMemberPlaceholder(node.name);
       } else {
         assert(node.name.asSend().isOperator);
       }
     }
   }
 
   void collectFieldDeclarationPlaceholders(Element element, Node node) {
     Identifier name = node is Identifier ? node : node.asSend().selector;
@@ skipping 27 matching lines @@
     currentLocalPlaceholders = new Map<String, LocalPlaceholder>();
     compiler.withCurrentElement(element, () {
       elementNode.accept(this);
     });
   }
 
   // TODO(karlklose): should we create placeholders for these?
   bool isTypedefParameter(Element element) {
     return element != null &&
         element.enclosingElement != null &&
-        element.enclosingElement.isTypedef();
+        element.enclosingElement.isTypedef;
   }
 
   void tryMakeLocalPlaceholder(Element element, Identifier node) {
     bool isNamedOptionalParameter() {
       FunctionElement function = element.enclosingElement;
       FunctionSignature signature = function.functionSignature;
       if (!signature.optionalParametersAreNamed) return false;
       for (Element parameter in signature.optionalParameters) {
         if (identical(parameter, element)) return true;
       }
       return false;
     }
 
     // TODO(smok): Maybe we should rename privates as well, their privacy
     // should not matter if they are local vars.
     if (isPrivateName(node.source)) return;
-    if (element.isParameter() && !isTypedefParameter(element) &&
+    if (element.isParameter && !isTypedefParameter(element) &&
         isNamedOptionalParameter()) {
       currentFunctionScope.registerParameter(node);
     } else if (Elements.isLocal(element) && !isTypedefParameter(element)) {
       makeLocalPlaceholder(node);
     }
   }
 
   void tryMakeMemberPlaceholder(Identifier node) {
     assert(node != null);
     if (isPrivateName(node.source)) return;
@@ skipping 22 matching lines @@
         new DeclarationTypePlaceholder(type, false));
   }
 
   void makeVarDeclarationTypePlaceholder(VariableDefinitions node) {
     // TODO(smok): Maybe instead of calling this method and
     // makeDeclaratioTypePlaceholder have type declaration placeholder
     // collector logic in visitVariableDefinitions when resolver becomes better
     // and/or catch syntax changes.
     if (node.type == null) return;
     Element definitionElement = treeElements[node.definitions.nodes.head];
-    bool requiresVar = !node.modifiers.isFinalOrConst();
+    bool requiresVar = !node.modifiers.isFinalOrConst;
     declarationTypePlaceholders.add(
         new DeclarationTypePlaceholder(node.type, requiresVar));
   }
 
   void makeNullPlaceholder(Node node) {
     assert(node is Identifier || node is Send);
     nullNodes.add(node);
   }
 
   void makeElementPlaceholder(Node node, Element element) {
     assert(node != null);
     assert(element != null);
     if (identical(element, entryFunction)) return;
-    if (identical(element.getLibrary(), coreLibrary)) return;
-    if (element.getLibrary().isPlatformLibrary && !element.isTopLevel()) {
+    if (identical(element.library, coreLibrary)) return;
+    if (element.library.isPlatformLibrary && !element.isTopLevel) {
       return;
     }
     if (element == compiler.dynamicClass) {
       return;
     }
     elementNodes.putIfAbsent(element, () => new Set<Node>()).add(node);
   }
 
   void makePrivateIdentifier(Identifier node) {
     assert(node != null);
     privateNodes.putIfAbsent(
-        currentElement.getLibrary(), () => new Set<Identifier>()).add(node);
+        currentElement.library, () => new Set<Identifier>()).add(node);
   }
 
   void makeUnresolvedPlaceholder(Node node) {
     unresolvedNodes.add(node);
   }
 
   void makeLocalPlaceholder(Identifier identifier) {
     LocalPlaceholder getLocalPlaceholder() {
       String name = identifier.source;
       return currentLocalPlaceholders.putIfAbsent(name, () {
@@ skipping 74 matching lines @@
     Element element = treeElements[send];
     if (Elements.isErroneousElement(element)) {
       // Complicated case: constructs like receiver.selector++ can resolve
       // to ErroneousElement.  Fortunately, receiver.selector still
       // can be resoved via treeElements[send.selector], that's all
       // that is needed to rename the construct properly.
       element = treeElements[send.selector];
     }
     if (element == null) {
       if (send.receiver != null) tryMakeMemberPlaceholder(send.selector);
-    } else if (!element.isErroneous()) {
+    } else if (!element.isErroneous) {
       if (Elements.isStaticOrTopLevel(element)) {
         // TODO(smok): Worth investigating why sometimes we get getter/setter
         // here and sometimes abstract field.
-        assert(element.isClass() || element is VariableElement ||
-               element.isAccessor() || element.isAbstractField() ||
-               element.isFunction() || element.isTypedef() ||
+        assert(element.isClass || element is VariableElement ||
+               element.isAccessor || element.isAbstractField ||
+               element.isFunction || element.isTypedef ||
                element is TypeVariableElement);
         makeElementPlaceholder(send.selector, element);
       } else {
         Identifier identifier = send.selector.asIdentifier();
         if (identifier == null) {
           // Handle optional function expression parameters with default values.
           identifier = send.selector.asFunctionExpression().name;
         }
         if (Elements.isInstanceField(element)) {
           tryMakeMemberPlaceholder(identifier);
@@ skipping 144 matching lines @@
 
   visitBlock(Block node) {
     for (Node statement in node.statements.nodes) {
       if (statement is VariableDefinitions) {
         makeVarDeclarationTypePlaceholder(statement);
       }
     }
     node.visitChildren(this);
   }
 }