Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/ssa/optimize.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 OptimizationPhase {
   String get name;
   void visitGraph(HGraph graph);
 }
@@ skipping 247 matching lines @@
     }
 
     // Try converting the instruction to a builtin instruction.
     HInstruction instruction =
         node.specializer.tryConvertToBuiltin(node, compiler);
     if (instruction != null) return instruction;
 
     Selector selector = node.selector;
     HInstruction input = node.inputs[1];
 
-    if (selector.isCall() || selector.isOperator()) {
+    if (selector.isCall || selector.isOperator) {
       Element target;
       if (input.isExtendableArray(compiler)) {
         if (selector.applies(backend.jsArrayRemoveLast, compiler)) {
           target = backend.jsArrayRemoveLast;
         } else if (selector.applies(backend.jsArrayAdd, compiler)) {
           // The codegen special cases array calls, but does not
           // inline argument type checks.
           if (!compiler.enableTypeAssertions) {
             target = backend.jsArrayAdd;
           }
@@ skipping 26 matching lines @@
         // HInvokeDynamicMethod and not create a HForeign because
         // HForeign is too opaque for the SsaCheckInserter (that adds a
         // bounds check on removeLast). Once we start inlining, the
         // bounds check will become explicit, so we won't need this
         // optimization.
         HInvokeDynamicMethod result = new HInvokeDynamicMethod(
             node.selector, node.inputs.sublist(1), node.instructionType);
         result.element = target;
         return result;
       }
-    } else if (selector.isGetter()) {
+    } else if (selector.isGetter) {
       if (selector.asUntyped.applies(backend.jsIndexableLength, compiler)) {
         HInstruction optimized = tryOptimizeLengthInterceptedGetter(node);
         if (optimized != null) return optimized;
       }
     }
 
     return node;
   }
 
   HInstruction visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
     if (node.isInterceptedCall) {
       HInstruction folded = handleInterceptedCall(node);
       if (folded != node) return folded;
     }
 
     TypeMask receiverType = node.getDartReceiver(compiler).instructionType;
     Selector selector = new TypedSelector(receiverType, node.selector);
     Element element = compiler.world.locateSingleElement(selector);
     // TODO(ngeoffray): Also fold if it's a getter or variable.
     if (element != null
-        && element.isFunction()
+        && element.isFunction
         // If we found out that the only target is a [:noSuchMethod:],
         // we just ignore it.
         && element.name == selector.name) {
       FunctionElement method = element;
 
-      if (method.isNative()) {
+      if (method.isNative) {
         HInstruction folded = tryInlineNativeMethod(node, method);
         if (folded != null) return folded;
       } else {
         // TODO(ngeoffray): If the method has optional parameters,
         // we should pass the default values.
         FunctionSignature parameters = method.functionSignature;
         if (parameters.optionalParameterCount == 0
             || parameters.parameterCount == node.selector.argumentCount) {
           node.element = element;
         }
@@ skipping 217 matching lines @@
     simplifyCondition(node.elseBlock, condition, isNegated);
     return node;
   }
 
   HInstruction visitIs(HIs node) {
     DartType type = node.typeExpression;
     Element element = type.element;
 
     if (!node.isRawCheck) {
       return node;
-    } else if (element.isTypedef()) {
+    } else if (element.isTypedef) {
       return node;
     } else if (element == compiler.functionClass) {
       return node;
     }
 
     if (element == compiler.objectClass || type.treatAsDynamic) {
       return graph.addConstantBool(true, compiler);
     }
 
     HInstruction expression = node.expression;
@@ skipping 145 matching lines @@
     Element field = findConcreteFieldForDynamicAccess(receiver, node.selector);
     if (field == null) return node;
     return directFieldGet(receiver, field);
   }
 
   HInstruction directFieldGet(HInstruction receiver, Element field) {
     ast.Modifiers modifiers = field.modifiers;
     bool isAssignable = !compiler.world.fieldNeverChanges(field);
 
     TypeMask type;
-    if (field.getEnclosingClass().isNative()) {
+    if (field.enclosingClass.isNative) {
       type = TypeMaskFactory.fromNativeBehavior(
           native.NativeBehavior.ofFieldLoad(field, compiler),
           compiler);
     } else {
       type = TypeMaskFactory.inferredTypeForElement(field, compiler);
     }
 
     return new HFieldGet(
         field, receiver, type, isAssignable: isAssignable);
   }
 
   HInstruction visitInvokeDynamicSetter(HInvokeDynamicSetter node) {
     if (node.isInterceptedCall) {
       HInstruction folded = handleInterceptedCall(node);
       if (folded != node) return folded;
     }
 
     HInstruction receiver = node.getDartReceiver(compiler);
     VariableElement field =
         findConcreteFieldForDynamicAccess(receiver, node.selector);
-    if (field == null || !field.isAssignable()) return node;
+    if (field == null || !field.isAssignable) return node;
     // Use [:node.inputs.last:] in case the call follows the
     // interceptor calling convention, but is not a call on an
     // interceptor.
     HInstruction value = node.inputs.last;
     if (compiler.enableTypeAssertions) {
       DartType type = field.type;
       if (!type.treatAsRaw || type.kind == TypeKind.TYPE_VARIABLE) {
         // We cannot generate the correct type representation here, so don't
         // inline this access.
         return node;
@@ skipping 819 matching lines @@
     dominatedUsers.forEach((HInstruction user) {
       user.changeUse(input, newInput);
     });
   }
 
   void visitIs(HIs instruction) {
     DartType type = instruction.typeExpression;
     Element element = type.element;
     if (!instruction.isRawCheck) {
       return;
-    } else if (element.isTypedef()) {
+    } else if (element.isTypedef) {
       return;
     }
 
     List<HInstruction> ifUsers = <HInstruction>[];
     List<HInstruction> notIfUsers = <HInstruction>[];
 
     collectIfUsers(instruction, ifUsers, notIfUsers);
 
     if (ifUsers.isEmpty && notIfUsers.isEmpty) return;
 
@@ skipping 286 matching lines @@
     nonEscapingReceivers.add(instruction);
   }
 
   /**
    * Sets `receiver.element` to contain [value]. Kills all potential
    * places that may be affected by this update.
    */
   void registerFieldValueUpdate(Element element,
                                 HInstruction receiver,
                                 HInstruction value) {
-    if (element.isNative()) return; // TODO(14955): Remove this restriction?
+    if (element.isNative) return; // TODO(14955): Remove this restriction?
     // [value] is being set in some place in memory, we remove it from
     // the non-escaping set.
     nonEscapingReceivers.remove(value);
     Map<HInstruction, HInstruction> map = fieldValues.putIfAbsent(
         element, () => <HInstruction, HInstruction> {});
     map.forEach((key, value) {
       if (mayAlias(receiver, key)) map[key] = null;
     });
     map[receiver] = value;
   }
 
   /**
    * Registers that `receiver.element` is now [value].
    */
   void registerFieldValue(Element element,
                           HInstruction receiver,
                           HInstruction value) {
-    if (element.isNative()) return; // TODO(14955): Remove this restriction?
+    if (element.isNative) return; // TODO(14955): Remove this restriction?
     Map<HInstruction, HInstruction> map = fieldValues.putIfAbsent(
         element, () => <HInstruction, HInstruction> {});
     map[receiver] = value;
   }
 
   /**
    * Returns the value stored in `receiver.element`. Returns null if
    * we don't know.
    */
   HInstruction lookupFieldValue(Element element, HInstruction receiver) {
@@ skipping 173 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }