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

pkg/compiler/lib/src/resolution/constructors.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.constructors;
 import '../compiler.dart' show
     Compiler;
 import '../constants/constructors.dart' show
     GenerativeConstantConstructor,
     RedirectingGenerativeConstantConstructor;
@@ skipping 74 matching lines @@
         ]);
     isValidAsConstant = false;
   }
 
   void checkForDuplicateInitializers(FieldElementX field, Node init) {
     // [field] can be null if it could not be resolved.
     if (field == null) return;
     if (initialized.containsKey(field)) {
       reportDuplicateInitializerError(field, init, initialized[field]);
     } else if (field.isFinal) {
-      field.parseNode(visitor.compiler);
+      field.parseNode(visitor.resolution.parsing);
       Expression initializer = field.initializer;
       if (initializer != null) {
         reportDuplicateInitializerError(field, init, initializer);
       }
     }
     initialized[field] = init;
   }
 
   void resolveFieldInitializer(SendSet init) {
     // init is of the form [this.]field = value.
@@ skipping 155 matching lines @@
       String fullConstructorName = Elements.constructorNameForDiagnostics(
               className,
               constructorSelector.name);
       MessageKind kind = isImplicitSuperCall
           ? MessageKind.CANNOT_RESOLVE_CONSTRUCTOR_FOR_IMPLICIT
           : MessageKind.CANNOT_RESOLVE_CONSTRUCTOR;
       listener.reportErrorMessage(
           diagnosticNode, kind, {'constructorName': fullConstructorName});
       isValidAsConstant = false;
     } else {
-      lookedupConstructor.computeType(visitor.compiler);
+      lookedupConstructor.computeType(visitor.resolution);
       if (!call.signatureApplies(lookedupConstructor.functionSignature)) {
         MessageKind kind = isImplicitSuperCall
                            ? MessageKind.NO_MATCHING_CONSTRUCTOR_FOR_IMPLICIT
                            : MessageKind.NO_MATCHING_CONSTRUCTOR;
         listener.reportErrorMessage(diagnosticNode, kind);
         isValidAsConstant = false;
       } else if (constructor.isConst
                  && !lookedupConstructor.isConst) {
         MessageKind kind = isImplicitSuperCall
                            ? MessageKind.CONST_CALLS_NON_CONST_FOR_IMPLICIT
@@ skipping 192 matching lines @@
       type = new MalformedType(error, null);
     }
     return new ConstructorResult(resultKind, error, type);
   }
 
   ConstructorResult resolveConstructor(
       InterfaceType type,
       Node diagnosticNode,
       String constructorName) {
     ClassElement cls = type.element;
-    cls.ensureResolved(compiler);
+    cls.ensureResolved(resolution);
     ConstructorElement constructor = findConstructor(
         resolver.enclosingElement.library, cls, constructorName);
     if (constructor == null) {
       String fullConstructorName =
           Elements.constructorNameForDiagnostics(cls.name, constructorName);
       return reportAndCreateErroneousConstructorElement(
           diagnosticNode,
           ConstructorResultKind.UNRESOLVED_CONSTRUCTOR, type,
           cls, constructorName,
           MessageKind.CANNOT_FIND_CONSTRUCTOR,
@@ skipping 139 matching lines @@
       return reportAndCreateErroneousConstructorElement(
           node,
           ConstructorResultKind.INVALID_TYPE, null,
           resolver.enclosingElement, name,
           MessageKind.CANNOT_RESOLVE,
           {'name': name});
     } else if (element.isErroneous) {
       return constructorResultForErroneous(node, element);
     } else if (element.isClass) {
       ClassElement cls = element;
-      cls.computeType(compiler);
+      cls.computeType(resolution);
       return constructorResultForType(node, cls.rawType);
     } else if (element.isPrefix) {
       return new ConstructorResult.forElement(element);
     } else if (element.isTypedef) {
       TypedefElement typdef = element;
-      typdef.ensureResolved(compiler);
+      typdef.ensureResolved(resolution);
       return constructorResultForType(node, typdef.rawType);
     } else if (element.isTypeVariable) {
       TypeVariableElement typeVariableElement = element;
       return constructorResultForType(node, typeVariableElement.type);
     } else {
       return reportAndCreateErroneousConstructorElement(
           node,
           ConstructorResultKind.INVALID_TYPE, null,
           resolver.enclosingElement, name,
           MessageKind.NOT_A_TYPE, {'node': name});
@@ skipping 96 matching lines @@
     // constructors.
     return null;
   }
   // TODO(johnniwinther): Use [Name] for lookup.
   ConstructorElement constructor = cls.lookupConstructor(constructorName);
   if (constructor != null) {
     constructor = constructor.declaration;
   }
   return constructor;
 }