Move array and string related HType from const to a field in the backend.

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 177 matching lines @@
     assert(inputs.length == 1);
     HInstruction input = inputs[0];
     HType type = input.instructionType;
     if (type.isBoolean()) return input;
     // All values that cannot be 'true' are boolified to false.
     DartType booleanType = backend.jsBoolClass.computeType(compiler);
     TypeMask mask = type.computeMask(compiler);
     // TODO(kasperl): Get rid of the null check here once all HTypes
     // have a proper mask.
     if (mask != null && !mask.contains(booleanType, compiler)) {
-      return graph.addConstantBool(false, constantSystem);
+      return graph.addConstantBool(false, compiler);
     }
     return node;
   }
 
   HInstruction visitNot(HNot node) {
     List<HInstruction> inputs = node.inputs;
     assert(inputs.length == 1);
     HInstruction input = inputs[0];
     if (input is HConstant) {
       HConstant constant = input;
       bool isTrue = constant.constant.isTrue();
-      return graph.addConstantBool(!isTrue, constantSystem);
+      return graph.addConstantBool(!isTrue, compiler);
     } else if (input is HNot) {
       return input.inputs[0];
     }
     return node;
   }
 
   HInstruction visitInvokeUnary(HInvokeUnary node) {
     HInstruction folded =
         foldUnary(node.operation(constantSystem), node.operand);
     return folded != null ? folded : node;
   }
 
   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);
+      if (folded != null) return graph.addConstant(folded, compiler);
     }
     return null;
   }
 
   HInstruction tryOptimizeLengthInterceptedGetter(HInvokeDynamic node) {
     HInstruction actualReceiver = node.inputs[1];
     if (actualReceiver.isIndexable(compiler)) {
       if (actualReceiver.isConstantString()) {
         HConstant constantInput = actualReceiver;
         StringConstant constant = constantInput.constant;
-        return graph.addConstantInt(constant.length, constantSystem);
+        return graph.addConstantInt(constant.length, compiler);
       } else if (actualReceiver.isConstantList()) {
         HConstant constantInput = actualReceiver;
         ListConstant constant = constantInput.constant;
-        return graph.addConstantInt(constant.length, constantSystem);
+        return graph.addConstantInt(constant.length, compiler);
       }
       Element element = backend.jsIndexableLength;
       bool isAssignable = !actualReceiver.isFixedArray(compiler) &&
-          !actualReceiver.isString();
+          !actualReceiver.isString(compiler);
       HFieldGet result = new HFieldGet(
           element, actualReceiver, isAssignable: isAssignable);
       result.instructionType = HType.INTEGER;
       return result;
     } else if (actualReceiver.isConstantMap()) {
       HConstant constantInput = actualReceiver;
       MapConstant constant = constantInput.constant;
-      return graph.addConstantInt(constant.length, constantSystem);
+      return graph.addConstantInt(constant.length, compiler);
     }
     return null;
   }
 
   HInstruction handleInterceptedCall(HInvokeDynamic node) {
     // 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])
@@ skipping 14 matching lines @@
       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;
           }
         }
-      } else if (input.isString()) {
+      } else if (input.isString(compiler)) {
         if (selector.applies(backend.jsStringSplit, compiler)) {
-          if (node.inputs[2].isString()) {
+          if (node.inputs[2].isString(compiler)) {
             target = backend.jsStringSplit;
           }
         } else if (selector.applies(backend.jsStringConcat, compiler)) {
-          if (node.inputs[2].isString()) {
+          if (node.inputs[2].isString(compiler)) {
             target = backend.jsStringConcat;
           }
         } else if (selector.applies(backend.jsStringToString, compiler)) {
           return input;
         }
       }
       if (target != null) {
         // TODO(ngeoffray): There is a strong dependency between codegen
         // and this optimization that the dynamic invoke does not need an
         // interceptor. We currently need to keep a
@@ skipping 126 matching lines @@
     return node;
   }
 
   HInstruction foldBinary(BinaryOperation operation,
                           HInstruction left,
                           HInstruction right) {
     if (left is HConstant && right is HConstant) {
       HConstant op1 = left;
       HConstant op2 = right;
       Constant folded = operation.fold(op1.constant, op2.constant);
-      if (folded != null) return graph.addConstant(folded);
+      if (folded != null) return graph.addConstant(folded, compiler);
     }
     return null;
   }
 
   HInstruction visitInvokeBinary(HInvokeBinary node) {
     HInstruction left = node.left;
     HInstruction right = node.right;
     BinaryOperation operation = node.operation(constantSystem);
     HConstant folded = foldBinary(operation, left, right);
     if (folded != null) return folded;
@@ skipping 22 matching lines @@
   HInstruction handleIdentityCheck(HRelational node) {
     HInstruction left = node.left;
     HInstruction right = node.right;
     HType leftType = left.instructionType;
     HType rightType = right.instructionType;
 
     // Intersection of int and double return conflicting, so
     // we don't optimize on numbers to preserve the runtime semantics.
     if (!(left.isNumberOrNull() && right.isNumberOrNull()) &&
         leftType.intersection(rightType, compiler).isConflicting()) {
-      return graph.addConstantBool(false, constantSystem);
+      return graph.addConstantBool(false, compiler);
     }
 
     if (left.isNull() && right.isNull()) {
-      return graph.addConstantBool(true, constantSystem);
+      return graph.addConstantBool(true, compiler);
     }
 
     if (left.isConstantBoolean() && right.isBoolean()) {
       HConstant constant = left;
       if (constant.constant.isTrue()) {
         return right;
       } else {
         return new HNot(right);
       }
     }
@@ skipping 31 matching lines @@
 
     if (!node.isRawCheck) {
       return node;
     } else if (element.isTypedef()) {
       return node;
     } else if (element == compiler.functionClass) {
       return node;
     }
 
     if (element == compiler.objectClass || element == compiler.dynamicClass) {
-      return graph.addConstantBool(true, constantSystem);
+      return graph.addConstantBool(true, compiler);
     }
 
     HType expressionType = node.expression.instructionType;
     if (expressionType.isInteger()) {
       if (identical(element, compiler.intClass)
           || identical(element, compiler.numClass)
           || Elements.isNumberOrStringSupertype(element, compiler)) {
-        return graph.addConstantBool(true, constantSystem);
+        return graph.addConstantBool(true, compiler);
       } else if (identical(element, compiler.doubleClass)) {
         // We let the JS semantics decide for that check. Currently
         // the code we emit will always return true.
         return node;
       } else {
-        return graph.addConstantBool(false, constantSystem);
+        return graph.addConstantBool(false, compiler);
       }
     } else if (expressionType.isDouble()) {
       if (identical(element, compiler.doubleClass)
           || identical(element, compiler.numClass)
           || Elements.isNumberOrStringSupertype(element, compiler)) {
-        return graph.addConstantBool(true, constantSystem);
+        return graph.addConstantBool(true, compiler);
       } else if (identical(element, compiler.intClass)) {
         // We let the JS semantics decide for that check. Currently
         // the code we emit will return true for a double that can be
         // represented as a 31-bit integer and for -0.0.
         return node;
       } else {
-        return graph.addConstantBool(false, constantSystem);
+        return graph.addConstantBool(false, compiler);
       }
     } else if (expressionType.isNumber()) {
       if (identical(element, compiler.numClass)) {
-        return graph.addConstantBool(true, constantSystem);
-      }
-      // We cannot just return false, because the expression may be of
-      // type int or double.
-    } else if (expressionType.isString()) {
-      if (identical(element, compiler.stringClass)
-               || Elements.isStringOnlySupertype(element, compiler)
-               || Elements.isNumberOrStringSupertype(element, compiler)) {
-        return graph.addConstantBool(true, constantSystem);
+        return graph.addConstantBool(true, compiler);
       } else {
-        return graph.addConstantBool(false, constantSystem);
+        // We cannot just return false, because the expression may be of
+        // type int or double.
       }
     // We need the [:hasTypeArguments:] check because we don't have
     // the notion of generics in the backend. For example, [:this:] in
     // a class [:A<T>:], is currently always considered to have the
     // raw type.
     } else if (!RuntimeTypes.hasTypeArguments(type) && !type.isMalformed) {
       TypeMask expressionMask = expressionType.computeMask(compiler);
       TypeMask typeMask = new TypeMask.nonNullSubtype(type);
       if (expressionMask.union(typeMask, compiler) == typeMask) {
-        return graph.addConstantBool(true, constantSystem);
+        return graph.addConstantBool(true, compiler);
       } else if (expressionMask.intersection(typeMask, compiler).isEmpty) {
-        return graph.addConstantBool(false, constantSystem);
+        return graph.addConstantBool(false, compiler);
       }
     }
     return node;
   }
 
   HInstruction visitTypeConversion(HTypeConversion node) {
     HInstruction value = node.inputs[0];
     DartType type = node.typeExpression;
     if (type != null && (!type.isRaw || type.kind == TypeKind.TYPE_VARIABLE)) {
       return node;
@@ skipping 25 matching lines @@
         // that we know takes an int.
         if (element == compiler.unnamedListConstructor
             && call.inputs.length == 1
             && call.inputs[0].isInteger()) {
           return call.inputs[0];
         }
       } else if (node.receiver.isConstantList() ||
                  node.receiver.isConstantString()) {
         var instruction = node.receiver;
         return graph.addConstantInt(
-            instruction.constant.length, backend.constantSystem);
+            instruction.constant.length, compiler);
       }
     }
     return node;
   }
 
   HInstruction visitIndex(HIndex node) {
     if (node.receiver.isConstantList() && node.index.isConstantInteger()) {
       var instruction = node.receiver;
       List<Constant> entries = instruction.constant.entries;
       instruction = node.index;
       int index = instruction.constant.value;
       if (index >= 0 && index < entries.length) {
-        return graph.addConstant(entries[index]);
+        return graph.addConstant(entries[index], compiler);
       }
     }
     return node;
   }
 
   HInstruction visitInvokeDynamicGetter(HInvokeDynamicGetter node) {
     if (node.isInterceptedCall) {
       HInstruction folded = handleInterceptedCall(node);
       if (folded != node) return folded;
     }
@@ skipping 89 matching lines @@
     if (leftString == null) {
       if (node.left is! HStringConcat) return node;
       HStringConcat leftConcat = node.left;
       // Don't undo CSE.
       if (leftConcat.usedBy.length != 1) return node;
       prefix = leftConcat.left;
       leftString = getString(leftConcat.right);
       if (leftString == null) return node;
     }
 
-    HInstruction folded =
-        graph.addConstant(constantSystem.createString(
+    HInstruction folded = graph.addConstant(
+        constantSystem.createString(
             new DartString.concat(leftString.value, rightString.value),
-            node.node));
+            node.node),
+        compiler);
     if (prefix == null) return folded;
-    return new HStringConcat(prefix, folded, node.node);
+    return new HStringConcat(prefix, folded, node.node, backend.stringType);
   }
 
   HInstruction visitStringify(HStringify node) {
     HInstruction input = node.inputs[0];
-    if (input.isString()) return input;
+    if (input.isString(compiler) && !input.canBeNull()) return input;
     if (input.isConstant()) {
       HConstant constant = input;
       if (!constant.constant.isPrimitive()) return node;
       PrimitiveConstant primitive = constant.constant;
       return graph.addConstant(constantSystem.createString(
-          primitive.toDartString(), node.node));
+          primitive.toDartString(), node.node), compiler);
     }
     return node;
   }
 
   HInstruction visitOneShotInterceptor(HOneShotInterceptor node) {
     return handleInterceptedCall(node);
   }
 }
 
 class SsaCheckInserter extends HBaseVisitor implements OptimizationPhase {
@@ skipping 17 matching lines @@
     while (instruction != null) {
       HInstruction next = instruction.next;
       instruction = instruction.accept(this);
       instruction = next;
     }
   }
 
   HBoundsCheck insertBoundsCheck(HInstruction indexNode,
                                  HInstruction array,
                                  HInstruction indexArgument) {
+    Compiler compiler = backend.compiler;
     bool isAssignable =
-        !array.isFixedArray(backend.compiler) && !array.isString();
+        !array.isFixedArray(compiler) && !array.isString(compiler);
     HFieldGet length = new HFieldGet(
         backend.jsIndexableLength, array, isAssignable: isAssignable);
     length.instructionType = HType.INTEGER;
     indexNode.block.addBefore(indexNode, length);
 
     HBoundsCheck check = new HBoundsCheck(indexArgument, length);
     indexNode.block.addBefore(indexNode, check);
     // If the index input to the bounds check was not known to be an integer
     // then we replace its uses with the bounds check, which is known to be an
     // integer.  However, if the input was already an integer we don't do this
@@ skipping 19 matching lines @@
     HInstruction index = node.index;
     index = insertBoundsCheck(node, node.receiver, index);
   }
 
   void visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
     Element element = node.element;
     if (node.isInterceptedCall) return;
     if (element != backend.jsArrayRemoveLast) return;
     if (boundsChecked.contains(node)) return;
     insertBoundsCheck(
-        node, node.receiver, graph.addConstantInt(0, backend.constantSystem));
+        node, node.receiver, graph.addConstantInt(0, backend.compiler));
   }
 }
 
 class SsaDeadCodeEliminator extends HGraphVisitor implements OptimizationPhase {
   final String name = "SsaDeadCodeEliminator";
 
   SsaDeadCodeEliminator();
 
   bool isDeadCode(HInstruction instruction) {
     return !instruction.sideEffects.hasSideEffects()
@@ skipping 459 matching lines @@
       // that knows it is not of a specific Type.
     }
 
     for (HIf ifUser in notIfUsers) {
       changeUsesDominatedBy(ifUser.elseBlock, input, convertedType);
       // TODO(ngeoffray): Also change uses for the then block on a HType
       // that knows it is not of a specific Type.
     }
   }
 }