Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/inferrer/inferrer_visitor.dart

 // Copyright (c) 2013, 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 inferrer_visitor;
 
 import '../dart2jslib.dart' hide Selector, TypedSelector;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../tree/tree.dart';
@@ skipping 594 matching lines @@
   LocalsHandler<T> locals;
   final List<T> cascadeReceiverStack = new List<T>();
 
   bool accumulateIsChecks = false;
   bool conditionIsSimple = false;
   List<Send> isChecks;
   int loopLevel = 0;
 
   bool get inLoop => loopLevel > 0;
   bool get isThisExposed {
-    return analyzedElement.isGenerativeConstructor()
+    return analyzedElement.isGenerativeConstructor
         ? locals.fieldScope.isThisExposed
         : true;
   }
   void set isThisExposed(value) {
-    if (analyzedElement.isGenerativeConstructor()) {
+    if (analyzedElement.isGenerativeConstructor) {
       locals.fieldScope.isThisExposed = value;
     }
   }
 
   InferrerVisitor(Element analyzedElement,
                   this.inferrer,
                   this.types,
                   Compiler compiler,
                   [LocalsHandler<T> handler])
     : this.analyzedElement = analyzedElement,
       this.locals = handler,
       super(compiler.enqueuer.resolution.getCachedElements(analyzedElement),
             compiler) {
     if (handler != null) return;
     Node node = analyzedElement.parseNode(compiler);
     FieldInitializationScope<T> fieldScope =
-        analyzedElement.isGenerativeConstructor()
+        analyzedElement.isGenerativeConstructor
             ? new FieldInitializationScope<T>(types)
             : null;
     locals = new LocalsHandler<T>(inferrer, types, compiler, node, fieldScope);
   }
 
   T visitSendSet(SendSet node);
 
   T visitSuperSend(Send node);
 
   T visitStaticSend(Send node);
@@ skipping 63 matching lines @@
   T visitLiteralInt(LiteralInt node) {
     ConstantSystem constantSystem = compiler.backend.constantSystem;
     // The JavaScript backend may turn this literal into a double at
     // runtime.
     return types.getConcreteTypeFor(
         constantSystem.createInt(node.value).computeMask(compiler));
   }
 
   T visitLiteralList(LiteralList node) {
     node.visitChildren(this);
-    return node.isConst() ? types.constListType : types.growableListType;
+    return node.isConst ? types.constListType : types.growableListType;
   }
 
   T visitLiteralMap(LiteralMap node) {
     node.visitChildren(this);
-    return node.isConst() ? types.constMapType : types.mapType;
+    return node.isConst ? types.constMapType : types.mapType;
   }
 
   T visitLiteralNull(LiteralNull node) {
     return types.nullType;
   }
 
   T visitLiteralSymbol(LiteralSymbol node) {
     // TODO(kasperl): We should be able to tell that the type of a literal
     // symbol is always a non-null exact symbol implementation -- not just
     // any non-null subtype of the symbol interface.
     return types.nonNullSubtype(compiler.symbolClass);
   }
 
   T visitTypeReferenceSend(Send node) {
     return elements.isTypeLiteral(node) ? types.typeType : types.dynamicType;
   }
 
   bool isThisOrSuper(Node node) => node.isThis() || node.isSuper();
 
   Element get outermostElement {
-    return
-        analyzedElement.getOutermostEnclosingMemberOrTopLevel().implementation;
+    return analyzedElement.outermostEnclosingMemberOrTopLevel.implementation;
   }
 
   T _thisType;
   T get thisType {
     if (_thisType != null) return _thisType;
-    ClassElement cls = outermostElement.getEnclosingClass();
+    ClassElement cls = outermostElement.enclosingClass;
     if (compiler.world.isUsedAsMixin(cls)) {
       return _thisType = types.nonNullSubtype(cls);
     } else if (compiler.world.hasAnySubclass(cls)) {
       return _thisType = types.nonNullSubclass(cls);
     } else {
       return _thisType = types.nonNullExact(cls);
     }
   }
 
   T _superType;
   T get superType {
     if (_superType != null) return _superType;
     return _superType = types.nonNullExact(
-        outermostElement.getEnclosingClass().superclass);
+        outermostElement.enclosingClass.superclass);
   }
 
   T visitIdentifier(Identifier node) {
     if (node.isThis()) {
       return thisType;
     } else if (node.isSuper()) {
       return superType;
     } else {
       Element element = elements[node];
       if (Elements.isLocal(element)) {
@@ skipping 435 matching lines @@
     return type;
   }
 
   T visitCascade(Cascade node) {
     // Ignore the result of the cascade send and return the type of the cascade
     // receiver.
     visit(node.expression);
     return cascadeReceiverStack.removeLast();
   }
 }