Use computed field types to recompile methods containing binary

lib/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.
 
 interface OptimizationPhase {
   String get name();
   void visitGraph(HGraph graph);
 }
 
 class SsaOptimizerTask extends CompilerTask {
@@ skipping 1236 matching lines @@
             }
             break;
           default:
             assert(false);
             break;
         }
       }
     }
   }
 
+  HInstruction visitBinaryArithmetic(HBinaryArithmetic node) {
+    // Determine if one of the operands is an HFieldGet.
+    HFieldGet field;
+    HInstruction other;

[Søren Gjesse, 2012/07/06 08:38:43]

Maybe we can also do like this field/other stuff in the visitEquals above
(currently it requires the rhs to be a constant).

[Mads Ager (google), 2012/07/06 08:42:18]

Yes, let me do that as well. I will pull the conflicting check in equals to
before the switch as well.

+    if (node.left is HFieldGet) {
+      field = node.left;
+      other = node.right;
+    } else if (node.right is HFieldGet) {
+      field = node.right;
+      other = node.left;
+    }
+    // Check that the other operand is a number and that we have type
+    // information for the field get.
+    if (other != null &&
+        other is HConstant &&
+        other.isNumber() &&
+        field.element != null &&
+        field.element.enclosingElement.isClass()) {
+      // If we have type information for the field and it contains
+      // NUMBER, we mark for recompilation.
+      Element fieldElement = field.element;
+      HType fieldSettersType = backend.fieldSettersTypeSoFar(fieldElement);
+      HType initializersType = backend.typeFromInitializersSoFar(fieldElement);
+      HType fieldType = fieldSettersType.union(initializersType);
+      HType type = HType.NUMBER.union(fieldType);
+      if (!type.isConflicting()) {
+        switch (compiler.phase) {
+          case Compiler.PHASE_COMPILING:
+            compiler.enqueuer.codegen.registerRecompilationCandidate(
+                work.element);
+            break;
+          case Compiler.PHASE_RECOMPILING:
+            if (compiler.codegenWorld.hasInvokedSetter(fieldElement,
+                                                       compiler)) {
+              // If there are invoked setters we don't know for sure
+              // that the field will hold a value of the calculated
+              // type, but the fact that the class itself sticks to
+              // this type for the field is still a strong signal
+              // indicating the expected type of the field.
+              field.propagatedType = type;
+              graph.highTypeLikelyhood = true;
+            } else {
+              // If there are no invoked setters we know the type of
+              // this field for sure.
+              field.guaranteedType = type;
+              print(node);
+            }
+            break;
+          default:
+            assert(false);
+            break;
+        }
+      }
+    }
+  }
 }