Refactor Parsing to remove compiler dependency

pkg/compiler/lib/src/resolution/resolution.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 dart2js.resolution;
 
 import 'dart:collection' show Queue;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
 import '../common/resolution.dart'
-    show Feature, Parsing, Resolution, ResolutionImpact;
+    show Feature, ParsingContext, Resolution, ResolutionImpact;
 import '../common/tasks.dart' show CompilerTask;
 import '../compile_time_constants.dart' show ConstantCompiler;
 import '../compiler.dart' show Compiler;
 import '../constants/expressions.dart'
     show
         ConstantExpression,
         ConstantExpressionKind,
         ConstructedConstantExpression,
         ErroneousConstantExpression;
 import '../constants/values.dart' show ConstantValue;
@@ skipping 36 matching lines @@
 
 class ResolverTask extends CompilerTask {
   final ConstantCompiler constantCompiler;
 
   ResolverTask(Compiler compiler, this.constantCompiler) : super(compiler);
 
   String get name => 'Resolver';
 
   Resolution get resolution => compiler.resolution;
 
-  Parsing get parsing => compiler.parsing;
+  ParsingContext get parsingContext => compiler.parsingContext;
 
   CoreClasses get coreClasses => compiler.coreClasses;
 
   CoreTypes get coreTypes => compiler.coreTypes;
 
   ResolutionImpact resolve(Element element) {
     return measure(() {
       if (Elements.isMalformed(element)) {
         // TODO(johnniwinther): Add a predicate for this.
         assert(invariant(element, element is! ErroneousElement,
@@ skipping 224 matching lines @@
             registry.registerStaticUse(new StaticUse.superConstructorInvoke(
                 target, CallStructure.NO_ARGS));
           }
           return registry.worldImpact;
         } else {
           assert(element.isDeferredLoaderGetter || element.isMalformed);
           _ensureTreeElements(element);
           return const ResolutionImpact();
         }
       } else {
-        element.parseNode(resolution.parsing);
+        element.parseNode(resolution.parsingContext);
         element.computeType(resolution);
         FunctionElementX implementation = element;
         if (element.isExternal) {
           implementation = compiler.backend.resolveExternalFunction(element);
         }
         return resolveMethodElementImplementation(
             implementation, implementation.node);
       }
     });
   }
 
   /// Creates a [ResolverVisitor] for resolving an AST in context of [element].
   /// If [useEnclosingScope] is `true` then the initial scope of the visitor
   /// does not include inner scope of [element].
   ///
   /// This method should only be used by this library (or tests of
   /// this library).
   ResolverVisitor visitorFor(Element element, {bool useEnclosingScope: false}) {
     return new ResolverVisitor(compiler, element,
         new ResolutionRegistry(compiler, _ensureTreeElements(element)),
         useEnclosingScope: useEnclosingScope);
   }
 
   WorldImpact resolveField(FieldElementX element) {
-    VariableDefinitions tree = element.parseNode(parsing);
+    VariableDefinitions tree = element.parseNode(parsingContext);
     if (element.modifiers.isStatic && element.isTopLevel) {
       reporter.reportErrorMessage(element.modifiers.getStatic(),
           MessageKind.TOP_LEVEL_VARIABLE_DECLARED_STATIC);
     }
     ResolverVisitor visitor = visitorFor(element);
     ResolutionRegistry registry = visitor.registry;
     // TODO(johnniwinther): Maybe remove this when placeholderCollector migrates
     // to the backend ast.
     registry.defineElement(tree.definitions.nodes.head, element);
     // TODO(johnniwinther): Share the resolved type between all variables
@@ skipping 151 matching lines @@
         cls.supertype = cls.allSupertypes.head;
         assert(invariant(from, cls.supertype != null,
             message: 'Missing supertype on cyclic class $cls.'));
         cls.interfaces = const Link<DartType>();
         return;
       }
       cls.supertypeLoadState = STATE_STARTED;
       reporter.withCurrentElement(cls, () {
         // TODO(ahe): Cache the node in cls.
         cls
-            .parseNode(parsing)
+            .parseNode(parsingContext)
             .accept(new ClassSupertypeResolver(compiler, cls));
         if (cls.supertypeLoadState != STATE_DONE) {
           cls.supertypeLoadState = STATE_DONE;
         }
       });
     });
   }
 
   // TODO(johnniwinther): Remove this queue when resolution has been split into
   // syntax and semantic resolution.
@@ skipping 68 matching lines @@
   }
 
   void resolveClassInternal(
       BaseClassElementX element, ResolutionRegistry registry) {
     if (!element.isPatch) {
       reporter.withCurrentElement(
           element,
           () => measure(() {
                 assert(element.resolutionState == STATE_NOT_STARTED);
                 element.resolutionState = STATE_STARTED;
-                Node tree = element.parseNode(parsing);
+                Node tree = element.parseNode(parsingContext);
                 loadSupertypes(element, tree);
 
                 ClassResolverVisitor visitor =
                     new ClassResolverVisitor(compiler, element, registry);
                 visitor.visit(tree);
                 element.resolutionState = STATE_DONE;
                 compiler.onClassResolved(element);
                 pendingClassesToBePostProcessed.add(element);
               }));
       if (element.isPatched) {
@@ skipping 347 matching lines @@
           'className': contextElement.enclosingClass.name
         }),
         <DiagnosticMessage>[
           reporter.createMessage(contextElement, contextMessage),
         ]);
   }
 
   FunctionSignature resolveSignature(FunctionElementX element) {
     MessageKind defaultValuesError = null;
     if (element.isFactoryConstructor) {
-      FunctionExpression body = element.parseNode(parsing);
+      FunctionExpression body = element.parseNode(parsingContext);
       if (body.isRedirectingFactory) {
         defaultValuesError = MessageKind.REDIRECTING_FACTORY_WITH_DEFAULT;
       }
     }
     return reporter.withCurrentElement(element, () {
-      FunctionExpression node = element.parseNode(parsing);
+      FunctionExpression node = element.parseNode(parsingContext);
       return measure(() => SignatureResolver.analyze(
           compiler,
           node.parameters,
           node.returnType,
           element,
           new ResolutionRegistry(compiler, _ensureTreeElements(element)),
           defaultValuesError: defaultValuesError,
           createRealParameters: true));
     });
   }
 
   WorldImpact resolveTypedef(TypedefElementX element) {
     if (element.isResolved) return const ResolutionImpact();
     compiler.world.allTypedefs.add(element);
     return _resolveTypeDeclaration(element, () {
       ResolutionRegistry registry =
           new ResolutionRegistry(compiler, _ensureTreeElements(element));
       return reporter.withCurrentElement(element, () {
         return measure(() {
           assert(element.resolutionState == STATE_NOT_STARTED);
           element.resolutionState = STATE_STARTED;
-          Typedef node = element.parseNode(parsing);
+          Typedef node = element.parseNode(parsingContext);
           TypedefResolverVisitor visitor =
               new TypedefResolverVisitor(compiler, element, registry);
           visitor.visit(node);
           element.resolutionState = STATE_DONE;
           return registry.worldImpact;
         });
       });
     });
   }
 
   void resolveMetadataAnnotation(MetadataAnnotationX annotation) {
     reporter.withCurrentElement(
         annotation.annotatedElement,
         () => measure(() {
               assert(annotation.resolutionState == STATE_NOT_STARTED);
               annotation.resolutionState = STATE_STARTED;
 
-              Node node = annotation.parseNode(parsing);
+              Node node = annotation.parseNode(parsingContext);
               Element annotatedElement = annotation.annotatedElement;
               AnalyzableElement context = annotatedElement.analyzableElement;
               ClassElement classElement = annotatedElement.enclosingClass;
               if (classElement != null) {
                 // The annotation is resolved in the scope of [classElement].
                 classElement.ensureResolved(resolution);
               }
               assert(invariant(node, context != null,
                   message: "No context found for metadata annotation "
                       "on $annotatedElement."));
@@ skipping 65 matching lines @@
   TreeElements get treeElements {
     assert(invariant(this, _treeElements != null,
         message: "TreeElements have not been computed for $this."));
     return _treeElements;
   }
 
   void reuseElement() {
     _treeElements = null;
   }
 }