Introduce DartType super hierarchy based on Entity

pkg/compiler/lib/src/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.
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/backend_api.dart' show BackendClasses;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
-import '../dart_types.dart';
 import '../elements/elements.dart'
     show Entity, JumpTarget, LabelDefinition, Local;
 import '../elements/entities.dart';
+import '../elements/types.dart';
 import '../io/source_information.dart';
 import '../js/js.dart' as js;
 import '../js_backend/backend_helpers.dart' show BackendHelpers;
 import '../js_backend/js_backend.dart';
 import '../native/native.dart' as native;
 import '../tree/dartstring.dart' as ast;
 import '../types/constants.dart' show computeTypeMask;
 import '../types/types.dart';
 import '../universe/selector.dart' show Selector;
 import '../universe/side_effects.dart' show SideEffects;
@@ skipping 1324 matching lines @@
           type, kind, closedWorld.commonMasks.dynamicType, this);
     }
     assert(type.isInterfaceType);
     if (kind == HTypeConversion.BOOLEAN_CONVERSION_CHECK) {
       // Boolean conversion checks work on non-nullable booleans.
       return new HTypeConversion(
           type, kind, closedWorld.commonMasks.boolType, this);
     } else if (kind == HTypeConversion.CHECKED_MODE_CHECK && !type.treatAsRaw) {
       throw 'creating compound check to $type (this = ${this})';
     } else {
-      Entity cls = type.element;
-      TypeMask subtype = new TypeMask.subtype(cls, closedWorld);
+      InterfaceType interfaceType = type;
+      TypeMask subtype =
+          new TypeMask.subtype(interfaceType.element, closedWorld);
       return new HTypeConversion(type, kind, subtype, this);
     }
   }
 
   /**
    * Return whether the instructions do not belong to a loop or
    * belong to the same loop.
    */
   bool hasSameLoopHeaderAs(HInstruction other) {
     return block.enclosingLoopHeader == other.block.enclosingLoopHeader;
@@ skipping 1417 matching lines @@
   final Selector receiverTypeCheckSelector;
 
   TypeMask checkedType; // Not final because we refine it.
 
   HTypeConversion(
       this.typeExpression, this.kind, TypeMask type, HInstruction input,
       {this.receiverTypeCheckSelector})
       : checkedType = type,
         super(<HInstruction>[input], type) {
     assert(!isReceiverTypeCheck || receiverTypeCheckSelector != null);
-    assert(typeExpression == null || typeExpression.kind != TypeKind.TYPEDEF);
+    assert(typeExpression == null || !typeExpression.isTypedef);
     sourceElement = input.sourceElement;
   }
 
   HTypeConversion.withTypeRepresentation(this.typeExpression, this.kind,
       TypeMask type, HInstruction input, HInstruction typeRepresentation)
       : checkedType = type,
         super(<HInstruction>[input, typeRepresentation], type),
         receiverTypeCheckSelector = null {
-    assert(typeExpression.kind != TypeKind.TYPEDEF);
+    assert(!typeExpression.isTypedef);
     sourceElement = input.sourceElement;
   }
 
   HTypeConversion.viaMethodOnType(this.typeExpression, this.kind, TypeMask type,
       HInstruction reifiedType, HInstruction input)
       : checkedType = type,
         super(<HInstruction>[reifiedType, input], type),
         receiverTypeCheckSelector = null {
     // This form is currently used only for function types.
     assert(typeExpression.isFunctionType);
@@ skipping 439 matching lines @@
   HInstruction get object => inputs.single;
 
   accept(HVisitor visitor) => visitor.visitTypeInfoReadVariable(this);
 
   bool canThrow() => false;
 
   int typeCode() => HInstruction.TYPE_INFO_READ_VARIABLE_TYPECODE;
   bool typeEquals(HInstruction other) => other is HTypeInfoReadVariable;
 
   bool dataEquals(HTypeInfoReadVariable other) {
-    return variable.element == other.variable.element;
+    return variable == other.variable;
   }
 
   String toString() => 'HTypeInfoReadVariable($variable)';
 }
 
 enum TypeInfoExpressionKind { COMPLETE, INSTANCE }
 
 /// Constructs a representation of a closed or ground-term type (that is, a type
 /// without type variables).
 ///
@@ skipping 97 matching lines @@
   }
 
   accept(HVisitor visitor) => visitor.visitReadTypeVariable(this);
 
   bool canThrow() => false;
 
   int typeCode() => HInstruction.READ_TYPE_VARIABLE_TYPECODE;
   bool typeEquals(HInstruction other) => other is HReadTypeVariable;
 
   bool dataEquals(HReadTypeVariable other) {
-    return dartType.element == other.dartType.element &&
-        hasReceiver == other.hasReceiver;
+    return dartType == other.dartType && hasReceiver == other.hasReceiver;
   }
 }
 
 abstract class HRuntimeType extends HInstruction {
   final DartType dartType;
 
   HRuntimeType(
       List<HInstruction> inputs, this.dartType, TypeMask instructionType)
       : super(inputs, instructionType) {
     setUseGvn();
@@ skipping 52 matching lines @@
 class HDynamicType extends HRuntimeType {
   HDynamicType(DynamicType dartType, TypeMask instructionType)
       : super(const <HInstruction>[], dartType, instructionType);
 
   accept(HVisitor visitor) => visitor.visitDynamicType(this);
 
   int typeCode() => HInstruction.DYNAMIC_TYPE_TYPECODE;
 
   bool typeEquals(HInstruction other) => other is HDynamicType;
 }