Rename Type to DartType to avoid conflicts with the class Type in the core library.

lib/compiler/implementation/ssa/types.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.
 
 abstract class HType {
   const HType();
 
   /**
    * Returns an [HType] that represents [type] and all types that have
    * [type] as supertype.
    */
-  factory HType.fromBoundedType(Type type,
+  factory HType.fromBoundedType(DartType type,
                                 Compiler compiler,
                                 [bool canBeNull = false]) {
     Element element = type.element;
     if (element.kind === ElementKind.TYPE_VARIABLE) {
       // TODO(ngeoffray): Replace object type with [type].
       return new HBoundedPotentialPrimitiveType(
           compiler.objectClass.computeType(compiler), canBeNull);
     }
 
     if (element === compiler.intClass) {
@@ skipping 57 matching lines @@
   bool isExact() => false;
 
   bool canBePrimitive() => false;
   bool canBeNull() => false;
 
   /** A type is useful it is not unknown, not conflicting, and not null. */
   bool isUseful() => !isUnknown() && !isConflicting() && !isNull();
   /** Alias for isReadableArray. */
   bool isArray() => isReadableArray();
 
-  abstract Type computeType(Compiler compiler);
+  abstract DartType computeType(Compiler compiler);
 
   /**
    * The intersection of two types is the intersection of its values. For
    * example:
    *   * INTEGER.intersect(NUMBER) => INTEGER.
    *   * DOUBLE.intersect(INTEGER) => CONFLICTING.
    *   * MUTABLE_ARRAY.intersect(READABLE_ARRAY) => MUTABLE_ARRAY.
    *
    * When there is no predefined type to represent the intersection returns
    * [CONFLICTING].
@@ skipping 17 matching lines @@
    */
   abstract HType union(HType other);
 }
 
 /** Used to represent [HType.UNKNOWN] and [HType.CONFLICTING]. */
 abstract class HAnalysisType extends HType {
   final String name;
   const HAnalysisType(this.name);
   String toString() => name;
 
-  Type computeType(Compiler compiler) => null;
+  DartType computeType(Compiler compiler) => null;
 }
 
 class HUnknownType extends HAnalysisType {
   const HUnknownType() : super("unknown");
   bool canBePrimitive() => true;
   bool canBeNull() => true;
 
   HType union(HType other) => this;
   HType intersection(HType other) => other;
 }
@@ skipping 12 matching lines @@
   bool isPrimitive() => true;
   bool canBePrimitive() => true;
 }
 
 class HNullType extends HPrimitiveType {
   const HNullType();
   bool canBeNull() => true;
   bool isNull() => true;
   String toString() => 'null';
 
-  Type computeType(Compiler compiler) => null;
+  DartType computeType(Compiler compiler) => null;
 
   HType union(HType other) {
     if (other.isConflicting()) return HType.NULL;
     if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isString()) return HType.STRING_OR_NULL;
     if (other.isInteger()) return HType.INTEGER_OR_NULL;
     if (other.isDouble()) return HType.DOUBLE_OR_NULL;
     if (other.isNumber()) return HType.NUMBER_OR_NULL;
     if (other.isBoolean()) return HType.BOOLEAN_OR_NULL;
     if (!other.canBeNull()) return HType.UNKNOWN;
@@ skipping 12 matching lines @@
   const HPrimitiveOrNullType();
   bool canBePrimitive() => true;
   bool canBeNull() => true;
 }
 
 class HBooleanOrNullType extends HPrimitiveOrNullType {
   const HBooleanOrNullType();
   String toString() => "boolean or null";
   bool isBooleanOrNull() => true;
 
-  Type computeType(Compiler compiler) {
+  DartType computeType(Compiler compiler) {
     return compiler.boolClass.computeType(compiler);
   }
 
   HType union(HType other) {
     if (other.isConflicting()) return HType.BOOLEAN_OR_NULL;
     if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isBooleanOrNull()) return HType.BOOLEAN_OR_NULL;
     if (other.isBoolean()) return HType.BOOLEAN_OR_NULL;
     if (other.isNull()) return HType.BOOLEAN_OR_NULL;
     return HType.UNKNOWN;
   }
 
   HType intersection(HType other) {
     if (other.isUnknown()) return HType.BOOLEAN_OR_NULL;
     if (other.isBooleanOrNull()) return HType.BOOLEAN_OR_NULL;
     if (other.isBoolean()) return HType.BOOLEAN;
     if (other.canBeNull()) return HType.NULL;
     return HType.CONFLICTING;
   }
 }
 
 class HBooleanType extends HPrimitiveType {
   const HBooleanType();
   bool isBoolean() => true;
   String toString() => "boolean";
 
-  Type computeType(Compiler compiler) {
+  DartType computeType(Compiler compiler) {
     return compiler.boolClass.computeType(compiler);
   }
 
   HType union(HType other) {
     if (other.isConflicting()) return HType.BOOLEAN;
     if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isBoolean()) return HType.BOOLEAN;
     if (other.isBooleanOrNull()) return HType.BOOLEAN_OR_NULL;
     if (other.isNull()) return HType.BOOLEAN_OR_NULL;
     return HType.UNKNOWN;
   }
 
   HType intersection(HType other) {
     if (other.isUnknown()) return HType.BOOLEAN;
     if (other.isBooleanOrNull()) return HType.BOOLEAN;
     if (other.isBoolean()) return HType.BOOLEAN;
     return HType.CONFLICTING;
   }
 }
 
 class HNumberOrNullType extends HPrimitiveOrNullType {
   const HNumberOrNullType();
   bool isNumberOrNull() => true;
   String toString() => "number or null";
 
-  Type computeType(Compiler compiler) {
+  DartType computeType(Compiler compiler) {
     return compiler.numClass.computeType(compiler);
   }
 
   HType union(HType other) {
     if (other.isConflicting()) return HType.NUMBER_OR_NULL;
     if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isNumberOrNull()) return HType.NUMBER_OR_NULL;
     if (other.isNumber()) return HType.NUMBER_OR_NULL;
     if (other.isNull()) return HType.NUMBER_OR_NULL;
     return HType.UNKNOWN;
@@ skipping 10 matching lines @@
     if (other.canBeNull()) return HType.NULL;
     return HType.CONFLICTING;
   }
 }
 
 class HNumberType extends HPrimitiveType {
   const HNumberType();
   bool isNumber() => true;
   String toString() => "number";
 
-  Type computeType(Compiler compiler) {
+  DartType computeType(Compiler compiler) {
     return compiler.numClass.computeType(compiler);
   }
 
   HType union(HType other) {
     if (other.isConflicting()) return HType.NUMBER;
     if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isNumber()) return HType.NUMBER;
     if (other.isNumberOrNull()) return HType.NUMBER_OR_NULL;
     if (other.isNull()) return HType.NUMBER_OR_NULL;
     return HType.UNKNOWN;
   }
 
   HType intersection(HType other) {
     if (other.isUnknown()) return HType.NUMBER;
     if (other.isNumber()) return other;
     if (other.isIntegerOrNull()) return HType.INTEGER;
     if (other.isDoubleOrNull()) return HType.DOUBLE;
     if (other.isNumberOrNull()) return HType.NUMBER;
     return HType.CONFLICTING;
   }
 }
 
 class HIntegerOrNullType extends HNumberOrNullType {
   const HIntegerOrNullType();
   bool isIntegerOrNull() => true;
   String toString() => "integer or null";
 
-  Type computeType(Compiler compiler) {
+  DartType computeType(Compiler compiler) {
     return compiler.intClass.computeType(compiler);
   }
 
   HType union(HType other) {
     if (other.isConflicting()) return HType.INTEGER_OR_NULL;
     if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isIntegerOrNull()) return HType.INTEGER_OR_NULL;
     if (other.isInteger()) return HType.INTEGER_OR_NULL;
     if (other.isNumber()) return HType.NUMBER_OR_NULL;
     if (other.isNumberOrNull()) return HType.NUMBER_OR_NULL;
@@ skipping 12 matching lines @@
     if (other.canBeNull()) return HType.NULL;
     return HType.CONFLICTING;
   }
 }
 
 class HIntegerType extends HNumberType {
   const HIntegerType();
   bool isInteger() => true;
   String toString() => "integer";
 
-  Type computeType(Compiler compiler) {
+  DartType computeType(Compiler compiler) {
     return compiler.intClass.computeType(compiler);
   }
 
   HType union(HType other) {
     if (other.isConflicting()) return HType.INTEGER;
     if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isInteger()) return HType.INTEGER;
     if (other.isIntegerOrNull()) return HType.INTEGER_OR_NULL;
     if (other.isNumber()) return HType.NUMBER;
     if (other.isNumberOrNull()) return HType.NUMBER_OR_NULL;
@@ skipping 11 matching lines @@
     if (other.isNumberOrNull()) return HType.INTEGER;
     return HType.CONFLICTING;
   }
 }
 
 class HDoubleOrNullType extends HNumberOrNullType {
   const HDoubleOrNullType();
   bool isDoubleOrNull() => true;
   String toString() => "double or null";
 
-  Type computeType(Compiler compiler) {
+  DartType computeType(Compiler compiler) {
     return compiler.doubleClass.computeType(compiler);
   }
 
   HType union(HType other) {
     if (other.isConflicting()) return HType.DOUBLE_OR_NULL;
     if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isDoubleOrNull()) return HType.DOUBLE_OR_NULL;
     if (other.isDouble()) return HType.DOUBLE_OR_NULL;
     if (other.isNumber()) return HType.NUMBER_OR_NULL;
     if (other.isNumberOrNull()) return HType.NUMBER_OR_NULL;
@@ skipping 12 matching lines @@
     if (other.canBeNull()) return HType.NULL;
     return HType.CONFLICTING;
   }
 }
 
 class HDoubleType extends HNumberType {
   const HDoubleType();
   bool isDouble() => true;
   String toString() => "double";
 
-  Type computeType(Compiler compiler) {
+  DartType computeType(Compiler compiler) {
     return compiler.doubleClass.computeType(compiler);
   }
 
   HType union(HType other) {
     if (other.isConflicting()) return HType.DOUBLE;
     if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isDouble()) return HType.DOUBLE;
     if (other.isDoubleOrNull()) return HType.DOUBLE_OR_NULL;
     if (other.isNumber()) return HType.NUMBER;
     if (other.isNumberOrNull()) return HType.NUMBER_OR_NULL;
@@ skipping 11 matching lines @@
     if (other.isNumberOrNull()) return HType.DOUBLE;
     return HType.CONFLICTING;
   }
 }
 
 class HIndexablePrimitiveType extends HPrimitiveType {
   const HIndexablePrimitiveType();
   bool isIndexablePrimitive() => true;
   String toString() => "indexable";
 
-  Type computeType(Compiler compiler) {
+  DartType computeType(Compiler compiler) {
     // TODO(ngeoffray): Represent union types.
     return null;
   }
 
   HType union(HType other) {
     if (other.isConflicting()) return HType.INDEXABLE_PRIMITIVE;
     if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isIndexablePrimitive()) return HType.INDEXABLE_PRIMITIVE;
     if (other is HBoundedPotentialPrimitiveString) {
       // TODO(ngeoffray): Represent union types.
@@ skipping 13 matching lines @@
     if (other is HBoundedPotentialPrimitiveArray) return HType.READABLE_ARRAY;
     return HType.CONFLICTING;
   }
 }
 
 class HStringOrNullType extends HPrimitiveOrNullType {
   const HStringOrNullType();
   bool isStringOrNull() => true;
   String toString() => "String or null";
 
-  Type computeType(Compiler compiler) {
+  DartType computeType(Compiler compiler) {
     return compiler.stringClass.computeType(compiler);
   }
 
   HType union(HType other) {
     if (other.isConflicting()) return HType.STRING_OR_NULL;
     if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isString()) return HType.STRING_OR_NULL;
     if (other.isStringOrNull()) return HType.STRING_OR_NULL;
     if (other.isIndexablePrimitive()) {
       // We don't have a type that represents the nullable indexable
@@ skipping 24 matching lines @@
     if (other.canBeNull()) return HType.NULL;
     return HType.CONFLICTING;
   }
 }
 
 class HStringType extends HIndexablePrimitiveType {
   const HStringType();
   bool isString() => true;
   String toString() => "String";
 
-  Type computeType(Compiler compiler) {
+  DartType computeType(Compiler compiler) {
     return compiler.stringClass.computeType(compiler);
   }
 
   HType union(HType other) {
     if (other.isConflicting()) return HType.STRING;
     if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isString()) return HType.STRING;
     if (other.isStringOrNull()) return HType.STRING_OR_NULL;
     if (other.isIndexablePrimitive()) return HType.INDEXABLE_PRIMITIVE;
     if (other is HBoundedPotentialPrimitiveString) return other;
@@ skipping 10 matching lines @@
     if (other is HBoundedPotentialPrimitiveString) return HType.STRING;
     return HType.CONFLICTING;
   }
 }
 
 class HReadableArrayType extends HIndexablePrimitiveType {
   const HReadableArrayType();
   bool isReadableArray() => true;
   String toString() => "readable array";
 
-  Type computeType(Compiler compiler) {
+  DartType computeType(Compiler compiler) {
     return compiler.listClass.computeType(compiler);
   }
 
   HType union(HType other) {
     if (other.isConflicting()) return HType.READABLE_ARRAY;
     if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isReadableArray()) return HType.READABLE_ARRAY;
     if (other.isIndexablePrimitive()) return HType.INDEXABLE_PRIMITIVE;
     if (other is HBoundedPotentialPrimitiveArray) return other;
     return HType.UNKNOWN;
@@ skipping 54 matching lines @@
     if (other.isUnknown()) return HType.EXTENDABLE_ARRAY;
     if (other.isExtendableArray()) return HType.EXTENDABLE_ARRAY;
     if (other.isString()) return HType.CONFLICTING;
     if (other.isIndexablePrimitive()) return HType.EXTENDABLE_ARRAY;
     if (other is HBoundedPotentialPrimitiveArray) return HType.EXTENDABLE_ARRAY;
     return HType.CONFLICTING;
   }
 }
 
 class HBoundedType extends HType {
-  final Type type;
+  final DartType type;
   final bool _canBeNull;
   final bool _isExact;
 
   toString() {
     return 'BoundedType($type, $_canBeNull, $_isExact)';
   }
 
   bool canBeNull() => _canBeNull;
 
   bool isExact() => _isExact;
 
-  const HBoundedType(Type this.type,
+  const HBoundedType(DartType this.type,
                      [bool canBeNull = false, isExact = false])
       : _canBeNull = canBeNull, _isExact = isExact;
-  const HBoundedType.exact(Type type) : this(type, isExact: true);
-  const HBoundedType.withNull(Type type) : this(type, canBeNull: true);
-  const HBoundedType.nonNull(Type type) : this(type);
+  const HBoundedType.exact(DartType type) : this(type, isExact: true);
+  const HBoundedType.withNull(DartType type) : this(type, canBeNull: true);
+  const HBoundedType.nonNull(DartType type) : this(type);
 
-  Type computeType(Compiler compiler) => type;
+  DartType computeType(Compiler compiler) => type;
 
   Element lookupMember(SourceString name) {
     if (!isExact()) return null;
     ClassElement classElement = type.element;
     return classElement.lookupMember(name);
   }
 
   HType intersection(HType other) {
     assert(!(isExact() && canBeNull()));
     if (other.isNull()) return canBeNull() ? HType.NULL : HType.CONFLICTING;
@@ skipping 37 matching lines @@
       if (isExact()) return other;
       if (other.isExact()) return this;
       return canBeNull() ? this : other;
     }
     if (other.isConflicting()) return this;
     return HType.UNKNOWN;
   }
 }
 
 class HBoundedPotentialPrimitiveType extends HBoundedType {
-  const HBoundedPotentialPrimitiveType(Type type, bool canBeNull)
+  const HBoundedPotentialPrimitiveType(DartType type, bool canBeNull)
       : super(type, canBeNull, false);
   bool canBePrimitive() => true;
 }
 
 class HBoundedPotentialPrimitiveArray extends HBoundedPotentialPrimitiveType {
-  const HBoundedPotentialPrimitiveArray(Type type, bool canBeNull)
+  const HBoundedPotentialPrimitiveArray(DartType type, bool canBeNull)
       : super(type, canBeNull);
 
   HType union(HType other) {
     if (other.isString()) return HType.UNKNOWN;
     if (other.isReadableArray()) return this;
     // TODO(ngeoffray): implement union types.
     if (other.isIndexablePrimitive()) return HType.UNKNOWN;
     if (other.isNull()) {
       if (canBeNull()) {
         return this;
       } else {
         return new HBoundedPotentialPrimitiveArray(type, true);
       }
     }
     return super.union(other);
   }
 
   HType intersection(HType other) {
     if (other.isString()) return HType.CONFLICTING;
     if (other.isReadableArray()) return other;
     if (other.isIndexablePrimitive()) return HType.READABLE_ARRAY;
     return super.intersection(other);
   }
 }
 
 class HBoundedPotentialPrimitiveString extends HBoundedPotentialPrimitiveType {
-  const HBoundedPotentialPrimitiveString(Type type, bool canBeNull)
+  const HBoundedPotentialPrimitiveString(DartType type, bool canBeNull)
       : super(type, canBeNull);
 
   HType union(HType other) {
     if (other.isString()) return this;
     if (other.isStringOrNull()) {
       if (canBeNull()) {
         return this;
       } else {
         return new HBoundedPotentialPrimitiveString(type, true);
       }
@@ skipping 29 matching lines @@
   operator [](HInstruction instruction) {
     HType result = _map[instruction];
     if (result == null) return instruction.guaranteedType;
     return result;
   }
 
   operator []=(HInstruction instruction, HType value) {
     _map[instruction] = value;
   }
 }