remove dependency on compiler from resolution

pkg/compiler/lib/src/resolution/class_hierarchy.dart

 // Copyright (c) 2015, 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.resolution.class_hierarchy;
 
 import '../common.dart';
-import '../common/resolution.dart' show Feature;
-import '../compiler.dart' show Compiler;
+import '../common/resolution.dart' show Feature, Resolution;
 import '../core_types.dart' show CoreClasses, CoreTypes;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart'
     show
         BaseClassElementX,
         ErroneousElementX,
         MixinApplicationElementX,
         SynthesizedConstructorElementX,
         TypeVariableElementX,
         UnnamedMixinApplicationElementX;
 import '../ordered_typeset.dart' show OrderedTypeSet, OrderedTypeSetBuilder;
 import '../tree/tree.dart';
 import '../util/util.dart' show Link, Setlet;
 import '../universe/call_structure.dart' show CallStructure;
 
 import 'enum_creator.dart';
 import 'members.dart' show lookupInScope;
 import 'registry.dart' show ResolutionRegistry;
 import 'resolution_common.dart' show CommonResolverVisitor, MappingVisitor;
 import 'scope.dart' show Scope, TypeDeclarationScope;
 
 class TypeDefinitionVisitor extends MappingVisitor<DartType> {
   Scope scope;
   final TypeDeclarationElement enclosingElement;
   TypeDeclarationElement get element => enclosingElement;
 
-  TypeDefinitionVisitor(Compiler compiler, TypeDeclarationElement element,
+  TypeDefinitionVisitor(Resolution resolution, TypeDeclarationElement element,
       ResolutionRegistry registry)
       : this.enclosingElement = element,
         scope = Scope.buildEnclosingScope(element),
-        super(compiler, registry);
+        super(resolution, registry);
 
-  CoreTypes get coreTypes => compiler.coreTypes;
+  CoreTypes get coreTypes => resolution.coreTypes;
 
   DartType get objectType => coreTypes.objectType;
 
   void resolveTypeVariableBounds(NodeList node) {
     if (node == null) return;
 
     Setlet<String> nameSet = new Setlet<String>();
     // Resolve the bounds of type variables.
     Iterator<DartType> types = element.typeVariables.iterator;
     Link<Node> nodeLink = node.nodes;
@@ skipping 57 matching lines @@
  * this may lead to cycles.
  *
  * This visitor can assume that the supertypes have already been
  * resolved, but it cannot call [ResolverTask.resolveClass] directly
  * or indirectly (through [ClassElement.ensureResolved]) for any other
  * types.
  */
 class ClassResolverVisitor extends TypeDefinitionVisitor {
   BaseClassElementX get element => enclosingElement;
 
-  ClassResolverVisitor(
-      Compiler compiler, ClassElement classElement, ResolutionRegistry registry)
-      : super(compiler, classElement, registry);
+  ClassResolverVisitor(Resolution resolution, ClassElement classElement,
+      ResolutionRegistry registry)
+      : super(resolution, classElement, registry);
 
   DartType visitClassNode(ClassNode node) {
     if (element == null) {
       throw reporter.internalError(node, 'element is null');
     }
     if (element.resolutionState != STATE_STARTED) {
       throw reporter.internalError(
           element, 'cyclic resolution of class $element');
     }
 
@@ skipping 71 matching lines @@
             .signatureApplies(superConstructor.functionSignature)) {
           MessageKind kind = MessageKind.NO_MATCHING_CONSTRUCTOR_FOR_IMPLICIT;
           reporter.reportErrorMessage(node, kind);
           superMember = new ErroneousElementX(kind, {}, '', element);
         }
       }
       FunctionElement constructor =
           new SynthesizedConstructorElementX.forDefault(superMember, element);
       if (superMember.isMalformed) {
         ErroneousElement erroneousElement = superMember;
-        compiler.registerCompiletimeError(
+        resolution.registerCompileTimeError(
             constructor,
             reporter.createMessage(node, erroneousElement.messageKind,
                 erroneousElement.messageArguments));
       }
       element.setDefaultConstructor(constructor, reporter);
     }
     return element.computeType(resolution);
   }
 
   @override
@@ skipping 10 matching lines @@
     element.supertype = objectType;
     element.interfaces = const Link<DartType>();
     calculateAllSupertypes(element);
 
     if (node.names.nodes.isEmpty) {
       reporter.reportErrorMessage(
           node, MessageKind.EMPTY_ENUM_DECLARATION, {'enumName': element.name});
     }
 
     EnumCreator creator =
-        new EnumCreator(reporter, compiler.coreTypes, element);
+        new EnumCreator(reporter, resolution.coreTypes, element);
     creator.createMembers();
     return enumType;
   }
 
   /// Resolves the mixed type for [mixinNode] and checks that the mixin type
   /// is a valid, non-blacklisted interface type. The mixin type is returned.
   DartType checkMixinType(TypeAnnotation mixinNode) {
     DartType mixinType = resolveType(mixinNode);
     if (isBlackListed(mixinType)) {
       reporter.reportErrorMessage(
@@ skipping 40 matching lines @@
     }
     doApplyMixinTo(element, supertype, checkMixinType(link.head));
     return element.computeType(resolution);
   }
 
   DartType applyMixin(DartType supertype, DartType mixinType, Node node) {
     String superName = supertype.name;
     String mixinName = mixinType.name;
     MixinApplicationElementX mixinApplication =
         new UnnamedMixinApplicationElementX("${superName}+${mixinName}",
-            element, compiler.idGenerator.getNextFreeId(), node);
+            element, resolution.idGenerator.getNextFreeId(), node);
     // Create synthetic type variables for the mixin application.
     List<DartType> typeVariables = <DartType>[];
     int index = 0;
     for (TypeVariableType type in element.typeVariables) {
       TypeVariableElementX typeVariableElement = new TypeVariableElementX(
           type.name, mixinApplication, index, type.element.node);
       TypeVariableType typeVariable = new TypeVariableType(typeVariableElement);
       typeVariables.add(typeVariable);
       index++;
     }
@@ skipping 35 matching lines @@
     constructor.computeType(resolution);
     return constructor;
   }
 
   void doApplyMixinTo(MixinApplicationElementX mixinApplication,
       DartType supertype, DartType mixinType) {
     Node node = mixinApplication.parseNode(resolution.parsingContext);
 
     if (mixinApplication.supertype != null) {
       // [supertype] is not null if there was a cycle.
-      assert(invariant(node, compiler.compilationFailed));
+      assert(invariant(node, reporter.hasReportedError));
       supertype = mixinApplication.supertype;
       assert(invariant(node, supertype.isObject));
     } else {
       mixinApplication.supertype = supertype;
     }
 
     // Named mixin application may have an 'implements' clause.
     NamedMixinApplication namedMixinApplication =
         node.asNamedMixinApplication();
     Link<DartType> interfaces = (namedMixinApplication != null)
@@ skipping 164 matching lines @@
    * first.
    */
   void calculateAllSupertypes(BaseClassElementX cls) {
     if (cls.allSupertypesAndSelf != null) return;
     final DartType supertype = cls.supertype;
     if (supertype != null) {
       cls.allSupertypesAndSelf = new OrderedTypeSetBuilder(cls,
               reporter: reporter, objectType: coreTypes.objectType)
           .createOrderedTypeSet(supertype, cls.interfaces);
     } else {
-      assert(cls == compiler.coreClasses.objectClass);
+      assert(cls == resolution.coreClasses.objectClass);
       cls.allSupertypesAndSelf =
           new OrderedTypeSet.singleton(cls.computeType(resolution));
     }
   }
 
   isBlackListed(DartType type) {
     LibraryElement lib = element.library;
-    return !identical(lib, compiler.coreLibrary) &&
+    return !identical(lib, resolution.coreLibrary) &&
         !resolution.target.isTargetSpecificLibrary(lib) &&
         (type.isDynamic ||
             type == coreTypes.boolType ||
             type == coreTypes.numType ||
             type == coreTypes.intType ||
             type == coreTypes.doubleType ||
             type == coreTypes.stringType ||
             type == coreTypes.nullType);
   }
 }
 
 class ClassSupertypeResolver extends CommonResolverVisitor {
   Scope context;
   ClassElement classElement;
 
-  ClassSupertypeResolver(Compiler compiler, ClassElement cls)
+  ClassSupertypeResolver(Resolution resolution, ClassElement cls)
       : context = Scope.buildEnclosingScope(cls),
         this.classElement = cls,
-        super(compiler);
+        super(resolution);
 
-  CoreClasses get coreClasses => compiler.coreClasses;
+  CoreClasses get coreClasses => resolution.coreClasses;
 
   void loadSupertype(ClassElement element, Node from) {
     if (!element.isResolved) {
-      compiler.resolver.loadSupertypes(element, from);
+      resolution.resolver.loadSupertypes(element, from);
       element.ensureResolved(resolution);
     }
   }
 
   void visitNodeList(NodeList node) {
     if (node != null) {
       for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
         link.head.accept(this);
       }
     }
@@ skipping 53 matching lines @@
     Identifier selector = node.selector.asIdentifier();
     var e = prefixElement.lookupLocalMember(selector.source);
     if (e == null || !e.impliesType) {
       reporter.reportErrorMessage(node.selector,
           MessageKind.CANNOT_RESOLVE_TYPE, {'typeName': node.selector});
       return;
     }
     loadSupertype(e, node);
   }
 }