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

pkg/compiler/lib/src/parser/partial_elements.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.parser.partial_elements;
 
+import '../common/resolution.dart' show
+    Parsing,
+    Resolution;
 import '../compiler.dart' show
     Compiler;
 import '../dart_types.dart' show DynamicType;
 import '../diagnostics/diagnostic_listener.dart';
 import '../diagnostics/invariant.dart' show
     invariant;
 import '../diagnostics/messages.dart';
 import '../elements/elements.dart' show
     CompilationUnitElement,
     ConstructorElement,
@@ skipping 80 matching lines @@
   }
 
   bool get hasNode => cachedNode != null;
 
   FunctionExpression get node {
     assert(invariant(this, cachedNode != null,
         message: "Node has not been computed for $this."));
     return cachedNode;
   }
 
-  FunctionExpression parseNode(DiagnosticListener listener) {
+  FunctionExpression parseNode(Parsing parsing) {
     if (cachedNode != null) return cachedNode;
     parseFunction(Parser p) {
       if (isClassMember && modifiers.isFactory) {
         p.parseFactoryMethod(beginToken);
       } else {
         p.parseFunction(beginToken, getOrSet);
       }
     }
-    cachedNode = parse(listener, this, declarationSite, parseFunction);
+    cachedNode = parse(parsing, this, declarationSite, parseFunction);
     return cachedNode;
   }
 
   Token get position => _position;
 
   void reusePartialFunctionMixin() {
     cachedNode = null;
   }
 
   DeclarationSite get declarationSite;
@@ skipping 134 matching lines @@
   PartialFieldList(Token beginToken,
                    Token endToken,
                    Modifiers modifiers,
                    bool hasParseError)
       : super(modifiers) {
     super.beginToken = beginToken;
     super.endToken = endToken;
     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 &&
           !definitions.modifiers.isVar &&
           !definitions.modifiers.isFinal &&
           !definitions.modifiers.isConst &&
           definitions.type == null &&
           !definitions.isErroneous) {
         listener.reportErrorMessage(
             definitions,
             MessageKind.GENERIC,
             { 'text': 'A field declaration must start with var, final, '
                       'const, or a type annotation.' });
       }
     });
     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;
   }
 }
 
 class PartialTypedefElement extends TypedefElementX with PartialElement {
 
   PartialTypedefElement(
       String name,
       Element enclosing,
       Token beginToken,
       Token endToken)
       : super(name, enclosing) {
     this.beginToken = beginToken;
     this.endToken = endToken;
   }
 
   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;
   }
 
   Token get position => findMyName(token);
 }
 
 /// A [MetadataAnnotation] which is constructed on demand.
 class PartialMetadataAnnotation extends MetadataAnnotationX
     implements PartialElement {
@@ skipping 18 matching lines @@
       token = token.next;
     }
     assert(token != null);
     return token;
   }
 
   void set endToken(_) {
     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));
     if (metadata is Metadata) {
       cachedNode = metadata.expression;
       return cachedNode;
     } else {
       assert (metadata is ErrorNode);
       return metadata;
     }
@@ skipping 33 matching lines @@
   }
 
   bool get hasNode => cachedNode != null;
 
   ClassNode get node {
     assert(invariant(this, cachedNode != null,
         message: "Node has not been computed for $this."));
     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);
           assert(identical(token, endToken.next));
           cachedNode = listener.popNode();
           assert(
               invariant(
                   beginToken, listener.nodes.isEmpty,
                   message: "Non-empty listener stack: ${listener.nodes}"));
         } on ParserError {
           // TODO(ahe): Often, a ParserError is thrown while parsing the class
           // body. This means that the stack actually contains most of the
           // information synthesized below. Consider rewriting the parser so
           // endClassDeclaration is called before parsing the class body.
           Identifier name = new Identifier(findMyName(beginToken));
           NodeList typeParameters = null;
           Node supertype = null;
           NodeList interfaces = listener.makeNodeList(0, null, null, ",");
           Token extendsKeyword = null;
           NodeList body = listener.makeNodeList(0, beginToken, endToken, null);
           cachedNode = new ClassNode(
               Modifiers.EMPTY, name, typeParameters, supertype, interfaces,
               beginToken, extendsKeyword, body, endToken);
           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;
   }
 
   Token get position => beginToken;
 
   // TODO(johnniwinther): Ensure that modifiers are always available.
   Modifiers get modifiers =>
       cachedNode != null ? cachedNode.modifiers : Modifiers.EMPTY;
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitClassElement(this, arg);
   }
 
   PartialClassElement copyWithEnclosing(CompilationUnitElement enclosing) {
     return new PartialClassElement(name, beginToken, endToken, enclosing, id);
   }
 }
 
 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;
+    });
+  });
 }