Introduce DartType.unaliased to avoid use of Resolution in the backend.

pkg/compiler/lib/src/typechecker.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.
 
 library dart2js.typechecker;
 
 import 'common/names.dart' show
     Identifiers;
 import 'common/resolution.dart' show
     Resolution;
@@ skipping 41 matching lines @@
     TypedefElement,
     VariableElement;
 import 'resolution/tree_elements.dart' show
     TreeElements;
 import 'resolution/class_members.dart' show
     MembersCreator;
 import 'tree/tree.dart';
 import 'util/util.dart' show
     Link,
     LinkBuilder;
-import '../compiler_new.dart' as api;
 
 class TypeCheckerTask extends CompilerTask {
   TypeCheckerTask(Compiler compiler) : super(compiler);
   String get name => "Type checker";
 
   void check(AstElement element) {
     if (element.isClass) return;
     if (element.isTypedef) return;
     ResolvedAst resolvedAst = element.resolvedAst;
     reporter.withCurrentElement(element.implementation, () {
@@ skipping 695 matching lines @@
           // This is an access of the special 'call' method implicitly defined
           // on 'Function'. This method can be called with any arguments, which
           // we ensure by giving it the type 'dynamic'.
           return new FunctionCallAccess(null, const DynamicType());
         }
       }
       return null;
     }
 
     DartType unaliasedBound =
-        Types.computeUnaliasedBound(compiler, receiverType);
+        Types.computeUnaliasedBound(resolution, receiverType);
     if (unaliasedBound.treatAsDynamic) {
       return new DynamicAccess();
     }
     InterfaceType interface =
-        Types.computeInterfaceType(compiler, unaliasedBound);
+        Types.computeInterfaceType(resolution, unaliasedBound);
     ElementAccess access = getAccess(memberName, unaliasedBound, interface);
     if (access != null) {
       return access;
     }
     if (receiverElement != null &&
         (receiverElement.isVariable || receiverElement.isParameter)) {
       Link<TypePromotion> typePromotions = typePromotionsMap[receiverElement];
       if (typePromotions != null) {
         while (!typePromotions.isEmpty) {
           TypePromotion typePromotion = typePromotions.head;
           if (!typePromotion.isValid) {
             DartType unaliasedBound =
-                Types.computeUnaliasedBound(compiler, typePromotion.type);
+                Types.computeUnaliasedBound(resolution, typePromotion.type);
             if (!unaliasedBound.treatAsDynamic) {
               InterfaceType interface =
-                  Types.computeInterfaceType(compiler, unaliasedBound);
+                  Types.computeInterfaceType(resolution, unaliasedBound);
               if (getAccess(memberName, unaliasedBound, interface) != null) {
                 reportTypePromotionHint(typePromotion);
               }
             }
           }
           typePromotions = typePromotions.tail;
         }
       }
     }
     // We didn't find a member with the correct name.  If this lookup is for a
@@ skipping 74 matching lines @@
   DartType lookupMemberType(Node node, DartType type, String name,
                             MemberKind memberKind,
                             {bool isHint: false}) {
     return lookupMember(node, type, name, memberKind, null, isHint: isHint)
         .computeType(resolution);
   }
 
   void analyzeArguments(Send send, Element element, DartType type,
                         [LinkBuilder<DartType> argumentTypes]) {
     Link<Node> arguments = send.arguments;
-    DartType unaliasedType = type.unalias(resolution);
+    type.computeUnaliased(resolution);
+    DartType unaliasedType = type.unaliased;
     if (identical(unaliasedType.kind, TypeKind.FUNCTION)) {
 
       /// Report [warning] including info(s) about the declaration of [element]
       /// or [type].
       void reportWarning(DiagnosticMessage warning) {
         // TODO(johnniwinther): Support pointing to individual parameters on
         // assignability warnings.
         List<DiagnosticMessage> infos = <DiagnosticMessage>[];
         Element declaration = element;
         if (declaration == null) {
@@ skipping 101 matching lines @@
                              [LinkBuilder<DartType> argumentTypes]) {
     DartType type = elementAccess.computeType(resolution);
     if (elementAccess.isCallable(compiler)) {
       analyzeArguments(node, elementAccess.element, type, argumentTypes);
     } else {
       reportTypeWarning(node, MessageKind.NOT_CALLABLE,
           {'elementName': elementAccess.name});
       analyzeArguments(node, elementAccess.element, const DynamicType(),
                        argumentTypes);
     }
-    type = type.unalias(resolution);
-    if (identical(type.kind, TypeKind.FUNCTION)) {
+    type.computeUnaliased(resolution);
+    type = type.unaliased;
+    if (type.isFunctionType) {
       FunctionType funType = type;
       return funType.returnType;
     } else {
       return const DynamicType();
     }
   }
 
   /**
    * Computes the [ElementAccess] for [name] on the [node] possibly using the
    * [element] provided for [node] by the resolver.
@@ skipping 116 matching lines @@
       //     class A<T, V> {}
       //     class B<S, U> extends A<S, int> {}
       // and a promotion from a [knownType] of `A<double, int>` to a
       // [shownType] of `B`.
       InterfaceType knownInterfaceType = knownType;
       ClassElement shownClass = shownType.element;
 
       // Compute `B<double, dynamic>` as the subtype of `A<double, int>` using
       // the relation between `A<S, int>` and `A<double, int>`.
       MoreSpecificSubtypeVisitor visitor =
-          new MoreSpecificSubtypeVisitor(compiler);
+          new MoreSpecificSubtypeVisitor(types);
       InterfaceType shownTypeGeneric = visitor.computeMoreSpecific(
           shownClass, knownInterfaceType);
 
       if (shownTypeGeneric != null &&
           types.isMoreSpecific(shownTypeGeneric, knownType)) {
         // This should be the case but we double-check.
         // TODO(johnniwinther): Ensure that we don't suggest malbounded types.
         return shownTypeGeneric;
       }
     }
@@ skipping 673 matching lines @@
     // TODO(johnniwinther): Move this to _CompilerCoreTypes.
     compiler.streamClass.ensureResolved(resolution);
     DartType streamOfDynamic = coreTypes.streamType();
     if (!types.isAssignable(expressionType, streamOfDynamic)) {
       reportMessage(node.expression,
           MessageKind.NOT_ASSIGNABLE,
           {'fromType': expressionType, 'toType': streamOfDynamic},
           isHint: true);
     } else {
       InterfaceType interfaceType =
-          Types.computeInterfaceType(compiler, expressionType);
+          Types.computeInterfaceType(resolution, expressionType);
       if (interfaceType != null) {
         InterfaceType streamType =
             interfaceType.asInstanceOf(compiler.streamClass);
         if (streamType != null) {
           DartType streamElementType = streamType.typeArguments.first;
           if (!types.isAssignable(streamElementType, elementType)) {
             reportMessage(node.expression,
                 MessageKind.FORIN_NOT_ASSIGNABLE,
                 {'currentType': streamElementType,
                  'expressionType': expressionType,
@@ skipping 146 matching lines @@
 
   visitTypedef(Typedef node) {
     // Do not typecheck [Typedef] nodes.
   }
 
   visitNode(Node node) {
     reporter.internalError(node,
         'Unexpected node ${node.getObjectDescription()} in the type checker.');
   }
 }