Turn getters and setters that we know are not intercepted into regular getter and setter calls.

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 127 matching lines @@
   void visitGraph(HGraph visitee) {
     graph = visitee;
     visitDominatorTree(visitee);
   }
 
   visitBasicBlock(HBasicBlock block) {
     HInstruction instruction = block.first;
     while (instruction != null) {
       HInstruction next = instruction.next;
       HInstruction replacement = instruction.accept(this);
-      if (!identical(replacement, instruction)) {
-        if (!replacement.isInBasicBlock()) {
-          // The constant folding can return an instruction that is already
-          // part of the graph (like an input), so we only add the replacement
-          // if necessary.
-          block.addAfter(instruction, replacement);
-        }
+      if (replacement != instruction) {
         block.rewrite(instruction, replacement);
-        block.remove(instruction);
 
         // If we can replace [instruction] with [replacement], then
         // [replacement]'s type can be narrowed.
         types[replacement] =
             types[replacement].intersection(types[instruction], compiler);
 
         // If the replacement instruction does not know its
         // source element, use the source element of the
         // instruction.
         if (replacement.sourceElement == null) {
           replacement.sourceElement = instruction.sourceElement;
         }
         if (replacement.sourcePosition == null) {
           replacement.sourcePosition = instruction.sourcePosition;
         }
+        if (!replacement.isInBasicBlock()) {
+          // The constant folding can return an instruction that is already
+          // part of the graph (like an input), so we only add the replacement
+          // if necessary.
+          block.addAfter(instruction, replacement);
+          // Visit the replacement as the next instruction in case it
+          // can also be constant folded away.
+          next = replacement;
+        }
+        block.remove(instruction);
       }
       instruction = next;
     }
   }
 
   HInstruction visitInstruction(HInstruction node) {
     return node;
   }
 
   HInstruction visitBoolify(HBoolify node) {
@@ skipping 31 matching lines @@
 
   HInstruction foldUnary(UnaryOperation operation, HInstruction operand) {
     if (operand is HConstant) {
       HConstant receiver = operand;
       Constant folded = operation.fold(receiver.constant);
       if (folded != null) return graph.addConstant(folded);
     }
     return null;
   }
 
+  HInstruction optimizeLengthInterceptedGetter(HInvokeDynamic node) {
+    HInstruction actualReceiver = node.inputs[1];
+    if (actualReceiver.isIndexablePrimitive(types)) {
+      if (actualReceiver.isConstantString()) {
+        HConstant constantInput = actualReceiver;
+        StringConstant constant = constantInput.constant;
+        return graph.addConstantInt(constant.length, constantSystem);
+      } else if (actualReceiver.isConstantList()) {
+        HConstant constantInput = actualReceiver;
+        ListConstant constant = constantInput.constant;
+        return graph.addConstantInt(constant.length, constantSystem);
+      }
+      Element element;
+      bool isAssignable;
+      if (actualReceiver.isString(types)) {
+        element = backend.jsStringLength;
+        isAssignable = false;
+      } else {
+        element = backend.jsArrayLength;
+        isAssignable = !actualReceiver.isFixedArray(types);
+      }
+      HFieldGet result = new HFieldGet(
+          element, actualReceiver, isAssignable: isAssignable);
+      result.guaranteedType = HType.INTEGER;
+      types[result] = HType.INTEGER;
+      return result;
+    } else if (actualReceiver.isConstantMap()) {
+      HConstant constantInput = actualReceiver;
+      MapConstant constant = constantInput.constant;
+      return graph.addConstantInt(constant.length, constantSystem);
+    }
+    return node;
+  }
+
   HInstruction handleInterceptorCall(HInvokeDynamic node) {
     // We only optimize for intercepted method calls in this method.
-    if (node.selector.isGetter() || node.selector.isSetter()) return node;
-
-    HInstruction input = node.inputs[1];
-    if (input.isString(types)
-        && node.selector.name == const SourceString('toString')) {
-      return node.inputs[1];
-    }
+    Selector selector = node.selector;
 
     // Try constant folding the instruction.
     Operation operation = node.specializer.operation(constantSystem);
     if (operation != null) {
       HInstruction instruction = node.inputs.length == 2
           ? foldUnary(operation, node.inputs[1])
           : foldBinary(operation, node.inputs[1], node.inputs[2]);
       if (instruction != null) return instruction;
     }
 
     // Try converting the instruction to a builtin instruction.
     HInstruction instruction =
         node.specializer.tryConvertToBuiltin(node, types);
     if (instruction != null) return instruction;
 
     // Check if this call does not need to be intercepted.
+    HInstruction input = node.inputs[1];
     HType type = types[input];
     var interceptor = node.inputs[0];
     if (interceptor is !HThis && !type.canBePrimitive()) {
       // If the type can be null, and the intercepted method can be in
       // the object class, keep the interceptor.
       if (type.canBeNull()) {
         Set<ClassElement> interceptedClasses;
         if (interceptor is HInterceptor) {
           interceptedClasses = interceptor.interceptedClasses;
         } else if (node is HOneShotInterceptor) {
           var oneShotInterceptor = node;
           interceptedClasses = oneShotInterceptor.interceptedClasses;
         }
         if (interceptedClasses.contains(compiler.objectClass)) return node;
       }
-      // Change the call to a regular invoke dynamic call.
-      return new HInvokeDynamicMethod(
-          node.selector, node.inputs.getRange(1, node.inputs.length - 1));
+      if (selector.isGetter()) {
+        // Change the call to a regular invoke dynamic call.
+        return new HInvokeDynamicGetter(selector, null, input, false);
+      } else if (selector.isSetter()) {
+        return new HInvokeDynamicSetter(
+            selector, null, input, node.inputs[2], false);
+      } else {
+        // Change the call to a regular invoke dynamic call.
+        return new HInvokeDynamicMethod(
+            selector, node.inputs.getRange(1, node.inputs.length - 1));
+      }
     }
 
-    Selector selector = node.selector;
     SourceString selectorName = selector.name;
-    Element target;
-    if (input.isExtendableArray(types)) {
-      if (selectorName == backend.jsArrayRemoveLast.name
-          && selector.argumentCount == 0) {
-        target = backend.jsArrayRemoveLast;
-      } else if (selectorName == backend.jsArrayAdd.name
-                 && selector.argumentCount == 1
-                 && selector.namedArgumentCount == 0
-                 && !compiler.enableTypeAssertions) {
-        target = backend.jsArrayAdd;
+    if (selector.isCall()) {
+      Element target;
+      if (input.isExtendableArray(types)) {
+        if (selectorName == backend.jsArrayRemoveLast.name
+            && selector.argumentCount == 0) {
+          target = backend.jsArrayRemoveLast;
+        } else if (selectorName == backend.jsArrayAdd.name

[kasperl, 2013/02/01 16:29:51]

Maybe we could store some object in the backend that makes it easier to figure
out if a certain selector and input types match a backend helper? All the
comparisons here kind of clutter this method.

[ngeoffray, 2013/02/04 13:31:30]

Actually, we're kind of doing a Selector.applies check, but Selector.applies
does not check the name. I have updated Selector.applies to check the names, and
updated the hot call sites of Selector.applies to Selector.appliesUnnamed.

+                   && selector.argumentCount == 1
+                   && selector.namedArgumentCount == 0
+                   && !compiler.enableTypeAssertions) {
+          target = backend.jsArrayAdd;
+        }
+      } else if (input.isString(types)) {
+        if (selectorName == backend.jsStringSplit.name
+            && selector.argumentCount == 1
+            && selector.namedArgumentCount == 0
+            && node.inputs[2].isString(types)) {
+          target = backend.jsStringSplit;
+        } else if (selectorName == backend.jsStringConcat.name
+                   && selector.argumentCount == 1
+                   && selector.namedArgumentCount == 0
+                   && node.inputs[2].isString(types)) {
+          target = backend.jsStringConcat;
+        } else if (selectorName == const SourceString('toString')
+                   && selector.argumentCount == 0) {
+          return node.inputs[1];
+        }
       }
-    } else if (input.isString(types)) {
-      if (selectorName == backend.jsStringSplit.name
-          && selector.argumentCount == 1
-          && selector.namedArgumentCount == 0
-          && node.inputs[2].isString(types)) {
-        target = backend.jsStringSplit;
-      } else if (selectorName == backend.jsStringConcat.name
-                 && selector.argumentCount == 1
-                 && selector.namedArgumentCount == 0
-                 && node.inputs[2].isString(types)) {
-        target = backend.jsStringConcat;
+      if (target != null) {
+        HInvokeDynamicMethod result = new HInvokeDynamicMethod(
+            node.selector, node.inputs.getRange(1, node.inputs.length - 1));
+        result.element = target;
+        return result;
       }
-    }
-    if (target != null) {
-      HInvokeDynamicMethod result = new HInvokeDynamicMethod(
-          node.selector, node.inputs.getRange(1, node.inputs.length - 1));
-      result.element = target;
-      return result;
+    } else if (selector.isGetter()
+               && selectorName == const SourceString("length")) {
+      return optimizeLengthInterceptedGetter(node);
     }
     return node;
   }
 
   bool isFixedSizeListConstructor(HInvokeStatic node) {
     Element element = node.target.element;
     if (backend.fixedLengthListConstructor == null) {
       backend.fixedLengthListConstructor =
         compiler.listClass.lookupConstructor(
             new Selector.callConstructor(const SourceString("fixedLength"),
@@ skipping 29 matching lines @@
             node.element = element;
           }
           // TODO(ngeoffray): If the method has optional parameters,
           // we should pass the default values here.
         }
       }
     }
     return node;
   }
 
-  /**
-   * Turns a primitive instruction (e.g. [HIndex], [HAdd], ...) into a
-   * [HInvokeDynamic] because we know the receiver is not a JS
-   * primitive object.
-   */
-  HInstruction fromPrimitiveInstructionToDynamicInvocation(HInstruction node,
-                                                           Selector selector) {
-    HBoundedType type = types[node.inputs[1]];
-    HInvokeDynamicMethod result = new HInvokeDynamicMethod(
-        selector,
-        node.inputs.getRange(1, node.inputs.length - 1));
-    if (type.isExact()) {
-      HBoundedType concrete = type;
-      // TODO(johnniwinther): Add lookup by selector to HBoundedType.
-      Element element = concrete.lookupMember(selector.name);
-      if (selector.applies(element, compiler)) {
-        // The target is only valid if the selector applies.
-        result.element = element;
-      }
-    }
-    return result;
-  }
-
   HInstruction visitIntegerCheck(HIntegerCheck node) {
     HInstruction value = node.value;
     if (value.isInteger(types)) return value;
     if (value.isConstant()) {
       HConstant constantInstruction = value;
       assert(!constantInstruction.constant.isInt());
       if (!constantSystem.isInt(constantInstruction.constant)) {
         // -0.0 is a double but will pass the runtime integer check.
         node.alwaysFalse = true;
       }
@@ skipping 196 matching lines @@
         // [:new List.fixedLength(int):].
         HInvokeStatic call = node.receiver;
         if (isFixedSizeListConstructor(call)) {
           return call.inputs[1];
         }
       }
     }
     return node;
   }
 
-  HInstruction optimizeLengthInterceptedCall(HInvokeDynamicGetter node) {
-    HInstruction actualReceiver = node.inputs[1];
-    if (actualReceiver.isIndexablePrimitive(types)) {
-      if (actualReceiver.isConstantString()) {
-        HConstant constantInput = actualReceiver;
-        StringConstant constant = constantInput.constant;
-        return graph.addConstantInt(constant.length, constantSystem);
-      } else if (actualReceiver.isConstantList()) {
-        HConstant constantInput = actualReceiver;
-        ListConstant constant = constantInput.constant;
-        return graph.addConstantInt(constant.length, constantSystem);
-      }
-      Element element;
-      bool isAssignable;
-      if (actualReceiver.isString(types)) {
-        element = backend.jsStringLength;
-        isAssignable = false;
-      } else {
-        element = backend.jsArrayLength;
-        isAssignable = !actualReceiver.isFixedArray(types);
-      }
-      HFieldGet result = new HFieldGet(
-          element, actualReceiver, isAssignable: isAssignable);
-      result.guaranteedType = HType.INTEGER;
-      types[result] = HType.INTEGER;
-      return result;
-    } else if (actualReceiver.isConstantMap()) {
-      HConstant constantInput = actualReceiver;
-      MapConstant constant = constantInput.constant;
-      return graph.addConstantInt(constant.length, constantSystem);
-    }
-    return node;
-  }
-
   HInstruction visitInvokeDynamicGetter(HInvokeDynamicGetter node) {
-    if (node.selector.name == const SourceString('length')
-        && node.isInterceptorCall) {
-      return optimizeLengthInterceptedCall(node);
-    }
+    if (node.isInterceptorCall) return handleInterceptorCall(node);
 
     Element field =
         findConcreteFieldForDynamicAccess(node.receiver, node.selector);
     if (field == null) return node;
 
     Modifiers modifiers = field.modifiers;
     bool isFinalOrConst = modifiers.isFinal() || modifiers.isConst();
     if (!compiler.resolverWorld.hasInvokedSetter(field, compiler)) {
       // If no setter is ever used for this field it is only initialized in the
       // initializer list.
       isFinalOrConst = true;
     }
     HFieldGet result = new HFieldGet(
         field, node.inputs[0], isAssignable: !isFinalOrConst);
     HType type = backend.optimisticFieldType(field);
     if (type != null) {
       result.guaranteedType = type;
       backend.registerFieldTypesOptimization(
           work.element, field, result.guaranteedType);
     }
     return result;
   }
 
   HInstruction visitInvokeDynamicSetter(HInvokeDynamicSetter node) {
+    if (node.isInterceptorCall) return handleInterceptorCall(node);
+
     Element field =
         findConcreteFieldForDynamicAccess(node.receiver, node.selector);
     if (field == null || !field.isAssignable()) return node;
     HInstruction value = node.inputs[1];
     if (compiler.enableTypeAssertions) {
       HInstruction other = value.convertType(
           compiler,
           field.computeType(compiler),
           HTypeConversion.CHECKED_MODE_CHECK);
       if (other != value) {
@@ skipping 874 matching lines @@
     HBasicBlock block = user.block;
     block.addAfter(user, interceptor);
     block.rewrite(user, interceptor);
     block.remove(user);
 
     // The interceptor will be removed in the dead code elimination
     // phase. Note that removing it here would not work because of how
     // the [visitBasicBlock] is implemented.
   }
 }