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

pkg/compiler/lib/src/parser/partial_elements.dart

Index: pkg/compiler/lib/src/parser/partial_elements.dart
diff --git a/pkg/compiler/lib/src/parser/partial_elements.dart b/pkg/compiler/lib/src/parser/partial_elements.dart
index 17412f731d145f3265644e421b6568f5dd0e08c8..87041b404d40ead830b32c3942cbb36507aa299e 100644
--- a/pkg/compiler/lib/src/parser/partial_elements.dart
+++ b/pkg/compiler/lib/src/parser/partial_elements.dart
@@ -4,6 +4,9 @@
 
 library dart2js.parser.partial_elements;
 
+import '../common/resolution.dart' show
+    Parsing,
+    Resolution;
 import '../compiler.dart' show
     Compiler;
 import '../dart_types.dart' show DynamicType;
@@ -104,7 +107,7 @@ abstract class PartialFunctionMixin implements BaseFunctionElementX {
     return cachedNode;
   }
 
-  FunctionExpression parseNode(DiagnosticListener listener) {
+  FunctionExpression parseNode(Parsing parsing) {
     if (cachedNode != null) return cachedNode;
     parseFunction(Parser p) {
       if (isClassMember && modifiers.isFactory) {
@@ -113,7 +116,7 @@ abstract class PartialFunctionMixin implements BaseFunctionElementX {
         p.parseFunction(beginToken, getOrSet);
       }
     }
-    cachedNode = parse(listener, this, declarationSite, parseFunction);
+    cachedNode = parse(parsing, this, declarationSite, parseFunction);
     return cachedNode;
   }
 
@@ -268,11 +271,12 @@ class PartialFieldList extends VariableList with PartialElement {
     super.hasParseError = hasParseError;
   }
 
-  VariableDefinitions parseNode(Element element, DiagnosticListener listener) {
+  VariableDefinitions parseNode(Element element, Parsing parsing) {
     if (definitions != null) return definitions;
+    DiagnosticListener listener = parsing.listener;
     listener.withCurrentElement(element, () {
       definitions = parse(
-          listener, element, declarationSite,
+          parsing, element, declarationSite,
           (Parser parser) => parser.parseMember(beginToken));
 
       if (!hasParseError &&
@@ -291,17 +295,15 @@ class PartialFieldList extends VariableList with PartialElement {
     return definitions;
   }
 
-  computeType(Element element, Compiler compiler) {
+  computeType(Element element, Resolution resolution) {
     if (type != null) return type;
     // TODO(johnniwinther): Compute this in the resolver.
-    compiler.withCurrentElement(element, () {
-      VariableDefinitions node = parseNode(element, compiler);
-      if (node.type != null) {
-        type = compiler.resolver.resolveTypeAnnotation(element, node.type);
-      } else {
-        type = const DynamicType();
-      }
-    });
+    VariableDefinitions node = parseNode(element, resolution.parsing);
+    if (node.type != null) {
+      type = resolution.resolveTypeAnnotation(element, node.type);
+    } else {
+      type = const DynamicType();
+    }
     assert(type != null);
     return type;
   }
@@ -321,10 +323,10 @@ class PartialTypedefElement extends TypedefElementX with PartialElement {
 
   Token get token => beginToken;
 
-  Node parseNode(DiagnosticListener listener) {
+  Node parseNode(Parsing parsing) {
     if (cachedNode != null) return cachedNode;
     cachedNode = parse(
-        listener, this, declarationSite,
+        parsing, this, declarationSite,
         (p) => p.parseTopLevelDeclaration(token));
     return cachedNode;
   }
@@ -363,9 +365,9 @@ class PartialMetadataAnnotation extends MetadataAnnotationX
     throw new UnsupportedError("endToken=");
   }
 
-  Node parseNode(DiagnosticListener listener) {
+  Node parseNode(Parsing parsing) {
     if (cachedNode != null) return cachedNode;
-    var metadata = parse(listener,
+    var metadata = parse(parsing,
                          annotatedElement,
                          declarationSite,
                          (p) => p.parseMetadata(beginToken));
@@ -419,11 +421,12 @@ class PartialClassElement extends ClassElementX with PartialElement {
     return cachedNode;
   }
 
-  ClassNode parseNode(Compiler compiler) {
+  ClassNode parseNode(Parsing parsing) {
     if (cachedNode != null) return cachedNode;
-    compiler.withCurrentElement(this, () {
-      compiler.parser.measure(() {
-        MemberListener listener = new MemberListener(compiler, this);
+    DiagnosticListener diagnosticListener = parsing.listener;
+    diagnosticListener.withCurrentElement(this, () {
+      parsing.measure(() {
+        MemberListener listener = new MemberListener(diagnosticListener, this);
         Parser parser = new ClassElementParser(listener);
         try {
           Token token = parser.parseTopLevelDeclaration(beginToken);
@@ -450,13 +453,9 @@ class PartialClassElement extends ClassElementX with PartialElement {
           hasParseError = true;
         }
       });
-      compiler.patchParser.measure(() {
-        if (isPatched) {
-          // TODO(lrn): Perhaps extract functionality so it doesn't
-          // need compiler.
-          compiler.patchParser.parsePatchClassNode(patch);
-        }
-      });
+      if (isPatched) {
+        parsing.parsePatchClass(patch);
+      }
     });
     return cachedNode;
   }
@@ -477,23 +476,28 @@ class PartialClassElement extends ClassElementX with PartialElement {
 }
 
 Node parse(
-    DiagnosticListener diagnosticListener,
+    Parsing parsing,
     ElementX element,
     PartialElement partial,
     doParse(Parser parser)) {
-  CompilationUnitElement unit = element.compilationUnit;
-  NodeListener listener = new NodeListener(diagnosticListener, unit);
-  listener.memberErrors = listener.memberErrors.prepend(false);
-  try {
-    if (partial.hasParseError) {
-      listener.suppressParseErrors = true;
-    }
-    doParse(new Parser(listener));
-  } on ParserError catch (e) {
-    partial.hasParseError = true;
-    return new ErrorNode(element.position, e.reason);
-  }
-  Node node = listener.popNode();
-  assert(listener.nodes.isEmpty);
-  return node;
+  DiagnosticListener diagnosticListener = parsing.listener;
+  return parsing.measure(() {
+    return diagnosticListener.withCurrentElement(element, () {
+      CompilationUnitElement unit = element.compilationUnit;
+      NodeListener listener = new NodeListener(diagnosticListener, unit);
+      listener.memberErrors = listener.memberErrors.prepend(false);
+      try {
+        if (partial.hasParseError) {
+          listener.suppressParseErrors = true;
+        }
+        doParse(new Parser(listener));
+      } on ParserError catch (e) {
+        partial.hasParseError = true;
+        return new ErrorNode(element.position, e.reason);
+      }
+      Node node = listener.popNode();
+      assert(listener.nodes.isEmpty);
+      return node;
+    });
+  });
 }