Refactor Parsing to remove compiler dependency

tests/compiler/dart2js/patch_test.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.
 
 import 'dart:async';
 import 'package:expect/expect.dart';
 import 'package:async_helper/async_helper.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/diagnostics/messages.dart' show
     MessageKind;
@@ skipping 27 matching lines @@
   var future;
   if (runCompiler) {
     future = compiler.run(null, main);
   } else {
     future = compiler.init(main);
   }
   return future.then((_) => compiler);
 }
 
 void expectHasBody(compiler, ElementX element) {
-    var node = element.parseNode(compiler.parsing);
+    var node = element.parseNode(compiler.parsingContext);
     Expect.isNotNull(node, "Element isn't parseable, when a body was expected");
     Expect.isNotNull(node.body);
     // If the element has a body it is either a Block or a Return statement,
     // both with different begin and end tokens.
     Expect.isTrue(node.body is Block || node.body is Return);
     Expect.notEquals(node.body.getBeginToken(), node.body.getEndToken());
 }
 
 void expectHasNoBody(compiler, ElementX element) {
-    var node = element.parseNode(compiler.parsing);
+    var node = element.parseNode(compiler.parsingContext);
     Expect.isNotNull(node, "Element isn't parseable, when a body was expected");
     Expect.isFalse(node.hasBody);
 }
 
 Element ensure(compiler,
                String name,
                Element lookup(name),
                {bool expectIsPatched: false,
                 bool expectIsPatch: false,
                 bool checkHasBody: false,
@@ skipping 260 matching lines @@
         external String toString();
       }
       """,
       """
       @patch class Class {
         @patch String toString() => 'string';
       }
       """);
   var container = ensure(compiler, "Class", compiler.coreLibrary.find,
                          expectIsPatched: true);
-  container.parseNode(compiler.parsing);
+  container.parseNode(compiler.parsingContext);
   ensure(compiler, "Class", compiler.coreLibrary.patch.find,
          expectIsPatch: true);
 
   ensure(compiler, "toString", container.lookupLocalMember,
          expectIsPatched: true, checkHasBody: true);
   ensure(compiler, "toString", container.patch.lookupLocalMember,
          expectIsPatch: true, checkHasBody: true);
 
   DiagnosticCollector collector = compiler.diagnosticCollector;
   Expect.isTrue(collector.warnings.isEmpty,
                 "Unexpected warnings: ${collector.warnings}");
   Expect.isTrue(collector.errors.isEmpty,
                 "Unexpected errors: ${collector.errors}");
 }
 
 Future testPatchGetter() async {
   var compiler = await applyPatch(
       """
       class Class {
         external int get field;
       }
       """,
       """
       @patch class Class {
         @patch int get field => 5;
       }
       """);
   var container = ensure(compiler, "Class", compiler.coreLibrary.find,
                          expectIsPatched: true);
-  container.parseNode(compiler.parsing);
+  container.parseNode(compiler.parsingContext);
   ensure(compiler,
          "field",
          container.lookupLocalMember,
          expectIsGetter: true,
          expectIsPatched: true,
          checkHasBody: true);
   ensure(compiler,
          "field",
          container.patch.lookupLocalMember,
          expectIsGetter: true,
@@ skipping 13 matching lines @@
       class Class {
         void regular() {}
       }
       """,
       """
       @patch class Class {
       }
       """);
   var container = ensure(compiler, "Class", compiler.coreLibrary.find,
                          expectIsPatched: true);
-  container.parseNode(compiler.parsing);
+  container.parseNode(compiler.parsingContext);
   ensure(compiler, "Class", compiler.coreLibrary.patch.find,
          expectIsPatch: true);
 
   ensure(compiler, "regular", container.lookupLocalMember,
          checkHasBody: true, expectIsRegular: true);
   ensure(compiler, "regular", container.patch.lookupLocalMember,
          checkHasBody: true, expectIsRegular: true);
 
   DiagnosticCollector collector = compiler.diagnosticCollector;
   Expect.isTrue(collector.warnings.isEmpty,
                 "Unexpected warnings: ${collector.warnings}");
   Expect.isTrue(collector.errors.isEmpty,
                 "Unexpected errors: ${collector.errors}");
 }
 
 Future testInjectedMember() async {
   var compiler = await applyPatch(
       """
       class Class {
       }
       """,
       """
       @patch class Class {
         void _injected() {}
       }
       """);
   var container = ensure(compiler, "Class", compiler.coreLibrary.find,
                          expectIsPatched: true);
-  container.parseNode(compiler.parsing);
+  container.parseNode(compiler.parsingContext);
   ensure(compiler, "Class", compiler.coreLibrary.patch.find,
          expectIsPatch: true);
 
   ensure(compiler, "_injected", container.lookupLocalMember,
          expectIsFound: false);
   ensure(compiler, "_injected", container.patch.lookupLocalMember,
          checkHasBody: true, expectIsRegular: true);
 
   DiagnosticCollector collector = compiler.diagnosticCollector;
   Expect.isTrue(collector.warnings.isEmpty,
                 "Unexpected warnings: ${collector.warnings}");
   Expect.isTrue(collector.errors.isEmpty,
                 "Unexpected errors: ${collector.errors}");
 }
 
 Future testInjectedPublicMember() async {
   var compiler = await applyPatch(
       """
       class Class {
       }
       """,
       """
       @patch class Class {
         void injected() {}
       }
       """);
   var container = ensure(compiler, "Class", compiler.coreLibrary.find,
                          expectIsPatched: true);
-  container.parseNode(compiler.parsing);
+  container.parseNode(compiler.parsingContext);
   ensure(compiler, "Class", compiler.coreLibrary.patch.find,
          expectIsPatch: true);
 
   ensure(compiler, "injected", container.lookupLocalMember,
          expectIsFound: false);
   ensure(compiler, "injected", container.patch.lookupLocalMember,
          checkHasBody: true, expectIsRegular: true);
 
   DiagnosticCollector collector = compiler.diagnosticCollector;
   Expect.isTrue(collector.warnings.isEmpty,
@@ skipping 76 matching lines @@
         @patch void method7([String s2]) {}
         @patch void method8({String s2}) {}
         @patch void method9(int str) {}
         @patch void method10([int str]) {}
         @patch void method11({int str}) {}
       }
       """);
   var container = ensure(compiler, "Class", compiler.coreLibrary.find,
                          expectIsPatched: true);
   container.ensureResolved(compiler.resolution);
-  container.parseNode(compiler.parsing);
+  container.parseNode(compiler.parsingContext);
   DiagnosticCollector collector = compiler.diagnosticCollector;
 
   void expect(String methodName, List infos, List errors) {
     collector.clear();
     compiler.resolver.resolveMethodElement(
         ensure(compiler, methodName, container.lookupLocalMember,
             expectIsPatched: true, checkHasBody: true));
     Expect.equals(0, collector.warnings.length);
     Expect.equals(infos.length, collector.infos.length,
                   "Unexpected infos: ${collector.infos} on $methodName");
@@ skipping 59 matching lines @@
         external void foo();
       }
       """,
       """
       @patch class Class {
         // @patch void foo() {}
       }
       """);
   var container = ensure(compiler, "Class", compiler.coreLibrary.find,
                          expectIsPatched: true);
-  container.parseNode(compiler.parsing);
+  container.parseNode(compiler.parsingContext);
   DiagnosticCollector collector = compiler.diagnosticCollector;
   collector.clear();
   compiler.resolver.resolveMethodElement(
       ensure(compiler, "foo", container.lookupLocalMember));
   Expect.isTrue(collector.warnings.isEmpty,
                 "Unexpected warnings: ${collector.warnings}");
   print('testExternalWithoutImplementationMember:${collector.errors}');
   Expect.equals(1, collector.errors.length);
   Expect.isTrue(
       collector.errors.first.message.kind ==
@@ skipping 40 matching lines @@
       """
       class Class {}
       """,
       """
       @patch class Class {
         @patch void foo() {}
       }
       """);
   var container = ensure(compiler, "Class", compiler.coreLibrary.find,
                          expectIsPatched: true);
-  container.parseNode(compiler.parsing);
+  container.parseNode(compiler.parsingContext);
   DiagnosticCollector collector = compiler.diagnosticCollector;
 
   Expect.isTrue(collector.warnings.isEmpty,
                 "Unexpected warnings: ${collector.warnings}");
   print('testPatchNonExistingMember:${collector.errors}');
   Expect.equals(1, collector.errors.length);
   Expect.isTrue(
       collector.errors.first.message.kind == MessageKind.PATCH_NON_EXISTING);
 }
 
@@ skipping 67 matching lines @@
         void foo() {}
       }
       """,
       """
       @patch class Class {
         @patch void foo() {}
       }
       """);
   var container = ensure(compiler, "Class", compiler.coreLibrary.find,
                          expectIsPatched: true);
-  container.parseNode(compiler.parsing);
+  container.parseNode(compiler.parsingContext);
 
   DiagnosticCollector collector = compiler.diagnosticCollector;
   print('testPatchNonExternalMember.errors:${collector.errors}');
   print('testPatchNonExternalMember.warnings:${collector.warnings}');
   Expect.equals(1, collector.errors.length);
   Expect.isTrue(
       collector.errors.first.message.kind == MessageKind.PATCH_NON_EXTERNAL);
   Expect.equals(0, collector.warnings.length);
   Expect.equals(1, collector.infos.length);
   Expect.isTrue(collector.infos.first.message.kind ==
@@ skipping 312 matching lines @@
     await testPatchNonFunction();
 
     await testPatchAndSelector();
 
     await testEffectiveTarget();
 
     await testAnalyzeAllInjectedMembers();
     await testTypecheckPatchedMembers();
   });
 }