Fix for dartbug.com/6036: the intersection of two different types is not always conflicting.

lib/compiler/implementation/ssa/nodes.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 HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
@@ skipping 881 matching lines @@
    * than the provided type for [this].
    *
    * Examples: the likely type of [:x == y:] is a boolean. In most cases this
    * cannot be guaranteed, but when merging types we still want to use this
    * information.
    *
    * Similarily the [HAdd] instruction is likely a number. Note that, even if
    * the incoming type is already set to integer, the likely type might still
    * just return the number type.
    */
-  HType computeLikelyType(HTypeMap types) => types[this];
+  HType computeLikelyType(HTypeMap types, Compiler compiler) => types[this];
 
   /**
    * Compute the type of the instruction by propagating the input types through
    * the instruction.
    *
    * By default just copy the guaranteed type.
    */
-  HType computeTypeFromInputTypes(HTypeMap types) => guaranteedType;
+  HType computeTypeFromInputTypes(HTypeMap types, Compiler compiler) {
+    return guaranteedType;
+  }
 
   /**
    * Compute the desired type for the the given [input]. Aside from using
    * other inputs to compute the desired type one should also use
    * the given [types] which, during the invocation of this method,
    * represents the desired type of [this].
    */
-  HType computeDesiredTypeForInput(HInstruction input, HTypeMap types) {
+  HType computeDesiredTypeForInput(HInstruction input,
+                                   HTypeMap types,
+                                   Compiler compiler) {
     return HType.UNKNOWN;
   }
 
   bool isInBasicBlock() => block != null;
 
   String inputsToString() {
     void addAsCommaSeparated(StringBuffer buffer, List<HInstruction> list) {
       for (int i = 0; i < list.length; i++) {
         if (i != 0) buffer.add(', ');
         buffer.add("@${list[i].id}");
@@ skipping 273 matching lines @@
   bool isEnabled = false;
 
   HTypeGuard(this.guardedType, HInstruction guarded, HInstruction bailoutTarget)
       : super(<HInstruction>[guarded, bailoutTarget]);
 
   HInstruction get guarded => inputs[0];
   HInstruction get checkedInput => guarded;
   HBailoutTarget get bailoutTarget => inputs[1];
   int get state => bailoutTarget.state;
 
-  HType computeTypeFromInputTypes(HTypeMap types) {
+  HType computeTypeFromInputTypes(HTypeMap types, Compiler compiler) {
     return isEnabled ? guardedType : types[guarded];
   }
 
   HType get guaranteedType => isEnabled ? guardedType : HType.UNKNOWN;
 
   bool isControlFlow() => true;
 
   bool isJsStatement(HTypeMap types) => isEnabled;
 
   accept(HVisitor visitor) => visitor.visitTypeGuard(this);
@@ skipping 31 matching lines @@
 class HIntegerCheck extends HCheck {
   bool alwaysFalse = false;
 
   HIntegerCheck(value) : super(<HInstruction>[value]);
 
   HInstruction get value => inputs[0];
   bool isControlFlow() => true;
 
   HType get guaranteedType => HType.INTEGER;
 
-  HType computeDesiredTypeForInput(HInstruction input, HTypeMap types) {
+  HType computeDesiredTypeForInput(HInstruction input,
+                                   HTypeMap types,
+                                   Compiler compiler) {
     // If the desired type of the input is already a number, we want
     // to specialize it to an integer.
     return input.isNumber(types)
       ? HType.INTEGER
-      : super.computeDesiredTypeForInput(input, types);
+      : super.computeDesiredTypeForInput(input, types, compiler);
   }
 
   accept(HVisitor visitor) => visitor.visitIntegerCheck(this);
   int typeCode() => HInstruction.INTEGER_CHECK_TYPECODE;
   bool typeEquals(other) => other is HIntegerCheck;
   bool dataEquals(HInstruction other) => true;
 }
 
 abstract class HConditionalBranch extends HControlFlow {
   HConditionalBranch(inputs) : super(inputs);
@@ skipping 107 matching lines @@
   HInvokeStatic(inputs, [HType knownType = HType.UNKNOWN]) : super(inputs) {
     guaranteedType = knownType;
   }
 
   toString() => 'invoke static: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeStatic(this);
   int typeCode() => HInstruction.INVOKE_STATIC_TYPECODE;
   Element get element => target.element;
   HStatic get target => inputs[0];
 
-  HType computeDesiredTypeForInput(HInstruction input, HTypeMap types) {
+  HType computeDesiredTypeForInput(HInstruction input,
+                                   HTypeMap types,
+                                   Compiler compiler) {
     // TODO(floitsch): we want the target to be a function.
     if (input == target) return HType.UNKNOWN;
-    return computeDesiredTypeForNonTargetInput(input, types);
+    return computeDesiredTypeForNonTargetInput(input, types, compiler);
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
-                                            HTypeMap types) {
+                                            HTypeMap types,
+                                            Compiler compiler) {
     return HType.UNKNOWN;
   }
 }
 
 class HInvokeSuper extends HInvokeStatic {
   final bool isSetter;
   HInvokeSuper(inputs, {this.isSetter: false}) : super(inputs);
   toString() => 'invoke super: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeSuper(this);
 
@@ skipping 25 matching lines @@
     return selector.isCall()
         && inputs[1].isExtendableArray(types)
         && selector.name == const SourceString('removeLast')
         && selector.argumentCount == 0;
   }
 
   bool isLengthGetterOnStringOrArray(HTypeMap types) {
     return isLengthGetter() && inputs[1].isIndexablePrimitive(types);
   }
 
-  HType computeLikelyType(HTypeMap types) {
+  HType computeLikelyType(HTypeMap types, Compiler compiler) {
     // In general a length getter or method returns an int.
     if (isLengthGetter()) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
-  HType computeTypeFromInputTypes(HTypeMap types) {
+  HType computeTypeFromInputTypes(HTypeMap types, Compiler compiler) {
     if (isLengthGetterOnStringOrArray(types)) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
-                                            HTypeMap types) {
+                                            HTypeMap types,
+                                            Compiler compiler) {
     // If the first argument is a string or an array and we invoke methods
     // on it that mutate it, then we want to restrict the incoming type to be
     // a mutable array.
     if (input == inputs[1] && input.isIndexablePrimitive(types)) {
       // TODO(kasperl): Should we check that the selector is a call selector?
       if (selector.name == const SourceString('add')
           || selector.name == const SourceString('removeLast')) {
         return HType.MUTABLE_ARRAY;
       }
     }
@@ skipping 159 matching lines @@
     if (isBuiltin(types)) {
       setUseGvn();
     } else {
       setAllSideEffects();
     }
   }
 
   bool isBuiltin(HTypeMap types)
       => left.isNumber(types) && right.isNumber(types);
 
-  HType computeTypeFromInputTypes(HTypeMap types) {
+  HType computeTypeFromInputTypes(HTypeMap types, Compiler compiler) {
     if (left.isInteger(types) && right.isInteger(types)) return HType.INTEGER;
     if (left.isNumber(types)) {
       if (left.isDouble(types) || right.isDouble(types)) return HType.DOUBLE;
       return HType.NUMBER;
     }
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
-                                            HTypeMap types) {
+                                            HTypeMap types,
+                                            Compiler compiler) {
     HType propagatedType = types[this];
     // If the desired output type should be an integer we want to get two
     // integers as arguments.
     if (propagatedType.isInteger()) return HType.INTEGER;
     // If the outgoing type should be a number we can get that if both inputs
     // are numbers. If we don't know the outgoing type we try to make it a
     // number.
     if (propagatedType.isUnknown() || propagatedType.isNumber()) {
       return HType.NUMBER;
     }
     // Even if the desired outgoing type is not a number we still want the
     // second argument to be a number if the first one is a number. This will
     // not help for the outgoing type, but at least the binary arithmetic
     // operation will not have type problems.
     // TODO(floitsch): normally we shouldn't request a number, but simply
     // throw an ArgumentError if it isn't. This would be similar
     // to the array case.
     if (input == right && left.isNumber(types)) return HType.NUMBER;
     return HType.UNKNOWN;
   }
 
-  HType computeLikelyType(HTypeMap types) {
+  HType computeLikelyType(HTypeMap types, Compiler compiler) {
     if (left.isTypeUnknown(types)) return HType.NUMBER;
     return HType.UNKNOWN;
   }
 
   abstract BinaryOperation operation(ConstantSystem constantSystem);
 }
 
 class HAdd extends HBinaryArithmetic {
   HAdd(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitAdd(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
       => constantSystem.add;
   int typeCode() => HInstruction.ADD_TYPECODE;
   bool typeEquals(other) => other is HAdd;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HDivide extends HBinaryArithmetic {
   HDivide(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitDivide(this);
 
-  HType computeTypeFromInputTypes(HTypeMap types) {
+  HType computeTypeFromInputTypes(HTypeMap types, Compiler compiler) {
     if (left.isNumber(types)) return HType.DOUBLE;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
-                                            HTypeMap types) {
+                                            HTypeMap types,
+                                            Compiler compiler) {
     // A division can never return an integer. So don't ask for integer inputs.
     if (isInteger(types)) return HType.UNKNOWN;
-    return super.computeDesiredTypeForNonTargetInput(input, types);
+    return super.computeDesiredTypeForNonTargetInput(input, types, compiler);
   }
 
   BinaryOperation operation(ConstantSystem constantSystem)
       => constantSystem.divide;
   int typeCode() => HInstruction.DIVIDE_TYPECODE;
   bool typeEquals(other) => other is HDivide;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HModulo extends HBinaryArithmetic {
@@ skipping 67 matching lines @@
   bool dataEquals(HInstruction other) => true;
 }
 
 
 // TODO(floitsch): Should HBinaryArithmetic really be the super class of
 // HBinaryBitOp?
 abstract class HBinaryBitOp extends HBinaryArithmetic {
   HBinaryBitOp(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
 
-  HType computeTypeFromInputTypes(HTypeMap types) {
+  HType computeTypeFromInputTypes(HTypeMap types, Compiler compiler) {
     // All bitwise operations on primitive types either produce an
     // integer or throw an error.
     if (left.isPrimitive(types)) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
-                                            HTypeMap types) {
+                                            HTypeMap types,
+                                            Compiler compiler) {
     HType propagatedType = types[this];
     // If the outgoing type should be a number we can get that only if both
     // inputs are integers. If we don't know the outgoing type we try to make
     // it an integer.
     if (propagatedType.isUnknown() || propagatedType.isNumber()) {
       return HType.INTEGER;
     }
     return HType.UNKNOWN;
   }
 
-  HType computeLikelyType(HTypeMap types) {
+  HType computeLikelyType(HTypeMap types, Compiler compiler) {
     if (left.isTypeUnknown(types)) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
   // TODO(floitsch): make class abstract instead of adding an abstract method.
   abstract accept(HVisitor visitor);
 }
 
 class HShiftLeft extends HBinaryBitOp {
   HShiftLeft(HStatic target, HInstruction left, HInstruction right)
@@ skipping 81 matching lines @@
     // number.
     if (isBuiltin(types)) {
       setUseGvn();
     } else {
       setAllSideEffects();
     }
   }
 
   bool isBuiltin(HTypeMap types) => operand.isNumber(types);
 
-  HType computeTypeFromInputTypes(HTypeMap types) {
+  HType computeTypeFromInputTypes(HTypeMap types, Compiler compiler) {
     HType operandType = types[operand];
     if (operandType.isNumber()) return operandType;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
-                                            HTypeMap types) {
+                                            HTypeMap types,
+                                            Compiler compiler) {
     HType propagatedType = types[this];
     // If the outgoing type should be a number (integer, double or both) we
     // want the outgoing type to be the input too.
     // If we don't know the outgoing type we try to make it a number.
     if (propagatedType.isNumber()) return propagatedType;
     if (propagatedType.isUnknown()) return HType.NUMBER;
     return HType.UNKNOWN;
   }
 
-  HType computeLikelyType(HTypeMap types) => HType.NUMBER;
+  HType computeLikelyType(HTypeMap types, Compiler compiler) => HType.NUMBER;
 
   abstract UnaryOperation operation(ConstantSystem constantSystem);
 }
 
 class HNegate extends HInvokeUnary {
   HNegate(HStatic target, HInstruction input) : super(target, input);
   accept(HVisitor visitor) => visitor.visitNegate(this);
 
   UnaryOperation operation(ConstantSystem constantSystem)
       => constantSystem.negate;
   int typeCode() => HInstruction.NEGATE_TYPECODE;
   bool typeEquals(other) => other is HNegate;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitNot extends HInvokeUnary {
   HBitNot(HStatic target, HInstruction input) : super(target, input);
   accept(HVisitor visitor) => visitor.visitBitNot(this);
 
-  HType computeTypeFromInputTypes(HTypeMap types) {
+  HType computeTypeFromInputTypes(HTypeMap types, Compiler compiler) {
     // All bitwise operations on primitive types either produce an
     // integer or throw an error.
     if (operand.isPrimitive(types)) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
-                                            HTypeMap types) {
+                                            HTypeMap types,
+                                            Compiler compiler) {
     HType propagatedType = types[this];
     // Bit operations only work on integers. If there is no desired output
     // type or if it as a number we want to get an integer as input.
     if (propagatedType.isUnknown() || propagatedType.isNumber()) {
       return HType.INTEGER;
     }
     return HType.UNKNOWN;
   }
 
   UnaryOperation operation(ConstantSystem constantSystem)
@@ skipping 115 matching lines @@
 class HNot extends HInstruction {
   HNot(HInstruction value) : super(<HInstruction>[value]);
   void prepareGvn(HTypeMap types) {
     assert(!hasSideEffects(types));
     setUseGvn();
   }
 
   HType get guaranteedType => HType.BOOLEAN;
 
   // 'Not' only works on booleans. That's what we want as input.
-  HType computeDesiredTypeForInput(HInstruction input, HTypeMap types) {
+  HType computeDesiredTypeForInput(HInstruction input,
+                                   HTypeMap types,
+                                   Compiler compiler) {
     return HType.BOOLEAN;
   }
 
   accept(HVisitor visitor) => visitor.visitNot(this);
   int typeCode() => HInstruction.NOT_TYPECODE;
   bool typeEquals(other) => other is HNot;
   bool dataEquals(HInstruction other) => true;
 }
 
 /**
@@ skipping 51 matching lines @@
   void addInput(HInstruction input) {
     assert(isInBasicBlock());
     inputs.add(input);
     input.usedBy.add(this);
   }
 
   // Compute the (shared) type of the inputs if any. If all inputs
   // have the same known type return it. If any two inputs have
   // different known types, we'll return a conflict -- otherwise we'll
   // simply return an unknown type.
-  HType computeInputsType(bool ignoreUnknowns, HTypeMap types) {
+  HType computeInputsType(bool ignoreUnknowns,
+                          HTypeMap types,
+                          Compiler compiler) {
     HType candidateType = HType.CONFLICTING;
     for (int i = 0, length = inputs.length; i < length; i++) {
       HType inputType = types[inputs[i]];
       if (ignoreUnknowns && inputType.isUnknown()) continue;
       // Phis need to combine the incoming types using the union operation.
       // For example, if one incoming edge has type integer and the other has
       // type double, then the phi is either an integer or double and thus has
       // type number.
-      candidateType = candidateType.union(inputType);
+      candidateType = candidateType.union(inputType, compiler);
       if (candidateType.isUnknown()) return HType.UNKNOWN;
     }
     return candidateType;
   }
 
-  HType computeTypeFromInputTypes(HTypeMap types) {
-    HType inputsType = computeInputsType(false, types);
+  HType computeTypeFromInputTypes(HTypeMap types, Compiler compiler) {
+    HType inputsType = computeInputsType(false, types, compiler);
     if (inputsType.isConflicting()) return HType.UNKNOWN;
     return inputsType;
   }
 
-  HType computeDesiredTypeForInput(HInstruction input, HTypeMap types) {
+  HType computeDesiredTypeForInput(HInstruction input,
+                                   HTypeMap types,
+                                   Compiler compiler) {
     HType propagatedType = types[this];
     // Best case scenario for a phi is, when all inputs have the same type. If
     // there is no desired outgoing type we therefore try to unify the input
     // types (which is basically the [likelyType]).
-    if (propagatedType.isUnknown()) return computeLikelyType(types);
+    if (propagatedType.isUnknown()) return computeLikelyType(types, compiler);
     // When the desired outgoing type is conflicting we don't need to give any
     // requirements on the inputs.
     if (propagatedType.isConflicting()) return HType.UNKNOWN;
     // Otherwise the input type must match the desired outgoing type.
     return propagatedType;
   }
 
-  HType computeLikelyType(HTypeMap types) {
-    HType agreedType = computeInputsType(true, types);
+  HType computeLikelyType(HTypeMap types, Compiler compiler) {
+    HType agreedType = computeInputsType(true, types, compiler);
     if (agreedType.isConflicting()) return HType.UNKNOWN;
     // Don't be too restrictive. If the agreed type is integer or double just
     // say that the likely type is number. If more is expected the type will be
     // propagated back.
     if (agreedType.isNumber()) return HType.NUMBER;
     return agreedType;
   }
 
   bool isLogicalOperator() => logicalOperatorType != IS_NOT_LOGICAL_OPERATOR;
 
@@ skipping 18 matching lines @@
     // Relational expressions can take part in global value numbering
     // and do not have any side-effects if we know all the inputs are
     // numbers. This can be improved for at least equality.
     if (isBuiltin(types)) {
       setUseGvn();
     } else {
       setAllSideEffects();
     }
   }
 
-  HType computeTypeFromInputTypes(HTypeMap types) {
+  HType computeTypeFromInputTypes(HTypeMap types, Compiler compiler) {
     if (left.isNumber(types) || usesBoolifiedInterceptor) return HType.BOOLEAN;
     return HType.UNKNOWN;
   }
 
   HType get guaranteedType {
     if (usesBoolifiedInterceptor) return HType.BOOLEAN;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
-                                            HTypeMap types) {
+                                            HTypeMap types,
+                                            Compiler compiler) {
     HType propagatedType = types[this];
     // For all relational operations exept HEquals, we expect to get numbers
     // only. With numbers the outgoing type is a boolean. If something else
     // is desired, then numbers are incorrect, though.
     if (propagatedType.isUnknown() || propagatedType.isBoolean()) {
       if (left.isTypeUnknown(types) || left.isNumber(types)) {
         return HType.NUMBER;
       }
     }
     return HType.UNKNOWN;
   }
 
-  HType computeLikelyType(HTypeMap types) => HType.BOOLEAN;
+  HType computeLikelyType(HTypeMap types, Compiler compiler) => HType.BOOLEAN;
 
   bool isBuiltin(HTypeMap types)
       => left.isNumber(types) && right.isNumber(types);
   // TODO(1603): the class should be marked as abstract.
   abstract BinaryOperation operation(ConstantSystem constantSystem);
 }
 
 class HEquals extends HRelational {
   HEquals(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitEquals(this);
 
   bool isBuiltin(HTypeMap types) {
     // All primitive types have === semantics.
     // Note that this includes all constants except the user-constructed
     // objects.
     return types[left].isPrimitiveOrNull() || right.isConstantNull();
   }
 
-  HType computeTypeFromInputTypes(HTypeMap types) {
+  HType computeTypeFromInputTypes(HTypeMap types, Compiler compiler) {
     if (isBuiltin(types) || usesBoolifiedInterceptor) return HType.BOOLEAN;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
-                                            HTypeMap types) {
+                                            HTypeMap types,
+                                            Compiler compiler) {
     HType propagatedType = types[this];
     if (input == left && types[right].isUseful()) {
       // All our useful types have === semantics. But we don't want to
       // speculatively test for all possible types. Therefore we try to match
       // the two types. That is, if we see x == 3, then we speculatively test
       // if x is a number and bailout if it isn't.
       // If right is a number we don't need more than a number (no need to match
       // the exact type of right).
       if (right.isNumber(types)) return HType.NUMBER;
       // String equality testing is much more common than array equality
@@ skipping 20 matching lines @@
 }
 
 class HIdentity extends HRelational {
   HIdentity(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitIdentity(this);
 
   bool isBuiltin(HTypeMap types) => true;
 
   HType get guaranteedType => HType.BOOLEAN;
-  HType computeTypeFromInputTypes(HTypeMap types)
+  HType computeTypeFromInputTypes(HTypeMap types, Compiler compiler)
       => HType.BOOLEAN;
   // Note that the identity operator really does not care for its input types.
-  HType computeDesiredTypeForInput(HInstruction input, HTypeMap types)
-      => HType.UNKNOWN;
+  HType computeDesiredTypeForInput(HInstruction input,
+                                   HTypeMap types,
+                                   Compiler compiler) {
+    return HType.UNKNOWN;
+  }
 
   BinaryOperation operation(ConstantSystem constantSystem)
       => constantSystem.identity;
   int typeCode() => HInstruction.IDENTITY_TYPECODE;
   bool typeEquals(other) => other is HIdentity;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HGreater extends HRelational {
   HGreater(HStatic target, HInstruction left, HInstruction right)
@@ skipping 140 matching lines @@
       setUseGvn();
     } else {
       setAllSideEffects();
     }
   }
 
   HInstruction get receiver => inputs[1];
   HInstruction get index => inputs[2];
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
-                                            HTypeMap types) {
+                                            HTypeMap types,
+                                            Compiler compiler) {
     if (input == receiver &&
         (index.isTypeUnknown(types) || index.isNumber(types))) {
       return HType.INDEXABLE_PRIMITIVE;
     }
     // The index should be an int when the receiver is a string or array.
     // However it turns out that inserting an integer check in the optimized
     // version is cheaper than having another bailout case. This is true,
     // because the integer check will simply throw if it fails.
     return HType.UNKNOWN;
   }
@@ skipping 25 matching lines @@
       setChangesIndex();
     } else {
       setAllSideEffects();
     }
   }
 
   // Note, that we don't have a computeTypeFromInputTypes, since [HIndexAssign]
   // is never used as input.
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
-                                            HTypeMap types) {
+                                            HTypeMap types,
+                                            Compiler compiler) {
     if (input == receiver &&
         (index.isTypeUnknown(types) || index.isNumber(types))) {
       return HType.MUTABLE_ARRAY;
     }
     // The index should be an int when the receiver is a string or array.
     // However it turns out that inserting an integer check in the optimized
     // version is cheaper than having another bailout case. This is true,
     // because the integer check will simply throw if it fails.
     return HType.UNKNOWN;
   }
@@ skipping 419 matching lines @@
   HBasicBlock get start => expression.start;
   HBasicBlock get end {
     // We don't create a switch block if there are no cases.
     assert(!statements.isEmpty);
     return statements.last.end;
   }
 
   bool accept(HStatementInformationVisitor visitor) =>
       visitor.visitSwitchInfo(this);
 }