Refactor types in ssa nodes.

lib/compiler/implementation/ssa/nodes.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 HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
   R visitBitXor(HBitXor node);
@@ skipping 649 matching lines @@
   bool isValid() {
     assert(isClosed());
     HValidator validator = new HValidator();
     validator.visitBasicBlock(this);
     return validator.isValid;
   }
 }
 
 
 class HType {
-  final int flag;
-  const HType(int this.flag);
+  // We need a field so that the different static types are not canonicalized.

[ngeoffray, 2012/04/23 10:19:21]

types -> fields

[floitsch, 2012/04/24 15:25:18]

Refactored.

+  // This way we don't need to do special work for the toString.

[ngeoffray, 2012/04/23 10:19:21]

the toString -> [toString]

[floitsch, 2012/04/24 15:25:18]

Refactored.

+  final String typeName;
+  const HType(this.typeName);
 
-  static final int FLAG_CONFLICTING = 0;
-  static final int FLAG_UNKNOWN = 1;
-  static final int FLAG_BOOLEAN = FLAG_UNKNOWN << 1;
-  static final int FLAG_INTEGER = FLAG_BOOLEAN << 1;
-  static final int FLAG_STRING = FLAG_INTEGER << 1;
-  static final int FLAG_READABLE_ARRAY = FLAG_STRING << 1;
-  // FLAG_WRITABLE_ARRAY implies FLAG_READABLE_ARRAY.
-  static final int FLAG_WRITEABLE_ARRAY = FLAG_READABLE_ARRAY << 1;
-  static final int FLAG_DOUBLE = FLAG_WRITEABLE_ARRAY << 1;
-  static final int FLAG_NON_PRIMITIVE = FLAG_DOUBLE << 1;
-
-  static final HType CONFLICTING = const HType(FLAG_CONFLICTING);
-  static final HType UNKNOWN = const HType(FLAG_UNKNOWN);
-  static final HType BOOLEAN = const HType(FLAG_BOOLEAN);
-  static final HType STRING = const HType(FLAG_STRING);
-  static final HType READABLE_ARRAY = const HType(FLAG_READABLE_ARRAY);
-  static final HType MUTABLE_ARRAY =
-      const HType(FLAG_READABLE_ARRAY | FLAG_WRITEABLE_ARRAY);
-  static final HType INTEGER = const HType(FLAG_INTEGER);
-  static final HType DOUBLE = const HType(FLAG_DOUBLE);
-  static final HType STRING_OR_ARRAY =
-      const HType(FLAG_STRING | FLAG_READABLE_ARRAY | FLAG_WRITEABLE_ARRAY);
-  static final HType NUMBER = const HType(FLAG_DOUBLE | FLAG_INTEGER);
+  static final HType CONFLICTING = const HType("conflicting");
+  static final HType UNKNOWN = const HType("unknown");
+  static final HType BOOLEAN = const HType("boolean");
+  static final HType STRING = const HType("string");
+  static final HType READABLE_ARRAY = const HType("readable array");
+  // Note that mutable array is considered to be a subtype of readable array.
+  // That is, all values of type mutable array are also readable arrays, but not
+  // the inverse.
+  static final HType MUTABLE_ARRAY = const HType("mutable array");
+  static final HType INTEGER = const HType("integer");
+  static final HType DOUBLE = const HType("double");
+  static final HType INTEGER_OR_DOUBLE = const HType("integer or double");
+  // In this context "Array" means readable array.

[ngeoffray, 2012/04/23 10:19:21]

I'd rather have the field named STRING_OR_READABLE_ARRAY than a comment.

[floitsch, 2012/04/24 15:25:18]

Refactored.

+  static final HType STRING_OR_ARRAY = const HType("string or array");
 
   bool isConflicting() => this === CONFLICTING;
   bool isUnknown() => this === UNKNOWN;
   bool isBoolean() => this === BOOLEAN;
   bool isInteger() => this === INTEGER;
   bool isDouble() => this === DOUBLE;
   bool isString() => this === STRING;
-  bool isArray() => (this.flag & FLAG_READABLE_ARRAY) != 0;
+  bool isReadableArray() => this === READABLE_ARRAY;
   bool isMutableArray() => this === MUTABLE_ARRAY;
-  bool isNumber() => (this.flag & (FLAG_INTEGER | FLAG_DOUBLE)) != 0;
-  bool isStringOrArray() =>
-      (this.flag & (FLAG_STRING | FLAG_READABLE_ARRAY)) != 0;
-  bool isNonPrimitive() => this.flag === FLAG_NON_PRIMITIVE;
+  bool isStringOrArray() => this === STRING_OR_ARRAY;
+  bool isNonPrimitive() => false;
+  bool hasNoSubtypes() {
+    return isInteger() || isDouble() || isString() || isMutableArray();
+  }
+  bool isNumber() => isInteger() || isDouble() || this === INTEGER_OR_DOUBLE;
+  /** [isArray] does not include [isStringOrArray]. */
+  bool isArray() => isReadableArray() || isMutableArray();
+  bool isIndexablePrimitive() => isString() || isArray() || isStringOrArray();
   /** A type is useful it is not unknown and not conflicting. */
-  bool isUseful() => this !== UNKNOWN && this !== CONFLICTING;
+  bool isUseful() => !isUnknown() && !isConflicting();
 
-  static HType getTypeFromFlag(int flag) {
-    if (flag === CONFLICTING.flag) return CONFLICTING;
-    if (flag === UNKNOWN.flag) return UNKNOWN;
-    if (flag === BOOLEAN.flag) return BOOLEAN;
-    if (flag === INTEGER.flag) return INTEGER;
-    if (flag === DOUBLE.flag) return DOUBLE;
-    if (flag === STRING.flag) return STRING;
-    if (flag === READABLE_ARRAY.flag) return READABLE_ARRAY;
-    if (flag === MUTABLE_ARRAY.flag) return MUTABLE_ARRAY;
-    if (flag === NUMBER.flag) return NUMBER;
-    if (flag === STRING_OR_ARRAY.flag) return STRING_OR_ARRAY;
-    unreachable();
+  String toString() => typeName;
+
+  /**
+   * The intersection of two types is the intersection of its values. For
+   * example:
+   *   * INTEGER.intersect(INTEGER_OR_DOUBLE) => INTEGER.
+   *   * DOUBLE.intersect(INTEGER) => CONFLICTING.
+   *   * MUTABLE_ARRAY.intersect(READABLE_ARRAY) => MUTABLE_ARRAY.
+   *
+   * When there is no predefined type to represent the intersection returns
+   * [CONFLICTING].
+   */
+  HType intersect(HType other) {

[ngeoffray, 2012/04/23 10:19:21]

intersect -> intersection

[floitsch, 2012/04/24 15:25:18]

Done.

+    if (this === other) return this;
+    // Unknown has no influence on the type. Always just return the other type.
+    if (isUnknown()) return other;
+    if (other.isUnknown()) return this;
+
+    // Avoid testing some of the combinations by making the most concrete type

[ngeoffray, 2012/04/23 10:19:21]

most concrete -> leaf type?

[floitsch, 2012/04/24 15:25:18]

refactored.

+    // [:this:].
+    if (!hasNoSubtypes() && other.hasNoSubtypes()) {

[ngeoffray, 2012/04/23 10:19:21]

double negation is annoying to read. You could add a hasSubtypes method.

[floitsch, 2012/04/24 15:25:18]

refactored.

+      return other.intersect(this);
+    }
+
+    // If other is a super-type return [this].

[ngeoffray, 2012/04/23 10:19:21]

[other]

[ngeoffray, 2012/04/23 10:19:21]

super-type -> supertype of [this]

[floitsch, 2012/04/24 15:25:18]

refactored.

[floitsch, 2012/04/24 15:25:18]

refactored.

+    if (isInteger() && other === INTEGER_OR_DOUBLE) return this;
+    if (isDouble() && other === INTEGER_OR_DOUBLE) return this;
+    if (isString() && other.isStringOrArray()) return this;
+    if (isMutableArray() && other.isIndexablePrimitive()) return this;
+
+    // Handle the cases where neither side is a supertype of the other.
+    if (isArray() && other.isStringOrArray()) return this;
+    if (other.isArray() && isStringOrArray()) return other;
+
+    return CONFLICTING;
   }
 
-  String toString() {
-    if (isConflicting()) return 'conflicting';
-    if (isUnknown()) return 'unknown';
-    if (isBoolean()) return 'boolean';
-    if (isInteger()) return 'integer';
-    if (isDouble()) return 'double';
-    if (isString()) return 'string';
-    if (isMutableArray()) return 'mutable array';
-    if (isArray()) return 'array';
-    if (isNumber()) return 'number';
-    if (isStringOrArray()) return 'string or array';
-    unreachable();
-  }
-
-  HType combine(HType other) {
+  /**
+   * The union of two types is the union of its values. For example:
+   *   * INTEGER.union(INTEGER_OR_DOUBLE) => INTEGER_OR_DOUBLE.
+   *   * DOUBLE.union(INTEGER) => DOUBLE.
+   *   * MUTABLE_ARRAY.union(READABLE_ARRAY) => READABLE_ARRAY.
+   *
+   * When there is no predefined type to represent the union returns
+   * [CONFLICTING].
+   */
+  HType union(HType other) {
+    if (this === other) return this;
+    // Unknown has no influence on the type. Always just return the other type.
     if (isUnknown()) return other;
     if (other.isUnknown()) return this;
-    return getTypeFromFlag(this.flag & other.flag);
+
+    // Avoid testing some of the combinations by making the most concrete type

[ngeoffray, 2012/04/23 10:19:21]

most concrete -> leaf type?

[floitsch, 2012/04/24 15:25:18]

refactored.

+    // [:this:].
+    if (!hasNoSubtypes() && other.hasNoSubtypes()) {
+      return other.union(this);
+    }
+
+    // If [other] is a super type of [this] return [other];

[ngeoffray, 2012/04/23 10:19:21]

super type -> supertype

[floitsch, 2012/04/24 15:25:18]

refactored.

+    if (isNumber() && other === INTEGER_OR_DOUBLE) return other;
+    if (isArray() && other.isReadableArray()) return other;
+    if ((isString() || isArray()) && other.isStringOrArray()) return other;
+
+    // Handle the cases where neither side is a super type of the other.

[ngeoffray, 2012/04/23 10:19:21]

super type -> supertype

[floitsch, 2012/04/24 15:25:18]

refactored.

+    if (isNumber() && other.isNumber()) return INTEGER_OR_DOUBLE;
+    if (isString() && other.isArray()) return STRING_OR_ARRAY;
+    if (isArray() && other.isString()) return STRING_OR_ARRAY;
+
+    return CONFLICTING;
   }
 }
 
 class HNonPrimitiveType extends HType {
   final Type type;
 
-  // TODO(ngeoffray): Add a HPrimitiveType to get rid of the flag.
-  const HNonPrimitiveType(Type this.type) : super(HType.FLAG_NON_PRIMITIVE);
+  // TODO(ngeoffray): Add a HPrimitiveType to get rid of the string.
+  const HNonPrimitiveType(Type this.type) : super("non primitive");
+
+  bool isNonPrimitive() => true;
 
   HType combine(HType other) {
     if (other.isNonPrimitive()) {
       HNonPrimitiveType temp = other;
       if (this.type === temp.type) return this;
     }
     if (other.isUnknown()) return this;
     return HType.CONFLICTING;
   }
 
+  // As long as we don't keep track of super/sub types for non-primitive types
+  // the intersection and union is the same.
+  HType intersect(HType other) => combine(other);
+  HType union(HType other) => combine(other);
+
   String toString() => type.toString();
   Element lookupMember(SourceString name) {
     ClassElement classElement = type.element;
     return classElement.lookupMember(name);
   }
 }
 
 class HInstruction implements Hashable {
   Element sourceElement;
 
@@ skipping 39 matching lines @@
   void setAllSideEffects() { flags |= ((1 << FLAG_CHANGES_COUNT) - 1); }
   void clearAllSideEffects() { flags &= ~((1 << FLAG_CHANGES_COUNT) - 1); }
 
   bool useGvn() => getFlag(FLAG_USE_GVN);
   void setUseGvn() { setFlag(FLAG_USE_GVN); }
   // Does this node potentially affect control flow.
   bool isControlFlow() => false;
 
   // All isFunctions work on the propagated types.
   bool isArray() => propagatedType.isArray();
+  bool isReadableArray() => propagatedType.isReadableArray();
   bool isMutableArray() => propagatedType.isMutableArray();
   bool isBoolean() => propagatedType.isBoolean();
   bool isInteger() => propagatedType.isInteger();
   bool isDouble() => propagatedType.isDouble();
   bool isNumber() => propagatedType.isNumber();
   bool isString() => propagatedType.isString();
   bool isTypeUnknown() => propagatedType.isUnknown();
   bool isStringOrArray() => propagatedType.isStringOrArray();
+  bool isIndexablePrimitive() => propagatedType.isIndexablePrimitive();
   bool isNonPrimitive() => propagatedType.isNonPrimitive();
 
   /**
    * This is the type the instruction is guaranteed to have. It does not
    * take any propagation into account.
    */
   HType get guaranteedType() => HType.UNKNOWN;
   bool hasGuaranteedType() => !guaranteedType.isUnknown();
 
   /**
@@ skipping 357 matching lines @@
                      List<HInstruction> inputs)
       : super(selector, inputs);
   toString() => 'invoke interceptor: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeInterceptor(this);
 
   bool isLengthGetter() {
     return getter && name == const SourceString('length');
   }
 
   bool isLengthGetterOnStringOrArray() {
-    return isLengthGetter()
-        && inputs[1].isStringOrArray();
+    return isLengthGetter() && inputs[1].isIndexablePrimitive();
   }
 
   String get builtinJsName() {
     if (isLengthGetterOnStringOrArray()) {
       return 'length';
     } else if (name == const SourceString('add')
                && inputs[1].isMutableArray()) {
       return 'push';
     } else if (name == const SourceString('removeLast')
                && inputs[1].isMutableArray()) {
@@ skipping 12 matching lines @@
 
   HType computeTypeFromInputTypes() {
     if (isLengthGetterOnStringOrArray()) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input) {
     // 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.isStringOrArray()) {
+    if (input == inputs[1] && input.isIndexablePrimitive()) {
       if (name == const SourceString('add')
           || name == const SourceString('removeLast')) {
         return HType.MUTABLE_ARRAY;
       }
     }
     return HType.UNKNOWN;
   }
 
   void prepareGvn() {
     if (isLengthGetterOnStringOrArray()) {
@@ skipping 41 matching lines @@
   final DartString code;
   final HType foreignType;
   HForeign(this.code, DartString declaredType, List<HInstruction> inputs)
       : foreignType = computeTypeFromDeclaredType(declaredType),
         super(inputs);
   accept(HVisitor visitor) => visitor.visitForeign(this);
 
   static HType computeTypeFromDeclaredType(DartString declaredType) {
     if (declaredType.slowToString() == 'bool') return HType.BOOLEAN;
     if (declaredType.slowToString() == 'int') return HType.INTEGER;
-    if (declaredType.slowToString() == 'num') return HType.NUMBER;
+    if (declaredType.slowToString() == 'double') return HType.DOUBLE;
+    if (declaredType.slowToString() == 'num') return HType.INTEGER_OR_DOUBLE;
     if (declaredType.slowToString() == 'String') return HType.STRING;
     return HType.UNKNOWN;
   }
 
   HType get guaranteedType() => foreignType;
 }
 
 class HForeignNew extends HForeign {
   ClassElement element;
   HForeignNew(this.element, List<HInstruction> inputs)
@@ skipping 28 matching lines @@
       setAllSideEffects();
     }
   }
 
   bool get builtin() => left.isNumber() && right.isNumber();
 
   HType computeTypeFromInputTypes() {
     if (left.isInteger() && right.isInteger()) return left.propagatedType;
     if (left.isNumber()) {
       if (left.isDouble() || right.isDouble()) return HType.DOUBLE;
-      return HType.NUMBER;
+      return HType.INTEGER_OR_DOUBLE;
     }
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input) {
     // 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;
+      return HType.INTEGER_OR_DOUBLE;
     }
     // 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 IllegalArgumentException if it isn't. This would be similar
     // to the array case.
-    if (input == right && left.isNumber()) return HType.NUMBER;
+    if (input == right && left.isNumber()) return HType.INTEGER_OR_DOUBLE;
     return HType.UNKNOWN;
   }
 
   HType get likelyType() {
-    if (left.isTypeUnknown()) return HType.NUMBER;
+    if (left.isTypeUnknown()) return HType.INTEGER_OR_DOUBLE;
     return HType.UNKNOWN;
   }
 
   // TODO(1603): The class should be marked as abstract.
   abstract BinaryOperation get operation();
 }
 
 class HAdd extends HBinaryArithmetic {
   HAdd(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitAdd(this);
 
   bool get builtin() {
     return (left.isNumber() && right.isNumber())
             || (left.isString() && right.isString())
             || (left.isString() && right is HConstant);
   }
 
   HType computeTypeFromInputTypes() {
     if (left.isInteger() && right.isInteger()) return left.propagatedType;
     if (left.isNumber()) {
       if (left.isDouble() || right.isDouble()) return HType.DOUBLE;
-      return HType.NUMBER;
+      return HType.INTEGER_OR_DOUBLE;
     }
     if (left.isString()) return HType.STRING;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input) {
     // If the desired output type is an integer we want two integers as input.
     if (propagatedType.isInteger()) {
       return HType.INTEGER;
     }
     // TODO(floitsch): remove string specialization once string+ is removed
     // from dart2js.
     if (propagatedType.isString() || left.isString() || right.isString()) {
       return HType.STRING;
     }
     // If the desired output is a number or any of the inputs is a number
     // ask for a number. Note that we might return the input's (say 'left')
     // type depending on its (the 'left's) type. But that shouldn't matter.
     if (propagatedType.isNumber() || left.isNumber() || right.isNumber()) {
-      return HType.NUMBER;
+      return HType.INTEGER_OR_DOUBLE;
     }
     return HType.UNKNOWN;
   }
 
   HType get likelyType() {
     if (left.isString() || right.isString()) return HType.STRING;
-    if (left.isTypeUnknown() || left.isNumber()) return HType.NUMBER;
+    if (left.isTypeUnknown() || left.isNumber()) return HType.INTEGER_OR_DOUBLE;
     return HType.UNKNOWN;
   }
 
   AddOperation get operation() => const AddOperation();
 
   int typeCode() => 5;
   bool typeEquals(other) => other is HAdd;
   bool dataEquals(HInstruction other) => true;
 }
 
@@ skipping 178 matching lines @@
     HType operandType = operand.propagatedType;
     if (operandType.isNumber()) return operandType;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input) {
     // 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;
+    if (propagatedType.isUnknown()) return HType.INTEGER_OR_DOUBLE;
     return HType.UNKNOWN;
   }
 
-  HType get likelyType() => HType.NUMBER;
+  HType get likelyType() => HType.INTEGER_OR_DOUBLE;
 
   abstract UnaryOperation get operation();
 }
 
 class HNegate extends HInvokeUnary {
   HNegate(HStatic target, HInstruction input) : super(target, input);
   accept(HVisitor visitor) => visitor.visitNegate(this);
 
   NegateOperation get operation() => const NegateOperation();
   int typeCode() => 16;
@@ skipping 200 matching lines @@
   // different known types, we'll return a conflict -- otherwise we'll
   // simply return an unknown type.
   HType computeInputsType(bool unknownWins) {
     bool seenUnknown = false;
     HType candidateType = inputs[0].propagatedType;
     for (int i = 1, length = inputs.length; i < length; i++) {
       HType inputType = inputs[i].propagatedType;
       if (inputType.isUnknown()) {
         seenUnknown = true;
       } else {
-        candidateType = candidateType.combine(inputType);
+        candidateType = candidateType.union(inputType);

[ngeoffray, 2012/04/23 10:19:21]

Please add a simple comment or example on why this is a union here.

[floitsch, 2012/04/24 15:25:18]

Done.

         if (candidateType.isConflicting()) return HType.CONFLICTING;
       }
     }
     if (seenUnknown && unknownWins) return HType.UNKNOWN;
     return candidateType;
   }
 
   HType computeTypeFromInputTypes() {
     HType inputsType = computeInputsType(true);
     if (inputsType.isConflicting()) return HType.UNKNOWN;
@@ skipping 11 matching lines @@
     // Otherwise the input type must match the desired outgoing type.
     return propagatedType;
   }
 
   HType get likelyType() {
     HType agreedType = computeInputsType(false);
     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;
+    if (agreedType.isNumber()) return HType.INTEGER_OR_DOUBLE;
     return agreedType;
   }
 
   bool isLogicalOperator() => logicalOperatorType != IS_NOT_LOGICAL_OPERATOR;
 
   String logicalOperator() {
     assert(isLogicalOperator());
     if (logicalOperatorType == IS_AND) return "&&";
     assert(logicalOperatorType == IS_OR);
     return "||";
@@ skipping 22 matching lines @@
   HType computeTypeFromInputTypes() {
     if (left.isNumber()) return HType.BOOLEAN;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input) {
     // 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() || left.isNumber()) return HType.NUMBER;
+      if (left.isTypeUnknown() || left.isNumber()) {
+        return HType.INTEGER_OR_DOUBLE;
+      }
     }
     return HType.UNKNOWN;
   }
 
   HType get likelyType() => HType.BOOLEAN;
 
   bool get builtin() => left.isNumber() && right.isNumber();
   // TODO(1603): the class should be marked as abstract.
   abstract BinaryOperation get operation();
 }
@@ skipping 14 matching lines @@
     if (builtin) return HType.BOOLEAN;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input) {
     if (input == left && right.propagatedType.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.isNumber()) return HType.NUMBER;  // No need to be more precise.
+      // 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()) return HType.INTEGER_OR_DOUBLE;
       // String equality testing is much more common than array equality
       // testing.
       if (right.isStringOrArray()) return HType.STRING;
       return right.propagatedType;
     }
     // String equality testing is much more common than array equality testing.
     if (input == left && left.isStringOrArray()) {
       return HType.READABLE_ARRAY;
     }
     // String equality testing is much more common than array equality testing.
@@ skipping 148 matching lines @@
     if (input == receiver && (index.isTypeUnknown() || index.isNumber())) {
       return HType.STRING_OR_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;
   }
 
-  bool get builtin() => receiver.isStringOrArray() && index.isInteger();
+  bool get builtin() => receiver.isIndexablePrimitive() && index.isInteger();
 }
 
 class HIndexAssign extends HInvokeStatic {
   HIndexAssign(HStatic target,
                HInstruction receiver,
                HInstruction index,
                HInstruction value)
       : super(Selector.INDEX_SET,
               <HInstruction>[target, receiver, index, value]);
   toString() => 'index assign operator';
@@ skipping 162 matching lines @@
   final bool isAnd;
   final SubExpression left;
   final SubExpression right;
   final HBasicBlock joinBlock;
   HAndOrBlockInformation(this.isAnd,
                          this.left,
                          this.right,
                          this.joinBlock);
   bool accept(HBlockInformationVisitor visitor) => visitor.visitAndOrInfo(this);
 }