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

pkg/compiler/lib/src/closure.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 closureToClassMapper;
 
 import 'common/names.dart' show
     Identifiers;
+import 'common/resolution.dart' show
+    Parsing,
+    Resolution;
 import 'common/tasks.dart' show
     CompilerTask;
 import 'compiler.dart' show
     Compiler;
 import 'constants/expressions.dart';
 import 'dart_types.dart';
 import 'diagnostics/diagnostic_listener.dart';
 import 'diagnostics/spannable.dart' show
     SpannableAssertionFailure;
 import 'elements/elements.dart';
@@ skipping 114 matching lines @@
   }
 
   Expression get initializer {
     throw new SpannableAssertionFailure(local,
         'Should not access initializer of ClosureFieldElement.');
   }
 
   bool get isInstanceMember => true;
   bool get isAssignable => false;
 
-  DartType computeType(Compiler compiler) => type;
+  DartType computeType(Resolution resolution) => type;
 
   DartType get type {
     if (local is LocalElement) {
       LocalElement element = local;
       return element.type;
     }
     return const DynamicType();
   }
 
   String toString() => "ClosureFieldElement($name)";
@@ skipping 36 matching lines @@
               closure.compilationUnit,
               // By assigning a fresh class-id we make sure that the hashcode
               // is unique, but also emit closure classes after all other
               // classes (since the emitter sorts classes by their id).
               compiler.getNextFreeClassId(),
               STATE_DONE) {
     JavaScriptBackend backend = compiler.backend;
     ClassElement superclass = methodElement.isInstanceMember
         ? backend.boundClosureClass
         : backend.closureClass;
-    superclass.ensureResolved(compiler);
+    superclass.ensureResolved(compiler.resolution);
     supertype = superclass.thisType;
     interfaces = const Link<DartType>();
     thisType = rawType = new InterfaceType(this);
     allSupertypesAndSelf =
         superclass.allSupertypesAndSelf.extendClass(thisType);
     callType = methodElement.type;
   }
 
   Iterable<ClosureFieldElement> get closureFields => _closureFields;
 
   void addField(ClosureFieldElement field, DiagnosticListener listener) {
     _closureFields.add(field);
     addMember(field, listener);
   }
 
   bool get hasNode => true;
 
   bool get isClosure => true;
 
   Token get position => node.getBeginToken();
 
-  Node parseNode(DiagnosticListener listener) => node;
+  Node parseNode(Parsing parsing) => node;
 
   // A [ClosureClassElement] is nested inside a function or initializer in terms
   // of [enclosingElement], but still has to be treated as a top-level
   // element.
   bool get isTopLevel => true;
 
   get enclosingElement => methodElement;
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitClosureClassElement(this, arg);
@@ skipping 12 matching lines @@
 // TODO(ngeoffray, ahe): These classes continuously cause problems.  We need to
 // find a more general solution.
 class BoxFieldElement extends ElementX
     implements TypedElement, CapturedVariable, FieldElement {
   final BoxLocal box;
 
   BoxFieldElement(String name, this.variableElement, BoxLocal box)
       : this.box = box,
         super(name, ElementKind.FIELD, box.executableContext);
 
-  DartType computeType(Compiler compiler) => type;
+  DartType computeType(Resolution resolution) => type;
 
   DartType get type => variableElement.type;
 
   final VariableElement variableElement;
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitBoxFieldElement(this, arg);
   }
 
   @override
@@ skipping 59 matching lines @@
   ClosureClassElement get closureClass => super.enclosingElement;
 
   MemberElement get memberContext {
     return closureClass.methodElement.memberContext;
   }
 
   bool get hasNode => expression.hasNode;
 
   FunctionExpression get node => expression.node;
 
-  FunctionExpression parseNode(DiagnosticListener listener) => node;
+  FunctionExpression parseNode(Parsing parsing) => node;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(this, node, treeElements);
   }
 
   Element get analyzableElement => closureClass.methodElement.analyzableElement;
 }
 
 // The box-element for a scope, and the captured variables that need to be
 // stored in the box.
@@ skipping 774 matching lines @@
 
   String get name => typeVariable.name;
 
   int get hashCode => typeVariable.hashCode;
 
   bool operator ==(other) {
     if (other is! TypeVariableLocal) return false;
     return typeVariable == other.typeVariable;
   }
 }