Refactor type propagation.

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 36 matching lines @@
       return !work.guards.isEmpty();
     });
   }
 
   void prepareForSpeculativeOptimizations(WorkItem work, HGraph graph) {
     measure(() {
       // In order to generate correct code for the bailout version, we did not
       // propagate types from the instruction to the type guard. We do it
       // now to be able to optimize further.
       work.guards.forEach((HTypeGuard guard) {
-        guard.type = guard.guarded.type;
-        guard.guarded.type = HType.UNKNOWN;
+        guard.propagatedType = guard.guarded.propagatedType;
+        guard.guarded.propagatedType = HType.UNKNOWN;
       });
       // We also need to insert range and integer checks for the type guards,
       // now that they know their type. We did not need to do that
       // before because instructions that reference a guard would
       // have not tried to use, e.g. native array access, since the
       // guard was not typed.
       runPhases(graph, <OptimizationPhase>[new SsaCheckInserter(compiler)]);
     });
   }
 }
@@ skipping 23 matching lines @@
         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);
         }
         block.rewrite(instruction, replacement);
         block.remove(instruction);
         // If the replacement instruction does not know its type yet,
         // use the type of the instruction.
-        if (!replacement.type.isKnown()) {
-          replacement.type = instruction.type;
+        if (!replacement.propagatedType.isUseful()) {
+          replacement.propagatedType = instruction.propagatedType;
         }
       }
       instruction = next;
     }
   }
 
   HInstruction visitInstruction(HInstruction node) {
     return node;
   }
 
   HInstruction visitBoolify(HBoolify node) {
     List<HInstruction> inputs = node.inputs;
     assert(inputs.length == 1);
     HInstruction input = inputs[0];
     if (input.isBoolean()) return input;
     // All values !== true are boolified to false.
-    if (input.type.isKnown()) {
+    if (input.propagatedType.isUseful()) {
       return graph.addConstantBool(false);
     }
     return node;
   }
 
   HInstruction visitNot(HNot node) {
     List<HInstruction> inputs = node.inputs;
     assert(inputs.length == 1);
     HInstruction input = inputs[0];
     if (input is HConstant) {
@@ skipping 48 matching lines @@
           compiler.builder.interceptors.getEqualsNullInterceptor());
       node.block.addBefore(node,target);
       return new HEquals(target, node.left, node.right);
     }
     // All other cases are dealt with by the [visitInvokeBinary].
     return visitInvokeBinary(node);
   }
 
   HInstruction visitTypeGuard(HTypeGuard node) {
     HInstruction value = node.guarded;
-    return (value.type.combine(node.type) == value.type) ? value : node;
+    HType combinedType = value.propagatedType.combine(node.propagatedType);
+    return (combinedType == value.propagatedType) ? value : node;
   }
 
   HInstruction visitIntegerCheck(HIntegerCheck node) {
     HInstruction value = node.value;
     return value.isInteger() ? value : node;
   }
 
   HInstruction visitIs(HIs node) {
     Element element = node.typeExpression;
     if (element.kind === ElementKind.TYPE_VARIABLE) {
       compiler.unimplemented("visitIs for type variables");
     }
 
-    HType expressionType = node.expression.type;
+    HType expressionType = node.expression.propagatedType;
     if (element === compiler.objectClass
         || element === compiler.dynamicClass) {
       return graph.addConstantBool(true);
     } else if (expressionType.isInteger()) {
       if (element === compiler.intClass || element === compiler.numClass) {
         return graph.addConstantBool(true);
       } else if (element === compiler.doubleClass) {
         // We let the JS semantics decide for that check. Currently
         // the code we emit will always return true.
         return node;
@@ skipping 62 matching lines @@
   HBoundsCheck insertBoundsCheck(HInstruction node,
                                  HInstruction receiver,
                                  HInstruction index) {
     HStatic interceptor = new HStatic(lengthInterceptor);
     node.block.addBefore(node, interceptor);
     HInvokeInterceptor length = new HInvokeInterceptor(
         Selector.INVOCATION_0,
         const SourceString("length"),
         true,
         <HInstruction>[interceptor, receiver]);
-    length.type = HType.NUMBER;
+    length.propagatedType = HType.INTEGER;
     node.block.addBefore(node, length);
 
     HBoundsCheck check = new HBoundsCheck(length, index);
     node.block.addBefore(node, check);
     return check;
   }
 
   HIntegerCheck insertIntegerCheck(HInstruction node, HInstruction value) {
     HIntegerCheck check = new HIntegerCheck(value);
     node.block.addBefore(node, check);
     return check;
   }
 
   void visitIndex(HIndex node) {
-    if (!node.builtin) return;
-    if (node.index is HBoundsCheck) return;
-    HInstruction index = insertIntegerCheck(node, node.index);
+    if (!node.receiver.isStringOrArray()) return;
+    HInstruction index = node.index;
+    if (index is HBoundsCheck) return;
+    if (!node.index.isInteger()) {
+      index = insertIntegerCheck(node, index);
+    }
     index = insertBoundsCheck(node, node.receiver, index);
     HIndex newInstruction = new HIndex(node.target, node.receiver, index);
     node.block.addBefore(node, newInstruction);
     node.block.rewrite(node, newInstruction);
     node.block.remove(node);
   }
 
   void visitIndexAssign(HIndexAssign node) {
-    if (!node.builtin) return;
-    if (node.index is HBoundsCheck) return;
-    HInstruction index = insertIntegerCheck(node, node.index);
+    if (!node.receiver.isMutableArray()) return;
+    HInstruction index = node.index;
+    if (index is HBoundsCheck) return;
+    if (!node.index.isInteger()) {
+      index = insertIntegerCheck(node, index);
+    }
     index = insertBoundsCheck(node, node.receiver, index);
     HIndexAssign newInstruction =
         new HIndexAssign(node.target, node.receiver, index, node.value);
     node.block.addBefore(node, newInstruction);
     node.block.rewrite(node, newInstruction);
     node.block.remove(node);
   }
 }
 
 class SsaDeadCodeEliminator extends HGraphVisitor implements OptimizationPhase {
@@ skipping 379 matching lines @@
         }
       }
       if (!canBeMoved) continue;
 
       // This is safe because we are running after GVN.
       // TODO(ngeoffray): ensure GVN has been run.
       set_.add(current);
     }
   }
 }