Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/ssa/nodes.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 ssa;
 
 abstract class HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
@@ skipping 1374 matching lines @@
     // because we don't need to check the arity (already checked in
     // [gvnEquals]), and the receiver types may not be in sync.
     return selector.name == other.selector.name
         && selector.kind == other.selector.kind;
   }
 }
 
 class HInvokeClosure extends HInvokeDynamic {
   HInvokeClosure(Selector selector, List<HInstruction> inputs, TypeMask type)
     : super(selector, null, inputs, type) {
-    assert(selector.isClosureCall());
+    assert(selector.isClosureCall);
   }
   accept(HVisitor visitor) => visitor.visitInvokeClosure(this);
 }
 
 class HInvokeDynamicMethod extends HInvokeDynamic {
   HInvokeDynamicMethod(Selector selector,
                        List<HInstruction> inputs,
                        TypeMask type,
                        [bool isIntercepted = false])
     : super(selector, null, inputs, type, isIntercepted);
@@ skipping 92 matching lines @@
 
 class HFieldGet extends HFieldAccess {
   final bool isAssignable;
 
   HFieldGet(Element element,
             HInstruction receiver,
             TypeMask type,
             {bool isAssignable})
       : this.isAssignable = (isAssignable != null)
             ? isAssignable
-            : element.isAssignable(),
+            : element.isAssignable,
         super(element, <HInstruction>[receiver], type) {
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
     setUseGvn();
     if (this.isAssignable) {
       sideEffects.setDependsOnInstancePropertyStore();
     }
   }
 
   bool isInterceptor(Compiler compiler) {
     if (sourceElement == null) return false;
     // In case of a closure inside an interceptor class, [:this:] is
     // stored in the generated closure class, and accessed through a
     // [HFieldGet].
     JavaScriptBackend backend = compiler.backend;
     bool interceptor =
-        backend.isInterceptorClass(sourceElement.getEnclosingClass());
+        backend.isInterceptorClass(sourceElement.enclosingClass);
     return interceptor && sourceElement is ThisElement;
   }
 
   bool canThrow() => receiver.canBeNull();
 
   HInstruction getDartReceiver(Compiler compiler) => receiver;
   bool onlyThrowsNSM() => true;
   bool get isNullCheck => element == null;
 
   accept(HVisitor visitor) => visitor.visitFieldGet(this);
@@ skipping 512 matching lines @@
   accept(HVisitor visitor) => visitor.visitParameterValue(this);
 }
 
 class HThis extends HParameterValue {
   HThis(Element element, TypeMask type) : super(element, type);
   toString() => 'this';
   accept(HVisitor visitor) => visitor.visitThis(this);
   bool isCodeMotionInvariant() => true;
   bool isInterceptor(Compiler compiler) {
     JavaScriptBackend backend = compiler.backend;
-    return backend.isInterceptorClass(sourceElement.getEnclosingClass());
+    return backend.isInterceptorClass(sourceElement.enclosingClass);
   }
 }
 
 class HPhi extends HInstruction {
   static const IS_NOT_LOGICAL_OPERATOR = 0;
   static const IS_AND = 1;
   static const IS_OR = 2;
 
   int logicalOperatorType = IS_NOT_LOGICAL_OPERATOR;
 
@@ skipping 107 matching lines @@
   accept(HVisitor visitor) => visitor.visitThrow(this);
 }
 
 class HStatic extends HInstruction {
   final Element element;
   HStatic(this.element, type) : super(<HInstruction>[], type) {
     assert(element != null);
     assert(invariant(this, element.isDeclaration));
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
-    if (element.isAssignable()) {
+    if (element.isAssignable) {
       sideEffects.setDependsOnStaticPropertyStore();
     }
     setUseGvn();
   }
   toString() => 'static ${element.name}';
   accept(HVisitor visitor) => visitor.visitStatic(this);
 
   int gvnHashCode() => super.gvnHashCode() ^ element.hashCode;
   int typeCode() => HInstruction.STATIC_TYPECODE;
   bool typeEquals(other) => other is HStatic;
   bool dataEquals(HStatic other) => element == other.element;
-  bool isCodeMotionInvariant() => !element.isAssignable();
+  bool isCodeMotionInvariant() => !element.isAssignable;
 }
 
 class HInterceptor extends HInstruction {
   // This field should originally be null to allow GVN'ing all
   // [HInterceptor] on the same input.
   Set<ClassElement> interceptedClasses;
   HInterceptor(HInstruction receiver, TypeMask type)
       : super(<HInstruction>[receiver], type) {
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
@@ skipping 817 matching lines @@
 class HDynamicType extends HRuntimeType {
   HDynamicType(DynamicType dartType, TypeMask instructionType)
       : super(const <HInstruction>[], dartType, instructionType);
 
   accept(HVisitor visitor) => visitor.visitDynamicType(this);
 
   int typeCode() => HInstruction.DYNAMIC_TYPE_TYPECODE;
 
   bool typeEquals(HInstruction other) => other is HDynamicType;
 }