Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/closure.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 closureToClassMapper;
 
 import "elements/elements.dart";
 import "dart2jslib.dart";
 import "dart_types.dart";
 import "scanner/scannerlib.dart" show Token;
@@ skipping 29 matching lines @@
           new ClosureTranslator(compiler, elements, closureMappingCache, namer);
 
       // The translator will store the computed closure-mappings inside the
       // cache. One for given node and one for each nested closure.
       if (node is FunctionExpression) {
         translator.translateFunction(element, node);
       } else if (element.isSynthesized) {
         return new ClosureClassMap(null, null, null,
             new ThisElement(element, compiler.types.dynamicType));
       } else {
-        assert(element.isField());
+        assert(element.isField);
         VariableElement field = element;
         if (field.initializer != null) {
           // The lazy initializer of a static.
           translator.translateLazyInitializer(element, node, field.initializer);
         } else {
-          assert(element.isInstanceMember());
+          assert(element.isInstanceMember);
           closureMappingCache[node] =
               new ClosureClassMap(null, null, null,
                   new ThisElement(element, compiler.types.dynamicType));
         }
       }
       assert(closureMappingCache[node] != null);
       return closureMappingCache[node];
     });
   }
 
@@ skipping 19 matching lines @@
                       this.variableElement,
                       ClassElement enclosing)
       : super(name, ElementKind.FIELD, enclosing);
 
   Expression get initializer {
     throw new SpannableAssertionFailure(
         variableElement,
         'Should not access initializer of ClosureFieldElement.');
   }
 
-  bool isInstanceMember() => true;
-  bool isAssignable() => false;
+  bool get isInstanceMember => true;
+  bool get isAssignable => false;
 
   DartType computeType(Compiler compiler) {
     return variableElement.type;
   }
 
   DartType get type => variableElement.type;
 
   String toString() => "ClosureFieldElement($name)";
 
   accept(ElementVisitor visitor) => visitor.visitClosureFieldElement(this);
@@ skipping 14 matching lines @@
                       Compiler compiler,
                       this.methodElement,
                       Element enclosingElement)
       : super(name,
               enclosingElement,
               // By assigning a fresh class-id we make sure that the hashcode
               // is unique, but also emit closure classes after all other
               // classes (since the emitter sorts classes by their id).
               compiler.getNextFreeClassId(),
               STATE_DONE) {
-    ClassElement superclass = methodElement.isInstanceMember()
+    ClassElement superclass = methodElement.isInstanceMember
         ? compiler.boundClosureClass
         : compiler.closureClass;
     superclass.ensureResolved(compiler);
     supertype = superclass.thisType;
     interfaces = const Link<DartType>();
     thisType = rawType = new InterfaceType(this);
     allSupertypesAndSelf =
         superclass.allSupertypesAndSelf.extendClass(thisType);
     callType = methodElement.type;
   }
 
-  bool isClosure() => true;
+  bool get isClosure => true;
 
-  Token position() => node.getBeginToken();
+  Token get position => node.getBeginToken();
 
   Node parseNode(DiagnosticListener listener) => node;
 
   /**
    * The element for the declaration of the function expression.
    */
   final TypedElement methodElement;
 
   // A [ClosureClassElement] is nested inside a function or initializer in terms
   // of [enclosingElement], but still has to be treated as a top-level
   // element.
-  bool isTopLevel() => true;
+  bool get isTopLevel => true;
 
   get enclosingElement => methodElement;
 
   accept(ElementVisitor visitor) => visitor.visitClosureClassElement(this);
 }
 
 // TODO(ahe): These classes continuously cause problems.  We need to
 // move these classes to elements/modelx.dart or see if we can find a
 // more general solution.
 class BoxElement extends ElementX implements TypedElement {
@@ skipping 27 matching lines @@
 
 // TODO(ahe): These classes continuously cause problems.  We need to
 // move these classes to elements/modelx.dart or see if we can find a
 // more general solution.
 class ThisElement extends ElementX implements TypedElement {
   final DartType type;
 
   ThisElement(Element enclosing, this.type)
       : super('this', ElementKind.PARAMETER, enclosing);
 
-  bool isAssignable() => false;
+  bool get isAssignable => false;
 
   DartType computeType(Compiler compiler) => compiler.types.dynamicType;
 
   // Since there is no declaration corresponding to 'this', use the position of
   // the enclosing method.
-  Token position() => enclosingElement.position();
+  Token get position => enclosingElement.position;
 
   accept(ElementVisitor visitor) => visitor.visitThisElement(this);
 }
 
 // The box-element for a scope, and the captured variables that need to be
 // stored in the box.
 class ClosureScope {
   Element boxElement;
   Map<Element, Element> capturedVariableMapping;
   // If the scope is attached to a [For] contains the variables that are
@@ skipping 39 matching lines @@
 
   ClosureClassMap(this.closureElement,
                   this.closureClassElement,
                   this.callElement,
                   this.thisElement)
       : this.freeVariableMapping = new Map<Element, Element>(),
         this.capturedFieldMapping = new Map<Element, Element>(),
         this.capturingScopes = new Map<Node, ClosureScope>(),
         this.usedVariablesInTry = new Set<Element>();
 
-  bool isClosure() => closureElement != null;
+  bool get isClosure => closureElement != null;
 
   bool capturingScopesBox(Element element) {
     return capturingScopes.values.any((scope) {
       return scope.boxedLoopVariables.contains(element);
     });
   }
 
   bool isVariableBoxed(Element element) {
     Element copy = freeVariableMapping[element];
-    if (copy != null && !copy.isMember()) return true;
+    if (copy != null && !copy.isMember) return true;
     return capturingScopesBox(element);
   }
 
   void forEachCapturedVariable(void f(Element local, Element field)) {
     freeVariableMapping.forEach((variable, copy) {
       if (variable is BoxElement) return;
       f(variable, copy);
     });
     capturingScopes.values.forEach((scope) {
       scope.capturedVariableMapping.forEach(f);
@@ skipping 82 matching lines @@
       Map<Element, Element> freeVariableMapping = data.freeVariableMapping;
       // We get a copy of the keys and iterate over it, to avoid modifications
       // to the map while iterating over it.
       freeVariableMapping.keys.toList().forEach((Element fromElement) {
         assert(fromElement == freeVariableMapping[fromElement]);
         Element updatedElement = capturedVariableMapping[fromElement];
         assert(updatedElement != null);
         if (fromElement == updatedElement) {
           assert(freeVariableMapping[fromElement] == updatedElement);
           assert(Elements.isLocal(updatedElement)
-                 || updatedElement.isTypeVariable());
+                 || updatedElement.isTypeVariable);
           // The variable has not been boxed.
           fieldCaptures.add(updatedElement);
         } else {
           // A boxed element.
           freeVariableMapping[fromElement] = updatedElement;
           Element boxElement = updatedElement.enclosingElement;
           assert(boxElement is BoxElement);
           boxes.add(boxElement);
         }
       });
@@ skipping 79 matching lines @@
         if (arguments != null) {
           visit(arguments);
         }
       } else {
         visit(definition);
       }
     }
   }
 
   visitTypeAnnotation(TypeAnnotation node) {
-    Element member = currentElement.getEnclosingMember();
+    Element member = currentElement.enclosingMember;
     DartType type = elements.getType(node);
     // TODO(karlklose,johnniwinther): if the type is null, the annotation is
     // from a parameter which has been analyzed before the method has been
     // resolved and the result has been thrown away.
     if (compiler.enableTypeAssertions && type != null &&
         type.containsTypeVariables) {
-      if (insideClosure && member.isFactoryConstructor()) {
+      if (insideClosure && member.isFactoryConstructor) {
         // This is a closure in a factory constructor.  Since there is no
         // [:this:], we have to mark the type arguments as free variables to
         // capture them in the closure.
         type.forEachTypeVariable((variable) => useLocal(variable.element));
       }
-      if (member.isInstanceMember() && !member.isField()) {
+      if (member.isInstanceMember && !member.isField) {
         // In checked mode, using a type variable in a type annotation may lead
         // to a runtime type check that needs to access the type argument and
         // therefore the closure needs a this-element, if it is not in a field
         // initializer; field initatializers are evaluated in a context where
         // the type arguments are available in locals.
         registerNeedsThis();
       }
     }
   }
 
   visitIdentifier(Identifier node) {
     if (node.isThis()) {
       registerNeedsThis();
     } else {
       Element element = elements[node];
       if (element != null && element.kind == ElementKind.TYPE_VARIABLE) {
-        if (outermostElement.isConstructor()) {
+        if (outermostElement.isConstructor) {
           useLocal(element);
         } else {
           registerNeedsThis();
         }
       }
     }
     node.visitChildren(this);
   }
 
   visitSend(Send node) {
     Element element = elements[node];
     if (Elements.isLocal(element)) {
       useLocal(element);
-    } else if (element != null && element.isTypeVariable()) {
+    } else if (element != null && element.isTypeVariable) {
       TypeVariableElement variable = element;
       analyzeType(variable.type);
     } else if (node.receiver == null &&
                Elements.isInstanceSend(node, elements)) {
       registerNeedsThis();
     } else if (node.isSuperCall) {
       registerNeedsThis();
     } else if (node.isTypeTest || node.isTypeCast) {
       TypeAnnotation annotation = node.typeAnnotationFromIsCheckOrCast;
       DartType type = elements.getType(annotation);
@@ skipping 26 matching lines @@
   visitNewExpression(NewExpression node) {
     DartType type = elements.getType(node);
     analyzeType(type);
     node.visitChildren(this);
   }
 
   void analyzeTypeVariables(DartType type) {
     type.forEachTypeVariable((TypeVariableType typeVariable) {
       // Field initializers are inlined and access the type variable as
       // normal parameters.
-      if (!outermostElement.isField() &&
-          !outermostElement.isConstructor()) {
+      if (!outermostElement.isField &&
+          !outermostElement.isConstructor) {
         registerNeedsThis();
       } else {
         useLocal(typeVariable.element);
       }
     });
   }
 
   void analyzeType(DartType type) {
     // TODO(johnniwinther): Find out why this can be null.
     if (type == null) return;
-    if (outermostElement.isMember() &&
-        compiler.backend.classNeedsRti(outermostElement.getEnclosingClass())) {
-      if (outermostElement.isConstructor() ||
-          outermostElement.isField()) {
+    if (outermostElement.isMember &&
+        compiler.backend.classNeedsRti(outermostElement.enclosingClass)) {
+      if (outermostElement.isConstructor ||
+          outermostElement.isField) {
         analyzeTypeVariables(type);
-      } else if (outermostElement.isInstanceMember()) {
+      } else if (outermostElement.isInstanceMember) {
         if (type.containsTypeVariables) {
           registerNeedsThis();
         }
       }
     }
   }
 
   // If variables that are declared in the [node] scope are captured and need
   // to be boxed create a box-element and update the [capturingScopes] in the
   // current [closureData].
   // The boxed variables are updated in the [capturedVariableMapping].
   void attachCapturedScopeVariables(Node node) {
     Element box = null;
     Map<Element, Element> scopeMapping = new Map<Element, Element>();
     for (Element element in scopeVariables) {
       // No need to box non-assignable elements.
-      if (!element.isAssignable()) continue;
+      if (!element.isAssignable) continue;
       if (!mutatedVariables.contains(element)) continue;
       if (capturedVariableMapping.containsKey(element)) {
         if (box == null) {
           // TODO(floitsch): construct better box names.
           String boxName =
               namer.getClosureVariableName('box', closureFieldCounter++);
           box = new BoxElement(
               boxName, currentElement, compiler.types.dynamicType);
         }
         String elementName = element.name;
@@ skipping 64 matching lines @@
     for (Element enclosingElement = element.enclosingElement;
          enclosingElement != null &&
              (enclosingElement.kind == ElementKind.GENERATIVE_CONSTRUCTOR_BODY
               || enclosingElement.kind == ElementKind.GENERATIVE_CONSTRUCTOR
               || enclosingElement.kind == ElementKind.CLASS
               || enclosingElement.kind == ElementKind.FUNCTION
               || enclosingElement.kind == ElementKind.GETTER
               || enclosingElement.kind == ElementKind.SETTER);
          enclosingElement = enclosingElement.enclosingElement) {
       // TODO(johnniwinther): Simplify computed names.
-      if (enclosingElement.isGenerativeConstructor() ||
-          enclosingElement.isGenerativeConstructorBody() ||
-          enclosingElement.isFactoryConstructor()) {
+      if (enclosingElement.isGenerativeConstructor ||
+          enclosingElement.isGenerativeConstructorBody ||
+          enclosingElement.isFactoryConstructor) {
         parts = parts.prepend(
             Elements.reconstructConstructorName(enclosingElement));
       } else {
         String surroundingName =
             Elements.operatorNameToIdentifier(enclosingElement.name);
         parts = parts.prepend(surroundingName);
       }
       // A generative constructors's parent is the class; the class name is
       // already part of the generative constructor's name.
       if (enclosingElement.kind == ElementKind.GENERATIVE_CONSTRUCTOR) break;
     }
     StringBuffer sb = new StringBuffer();
     parts.printOn(sb, '_');
     return sb.toString();
   }
 
   ClosureClassMap globalizeClosure(FunctionExpression node,
                                    TypedElement element) {
     String closureName = computeClosureName(element);
     ClassElement globalizedElement = new ClosureClassElement(
-        node, closureName, compiler, element, element.getCompilationUnit());
+        node, closureName, compiler, element, element.compilationUnit);
     FunctionElement callElement =
         new SynthesizedCallMethodElementX(Compiler.CALL_OPERATOR_NAME,
                                           element,
                                           globalizedElement);
     ClosureContainer enclosing = element.enclosingElement;
     enclosing.nestedClosures.add(callElement);
     globalizedElement.addMember(callElement, compiler);
     // The nested function's 'this' is the same as the one for the outer
     // function. It could be [null] if we are inside a static method.
     Element thisElement = closureData.thisElement;
     return new ClosureClassMap(element, globalizedElement,
                                callElement, thisElement);
   }
 
   void visitInvokable(TypedElement element, Node node, void visitChildren()) {
     bool oldInsideClosure = insideClosure;
     Element oldFunctionElement = currentElement;
     ClosureClassMap oldClosureData = closureData;
 
     insideClosure = outermostElement != null;
     currentElement = element;
     if (insideClosure) {
       closures.add(node);
       closureData = globalizeClosure(node, element);
     } else {
       outermostElement = element;
       Element thisElement = null;
-      if (element.isInstanceMember() || element.isGenerativeConstructor()) {
+      if (element.isInstanceMember || element.isGenerativeConstructor) {
         thisElement = new ThisElement(element, compiler.types.dynamicType);
       }
       closureData = new ClosureClassMap(null, null, null, thisElement);
     }
     closureMappingCache[node] = closureData;
 
     inNewScope(node, () {
       // We have to declare the implicit 'this' parameter.
       if (!insideClosure && closureData.thisElement != null) {
         declareLocal(closureData.thisElement);
       }
       // If we are inside a named closure we have to declare ourselve. For
       // simplicity we declare the local even if the closure does not have a
       // name.
       // It will simply not be used.
       if (insideClosure) {
         declareLocal(element);
       }
 
-      if (currentElement.isFactoryConstructor() &&
+      if (currentElement.isFactoryConstructor &&
           compiler.backend.classNeedsRti(currentElement.enclosingElement)) {
         // Declare the type parameters in the scope. Generative
         // constructors just use 'this'.
         ClassElement cls = currentElement.enclosingElement;
         cls.typeVariables.forEach((TypeVariableType typeVariable) {
           declareLocal(typeVariable.element);
         });
       }
 
       DartType type = element.computeType(compiler);
@@ skipping 26 matching lines @@
         compiler.internalError(node, 'In closure analyzer.');
       }
       capturedVariableMapping[freeElement] = freeElement;
       useLocal(freeElement);
     }
   }
 
   visitFunctionExpression(FunctionExpression node) {
     Element element = elements[node];
 
-    if (element.isParameter()) {
+    if (element.isParameter) {
       // TODO(ahe): This is a hack. This method should *not* call
       // visitChildren.
       return node.name.accept(this);
     }
 
     visitInvokable(element, node, () {
       // TODO(ahe): This is problematic. The backend should not repeat
       // the work of the resolver. It is the resolver's job to create
       // parameters, etc. Other phases should only visit statements.
       if (node.parameters != null) node.parameters.accept(this);
       if (node.initializers != null) node.initializers.accept(this);
       if (node.body != null) node.body.accept(this);
     });
   }
 
   visitFunctionDeclaration(FunctionDeclaration node) {
     node.visitChildren(this);
     declareLocal(elements[node]);
   }
 
   visitTryStatement(TryStatement node) {
     // TODO(ngeoffray): implement finer grain state.
     bool oldInTryStatement = inTryStatement;
     inTryStatement = true;
     node.visitChildren(this);
     inTryStatement = oldInTryStatement;
   }
 }