Refactor Parsing to remove compiler dependency

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.dart';
-import '../common/resolution.dart' show Parsing, Resolution;
+import '../common/resolution.dart' show ParsingContext, Resolution;
 import '../dart_types.dart' show DynamicType;
 import '../elements/elements.dart'
     show
         CompilationUnitElement,
         Element,
         ElementKind,
         GetterElement,
         MetadataAnnotation,
         SetterElement,
         STATE_NOT_STARTED,
@@ skipping 57 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(Parsing parsing) {
+  FunctionExpression parseNode(ParsingContext parsing) {
     if (cachedNode != null) return cachedNode;
     parseFunction(Parser p) {
       if (isClassMember && modifiers.isFactory) {
         p.parseFactoryMethod(beginToken);
       } else {
         p.parseFunction(beginToken, getOrSet);
       }
     }
     cachedNode = parse(parsing, this, declarationSite, parseFunction);
     return cachedNode;
@@ skipping 122 matching lines @@
 
 class PartialFieldList extends VariableList with PartialElement {
   PartialFieldList(
       Token beginToken, Token endToken, Modifiers modifiers, bool hasParseError)
       : super(modifiers) {
     super.beginToken = beginToken;
     super.endToken = endToken;
     super.hasParseError = hasParseError;
   }
 
-  VariableDefinitions parseNode(Element element, Parsing parsing) {
+  VariableDefinitions parseNode(Element element, ParsingContext parsing) {
     if (definitions != null) return definitions;
     DiagnosticReporter reporter = parsing.reporter;
     reporter.withCurrentElement(element, () {
       definitions = parse(parsing, element, declarationSite,
           (Parser parser) => parser.parseMember(beginToken));
 
       if (!hasParseError &&
           !definitions.modifiers.isVar &&
           !definitions.modifiers.isFinal &&
           !definitions.modifiers.isConst &&
           definitions.type == null &&
           !definitions.isErroneous) {
         reporter.reportErrorMessage(definitions, MessageKind.GENERIC, {
           'text': 'A field declaration must start with var, final, '
               'const, or a type annotation.'
         });
       }
     });
     return definitions;
   }
 
   computeType(Element element, Resolution resolution) {
     if (type != null) return type;
     // TODO(johnniwinther): Compute this in the resolver.
-    VariableDefinitions node = parseNode(element, resolution.parsing);
+    VariableDefinitions node = parseNode(element, resolution.parsingContext);
     if (node.type != null) {
       type = resolution.reporter.withCurrentElement(element, () {
         return 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(Parsing parsing) {
+  Node parseNode(ParsingContext parsing) {
     if (cachedNode != null) return cachedNode;
     cachedNode = parse(parsing, this, declarationSite,
         (p) => p.parseTopLevelDeclaration(token));
     return cachedNode;
   }
 
   Token get position => findMyName(token);
 }
 
 /// A [MetadataAnnotation] which is constructed on demand.
@@ skipping 20 matching lines @@
       token = token.next;
     }
     assert(token != null);
     return token;
   }
 
   void set endToken(_) {
     throw new UnsupportedError("endToken=");
   }
 
-  Node parseNode(Parsing parsing) {
+  Node parseNode(ParsingContext parsing) {
     if (cachedNode != null) return cachedNode;
     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 30 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(Parsing parsing) {
+  ClassNode parseNode(ParsingContext parsing) {
     if (cachedNode != null) return cachedNode;
     DiagnosticReporter reporter = parsing.reporter;
     reporter.withCurrentElement(this, () {
       parsing.measure(() {
         MemberListener listener = new MemberListener(
             parsing.getScannerOptionsFor(this), reporter, this);
         Parser parser = new ClassElementParser(listener, parsing.parserOptions);
         try {
           Token token = parser.parseTopLevelDeclaration(beginToken);
           assert(identical(token, endToken.next));
@@ skipping 39 matching lines @@
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitClassElement(this, arg);
   }
 
   PartialClassElement copyWithEnclosing(CompilationUnitElement enclosing) {
     return new PartialClassElement(name, beginToken, endToken, enclosing, id);
   }
 }
 
-Node parse(Parsing parsing, ElementX element, PartialElement partial,
+Node parse(ParsingContext parsing, ElementX element, PartialElement partial,
     doParse(Parser parser)) {
   DiagnosticReporter reporter = parsing.reporter;
   return parsing.measure(() {
     return reporter.withCurrentElement(element, () {
       CompilationUnitElement unit = element.compilationUnit;
       NodeListener listener = new NodeListener(
           parsing.getScannerOptionsFor(element), reporter, unit);
       listener.memberErrors = listener.memberErrors.prepend(false);
       try {
         if (partial.hasParseError) {
           listener.suppressParseErrors = true;
         }
         doParse(new Parser(listener, parsing.parserOptions));
       } on ParserError catch (e) {
         partial.hasParseError = true;
         return new ErrorNode(element.position, e.reason);
       }
       Node node = listener.popNode();
       assert(listener.nodes.isEmpty);
       return node;
     });
   });
 }