Start propagating non-primitive types in the backend, and fold instructions that know about the typ…

lib/compiler/implementation/ssa/optimize.dart

 // Copyright (c) 2011, 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.
 
 interface OptimizationPhase {
   String get name();
   void visitGraph(HGraph graph);
 }
 
 class SsaOptimizerTask extends CompilerTask {
@@ skipping 129 matching lines @@
     if (operand is HConstant) {
       UnaryOperation operation = node.operation;
       HConstant receiver = operand;
       Constant folded = operation.fold(receiver.constant);
       if (folded !== null) return graph.addConstant(folded);
     }
     return node;
   }
 
   HInstruction visitInvokeInterceptor(HInvokeInterceptor node) {
-    if (node.name == const SourceString('length') &&
-        node.inputs[1].isConstantString()) {
-      HConstant input = node.inputs[1];
-      StringConstant constant = input.constant;
-      DartString string = constant.value;
-      return graph.addConstantInt(string.length);
+    if (node.isLengthGetter()) {
+      HInstruction input = node.inputs[1];
+      if (input.isConstantString()) {
+        StringConstant constant = input.constant;
+        return graph.addConstantInt(constant.length);
+      } else if (input.isConstantList()) {
+        ListConstant constant = input.constant;
+        return graph.addConstantInt(constant.length);
+      } else if (input.isConstantMap()) {
+        MapConstant constant = input.constant;
+        return graph.addConstantInt(constant.length);
+      }
+    }
+    return node;
+  }
+
+  HInstruction visitInvokeDynamic(HInvokeDynamic node) {
+    HType receiverType = node.receiver.propagatedType;
+    if (receiverType.isNonPrimitive()) {
+      HNonPrimitiveType type = receiverType;
+      Element element = type.lookupMember(node.name);
+      // TODO(ngeoffray): Also fold if it's a getter or variable.
+      if (element != null && element.isFunction()) {
+        FunctionElement method = element;
+        FunctionParameters parameters = method.computeParameters(compiler);
+        if (node.selector.applies(parameters)) {

[floitsch, 2012/04/18 19:18:48]

Even if the function doesn't apply we should set the node.element.
If it doesn't apply we should probably emit a warning.

[ngeoffray, 2012/04/19 08:09:33]

Why? There is no need to compile the function since we know for sure it won't be
called.
Not at this level. The warning can only be emitted by the typechecker. If it
doesn't apply, we should generate 'throw new NoSuchMethodException(...)'.

+          if (parameters.optionalParameterCount == 0) {
+            node.element = element;
+          }
+          // TODO(ngeoffray): If the method has optional parameters,
+          // we should pass the default values here.
+        }
+      }
+    }
+    return node;
+  }
+
+  HInstruction visitIndex(HIndex node) {

[kasperl, 2012/04/19 06:46:19]

This looks like this could be refactored with a helper and used for visitIndex,
visitIndexAssign, and visitInvokeBinary.

[ngeoffray, 2012/04/19 08:09:33]

Done.

+    if (node.receiver.isNonPrimitive()) {
+      return new HInvokeDynamicMethod(
+          node.selector,
+          Elements.constructOperatorName(
+              const SourceString('operator'),
+              const SourceString('[]')),
+          node.inputs.getRange(1, node.inputs.length - 1));
+    }
+    return node;
+  }
+
+  HInstruction visitIndexAssign(HIndexAssign node) {
+    if (node.receiver.isNonPrimitive()) {
+      return new HInvokeDynamicMethod(
+          node.selector,
+          Elements.constructOperatorName(
+              const SourceString('operator'),
+              const SourceString('[]=')),
+          node.inputs.getRange(1, node.inputs.length - 1));
     }
     return node;
   }
 
   HInstruction visitInvokeBinary(HInvokeBinary node) {
     HInstruction left = node.left;
     HInstruction right = node.right;
     if (left is HConstant && right is HConstant) {
       BinaryOperation operation = node.operation;
       HConstant op1 = left;
       HConstant op2 = right;
       Constant folded = operation.fold(op1.constant, op2.constant);
       if (folded !== null) return graph.addConstant(folded);
     }
+
+    if (left.isNonPrimitive() && node.operation.isUserDefinable()) {
+      return new HInvokeDynamicMethod(
+          node.selector,
+          Elements.constructOperatorName(
+              const SourceString('operator'),
+              node.operation.name),
+          node.inputs.getRange(1, node.inputs.length - 1));
+    }
     return node;
   }
 
   HInstruction visitEquals(HEquals node) {
     HInstruction left = node.left;
     HInstruction right = node.right;
     if (!left.isConstant() && right.isConstantNull()) {
       // TODO(floitsch): cache interceptors.
       HStatic target = new HStatic(
           compiler.builder.interceptors.getEqualsNullInterceptor());
       node.block.addBefore(node,target);
       return new HEquals(target, node.left, node.right);
     }
+
+    if (left.isNonPrimitive()) {

[kasperl, 2012/04/19 06:46:19]

Add a comment here that explains what this does. Essentially, you're optimizing
equality checks where the left-hand side is guaranteed not to be a proper Dart
object with no user-defined equals method.

Should this check come before line 236 so we get faster null checks too?

+      HNonPrimitiveType type = left.propagatedType;
+      Element element = type.lookupMember(Namer.OPERATOR_EQUALS);
+      if (element === null) {
+        // TODO(floitsch): cache interceptors.
+        HStatic target = new HStatic(
+            compiler.builder.interceptors.getTripleEqualsInterceptor());
+        return new HIdentity(target, left, right);
+      }
+    }
+
     // All other cases are dealt with by the [visitInvokeBinary].
     return visitInvokeBinary(node);
   }
 
   HInstruction visitTypeGuard(HTypeGuard node) {
     HInstruction value = node.guarded;
     HType combinedType = value.propagatedType.combine(node.propagatedType);
     return (combinedType == value.propagatedType) ? value : node;
   }
 
@@ skipping 520 matching lines @@
         }
       }
       if (!canBeMoved) continue;
 
       // This is safe because we are running after GVN.
       // TODO(ngeoffray): ensure GVN has been run.
       set_.add(current);
     }
   }
 }