Add Resolution and Parsing interfaces for computeType, ensureResolved and parseNode.

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 '../compiler.dart' show
     Compiler;
 import '../dart_types.dart';
 import '../diagnostics/invariant.dart' show
@@ skipping 124 matching lines @@
 
   DartType visitClassNode(ClassNode node) {
     if (element == null) {
       throw compiler.internalError(node, 'element is null');
     }
     if (element.resolutionState != STATE_STARTED) {
       throw compiler.internalError(element,
           'cyclic resolution of class $element');
     }
 
-    element.computeType(compiler);
+    element.computeType(resolution);
     scope = new TypeDeclarationScope(scope, element);
     // TODO(ahe): It is not safe to call resolveTypeVariableBounds yet.
     // As a side-effect, this may get us back here trying to
     // resolve this class again.
     resolveTypeVariableBounds(node.typeParameters);
 
     // Setup the supertype for the element (if there is a cycle in the
     // class hierarchy, it has already been set to Object).
     if (element.supertype == null && node.superclass != null) {
       MixinApplication superMixin = node.superclass.asMixinApplication();
@@ skipping 15 matching lines @@
     // of Object - the JavaScript backend chooses between Object and
     // Interceptor.
     if (element.supertype == null) {
       ClassElement superElement = registry.defaultSuperclass(element);
       // Avoid making the superclass (usually Object) extend itself.
       if (element != superElement) {
         if (superElement == null) {
           compiler.internalError(node,
               "Cannot resolve default superclass for $element.");
         } else {
-          superElement.ensureResolved(compiler);
+          superElement.ensureResolved(resolution);
         }
-        element.supertype = superElement.computeType(compiler);
+        element.supertype = superElement.computeType(resolution);
       }
     }
 
     if (element.interfaces == null) {
       element.interfaces = resolveInterfaces(node.interfaces, node.superclass);
     } else {
       assert(invariant(element, element.hasIncompleteHierarchy));
     }
     calculateAllSupertypes(element);
 
     if (!element.hasConstructor) {
       Element superMember = element.superclass.localLookup('');
       if (superMember == null || !superMember.isGenerativeConstructor) {
         MessageKind kind = MessageKind.CANNOT_FIND_CONSTRUCTOR;
         Map arguments = {'constructorName': ''};
         // TODO(ahe): Why is this a compile-time error? Or if it is an error,
         // why do we bother to registerThrowNoSuchMethod below?
         compiler.reportErrorMessage(node, kind, arguments);
         superMember = new ErroneousElementX(
             kind, arguments, '', element);
         registry.registerThrowNoSuchMethod();
       } else {
         ConstructorElement superConstructor = superMember;
-        superConstructor.computeType(compiler);
+        superConstructor.computeType(resolution);
         if (!CallStructure.NO_ARGS.signatureApplies(
                 superConstructor.functionSignature)) {
           MessageKind kind = MessageKind.NO_MATCHING_CONSTRUCTOR_FOR_IMPLICIT;
           compiler.reportErrorMessage(node, kind);
           superMember = new ErroneousElementX(kind, {}, '', element);
         }
       }
       FunctionElement constructor =
           new SynthesizedConstructorElementX.forDefault(superMember, element);
       if (superMember.isErroneous) {
         compiler.elementsWithCompileTimeErrors.add(constructor);
       }
       element.setDefaultConstructor(constructor, compiler);
     }
-    return element.computeType(compiler);
+    return element.computeType(resolution);
   }
 
   @override
   DartType visitEnum(Enum node) {
     if (element == null) {
       throw compiler.internalError(node, 'element is null');
     }
     if (element.resolutionState != STATE_STARTED) {
       throw compiler.internalError(element,
           'cyclic resolution of class $element');
     }
 
-    InterfaceType enumType = element.computeType(compiler);
-    element.supertype = compiler.objectClass.computeType(compiler);
+    InterfaceType enumType = element.computeType(resolution);
+    element.supertype = compiler.coreTypes.objectType;
     element.interfaces = const Link<DartType>();
     calculateAllSupertypes(element);
 
     if (node.names.nodes.isEmpty) {
       compiler.reportErrorMessage(
           node,
           MessageKind.EMPTY_ENUM_DECLARATION,
           {'enumName': element.name});
     }
 
@@ skipping 39 matching lines @@
     }
 
     if (identical(node.classKeyword.stringValue, 'typedef')) {
       // TODO(aprelev@gmail.com): Remove this deprecation diagnostic
       // together with corresponding TODO in parser.dart.
       compiler.reportWarningMessage(
           node.classKeyword,
           MessageKind.DEPRECATED_TYPEDEF_MIXIN_SYNTAX);
     }
 
-    element.computeType(compiler);
+    element.computeType(resolution);
     scope = new TypeDeclarationScope(scope, element);
     resolveTypeVariableBounds(node.typeParameters);
 
     // Generate anonymous mixin application elements for the
     // intermediate mixin applications (excluding the last).
     DartType supertype = resolveSupertype(element, node.superclass);
     Link<Node> link = node.mixins.nodes;
     while (!link.tail.isEmpty) {
       supertype = applyMixin(supertype, checkMixinType(link.head), link.head);
       link = link.tail;
     }
     doApplyMixinTo(element, supertype, checkMixinType(link.head));
-    return element.computeType(compiler);
+    return element.computeType(resolution);
   }
 
   DartType applyMixin(DartType supertype, DartType mixinType, Node node) {
     String superName = supertype.name;
     String mixinName = mixinType.name;
     MixinApplicationElementX mixinApplication = new MixinApplicationElementX(
         "${superName}+${mixinName}",
         element.compilationUnit,
         compiler.getNextFreeClassId(),
         node,
@@ skipping 10 matching lines @@
     }
     // Setup bounds on the synthetic type variables.
     for (TypeVariableType type in element.typeVariables) {
       TypeVariableType typeVariable = typeVariables[type.element.index];
       TypeVariableElementX typeVariableElement = typeVariable.element;
       typeVariableElement.typeCache = typeVariable;
       typeVariableElement.boundCache =
           type.element.bound.subst(typeVariables, element.typeVariables);
     }
     // Setup this and raw type for the mixin application.
-    mixinApplication.computeThisAndRawType(compiler, typeVariables);
+    mixinApplication.computeThisAndRawType(resolution, typeVariables);
     // Substitute in synthetic type variables in super and mixin types.
     supertype = supertype.subst(typeVariables, element.typeVariables);
     mixinType = mixinType.subst(typeVariables, element.typeVariables);
 
     doApplyMixinTo(mixinApplication, supertype, mixinType);
     mixinApplication.resolutionState = STATE_DONE;
     mixinApplication.supertypeLoadState = STATE_DONE;
     // Replace the synthetic type variables by the original type variables in
     // the returned type (which should be the type actually extended).
     InterfaceType mixinThisType = mixinApplication.thisType;
     return mixinThisType.subst(element.typeVariables,
                                mixinThisType.typeArguments);
   }
 
   bool isDefaultConstructor(FunctionElement constructor) {
     if (constructor.name != '') return false;
-    constructor.computeType(compiler);
+    constructor.computeType(resolution);
     return constructor.functionSignature.parameterCount == 0;
   }
 
   FunctionElement createForwardingConstructor(ConstructorElement target,
                                               ClassElement enclosing) {
     FunctionElement constructor =
         new SynthesizedConstructorElementX.notForDefault(
             target.name, target, enclosing);
-    constructor.computeType(compiler);
+    constructor.computeType(resolution);
     return constructor;
   }
 
   void doApplyMixinTo(MixinApplicationElementX mixinApplication,
                       DartType supertype,
                       DartType mixinType) {
-    Node node = mixinApplication.parseNode(compiler);
+    Node node = mixinApplication.parseNode(resolution.parsing);
 
     if (mixinApplication.supertype != null) {
       // [supertype] is not null if there was a cycle.
       assert(invariant(node, compiler.compilationFailed));
       supertype = mixinApplication.supertype;
       assert(invariant(node, supertype.element == compiler.objectClass));
     } else {
       mixinApplication.supertype = supertype;
     }
 
@@ skipping 44 matching lines @@
         return;
       }
       mixinApplication.addConstructor(forwarder);
     });
     calculateAllSupertypes(mixinApplication);
   }
 
   InterfaceType resolveMixinFor(MixinApplicationElement mixinApplication,
                                 DartType mixinType) {
     ClassElement mixin = mixinType.element;
-    mixin.ensureResolved(compiler);
+    mixin.ensureResolved(resolution);
 
     // Check for cycles in the mixin chain.
     ClassElement previous = mixinApplication;  // For better error messages.
     ClassElement current = mixin;
     while (current != null && current.isMixinApplication) {
       MixinApplicationElement currentMixinApplication = current;
       if (currentMixinApplication == mixinApplication) {
         compiler.reportErrorMessage(
             mixinApplication,
             MessageKind.ILLEGAL_MIXIN_CYCLE,
@@ skipping 125 matching lines @@
            interfaces = interfaces.tail) {
         allSupertypes.add(compiler, interfaces.head);
       }
 
       addAllSupertypes(allSupertypes, supertype);
       for (Link<DartType> interfaces = cls.interfaces;
            !interfaces.isEmpty;
            interfaces = interfaces.tail) {
         addAllSupertypes(allSupertypes, interfaces.head);
       }
-      allSupertypes.add(compiler, cls.computeType(compiler));
+      allSupertypes.add(compiler, cls.computeType(resolution));
       cls.allSupertypesAndSelf = allSupertypes.toTypeSet();
     } else {
       assert(identical(cls, compiler.objectClass));
       cls.allSupertypesAndSelf =
-          new OrderedTypeSet.singleton(cls.computeType(compiler));
+          new OrderedTypeSet.singleton(cls.computeType(resolution));
     }
   }
 
   /**
    * Adds [type] and all supertypes of [type] to [allSupertypes] while
    * substituting type variables.
    */
   void addAllSupertypes(OrderedTypeSetBuilder allSupertypes,
                         InterfaceType type) {
     ClassElement classElement = type.element;
@@ skipping 28 matching lines @@
   ClassElement classElement;
 
   ClassSupertypeResolver(Compiler compiler, ClassElement cls)
     : context = Scope.buildEnclosingScope(cls),
       this.classElement = cls,
       super(compiler);
 
   void loadSupertype(ClassElement element, Node from) {
     if (!element.isResolved) {
       compiler.resolver.loadSupertypes(element, from);
-      element.ensureResolved(compiler);
+      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 54 matching lines @@
     if (e == null || !e.impliesType) {
       compiler.reportErrorMessage(
           node.selector,
           MessageKind.CANNOT_RESOLVE_TYPE,
           {'typeName': node.selector});
       return;
     }
     loadSupertype(e, node);
   }
 }