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 654 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);
-
-  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);
-
-  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 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;
-  /** A type is useful it is not unknown and not conflicting. */
-  bool isUseful() => this !== UNKNOWN && this !== CONFLICTING;
-
-  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() {
-    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) {
-    if (isUnknown()) return other;
-    if (other.isUnknown()) return this;
-    return getTypeFromFlag(this.flag & other.flag);
-  }
-}
-
-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);
-
-  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;
-  }
-
-  String toString() => type.toString();
-  Element lookupMember(SourceString name) {
-    ClassElement classElement = type.element;
-    return classElement.lookupMember(name);
-  }
-}
-
 class HInstruction implements Hashable {
   Element sourceElement;
 
   final int id;
   static int idCounter;
 
   final List<HInstruction> inputs;
   final List<HInstruction> usedBy;
 
   HBasicBlock block;
@@ skipping 32 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 isExtendableArray() => propagatedType.isExtendableArray();
   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 369 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()) {
+               && inputs[1].isExtendableArray()) {
       return 'push';
     } else if (name == const SourceString('removeLast')
-               && inputs[1].isMutableArray()) {
+               && inputs[1].isExtendableArray()) {
       return 'pop';
     }
     return null;
   }
 
   HType get guaranteedType() => HType.UNKNOWN;
 
   HType get likelyType() {
     // In general a length getter or method returns an int.
     if (name == const SourceString('length')) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
   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() == 'double') return HType.DOUBLE;
     if (declaredType.slowToString() == 'num') return HType.NUMBER;
     if (declaredType.slowToString() == 'String') return HType.STRING;
     return HType.UNKNOWN;
   }
 
   HType get guaranteedType() => foreignType;
 }
 
 class HForeignNew extends HForeign {
   ClassElement element;
@@ skipping 530 matching lines @@
   // different known types, we'll return a conflict -- otherwise we'll
   // simply return an unknown type.
   HType computeInputsType(bool unknownWins) {
     HType candidateType = inputs[0].propagatedType;
     bool seenUnknown = candidateType.isUnknown();
     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);
+        // 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);
         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 54 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.NUMBER;
+      }
     }
     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.NUMBER;
       // String equality testing is much more common than array equality
       // testing.
-      if (right.isStringOrArray()) return HType.STRING;
+      if (right.isIndexablePrimitive()) return HType.STRING;
       return right.propagatedType;
     }
     // String equality testing is much more common than array equality testing.
-    if (input == left && left.isStringOrArray()) {
+    if (input == left && left.isIndexablePrimitive()) {
       return HType.READABLE_ARRAY;
     }
     // String equality testing is much more common than array equality testing.
-    if (input == right && right.isStringOrArray()) {
+    if (input == right && right.isIndexablePrimitive()) {
       return HType.STRING;
     }
     return HType.UNKNOWN;
   }
 
   EqualsOperation get operation() => const EqualsOperation();
   int typeCode() => 19;
   bool typeEquals(other) => other is HEquals;
   bool dataEquals(HInstruction other) => true;
 }
@@ skipping 128 matching lines @@
     } else {
       setAllSideEffects();
     }
   }
 
   HInstruction get receiver() => inputs[1];
   HInstruction get index() => inputs[2];
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input) {
     if (input == receiver && (index.isTypeUnknown() || index.isNumber())) {
-      return HType.STRING_OR_ARRAY;
+      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;
   }
 
-  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);
 }