Refactor Parsing to remove compiler dependency

tests/compiler/dart2js/resolver_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 'dart:collection';
 
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
 import 'package:compiler/src/constants/expressions.dart';
@@ skipping 209 matching lines @@
     ClassElement classB = compiler.mainApp.find("B");
     FunctionElement fooB = classB.lookupLocalMember("foo");
     ClassElement classA = compiler.mainApp.find("A");
     FunctionElement fooA = classA.lookupLocalMember("foo");
 
     ResolverVisitor visitor =
         new ResolverVisitor(compiler, fooB,
             new ResolutionRegistry(compiler,
                 new CollectingTreeElements(fooB)));
     FunctionExpression node =
-        (fooB as FunctionElementX).parseNode(compiler.parsing);
+        (fooB as FunctionElementX).parseNode(compiler.parsingContext);
     visitor.visit(node.body);
     Map mapping = map(visitor);
 
     Send superCall = node.body.asReturn().expression;
     FunctionElement called = mapping[superCall];
     Expect.isNotNull(called);
     Expect.equals(fooA, called);
   });
 }
 
@@ skipping 23 matching lines @@
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("class Foo { foo() { return this; } }");
       compiler.resolveStatement("Foo foo;");
       ClassElement fooElement = compiler.mainApp.find("Foo");
       FunctionElement funElement = fooElement.lookupLocalMember("foo");
       ResolverVisitor visitor =
           new ResolverVisitor(compiler, funElement,
               new ResolutionRegistry(compiler,
                   new CollectingTreeElements(funElement)));
       FunctionExpression function =
-          (funElement as FunctionElementX).parseNode(compiler.parsing);
+          (funElement as FunctionElementX).parseNode(compiler.parsingContext);
       visitor.visit(function.body);
       Map mapping = map(visitor);
       List<Element> values = mapping.values.toList();
       DiagnosticCollector collector = compiler.diagnosticCollector;
       Expect.equals(0, mapping.length);
       Expect.equals(0, collector.warnings.length);
     }),
     MockCompiler.create((MockCompiler compiler) {
       compiler.resolveStatement("main() { return this; }");
       DiagnosticCollector collector = compiler.diagnosticCollector;
       Expect.equals(0, collector.warnings.length);
       Expect.equals(1, collector.errors.length);
       Expect.equals(MessageKind.NO_INSTANCE_AVAILABLE,
                     collector.errors.first.message.kind);
     }),
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("class Foo { static foo() { return this; } }");
       compiler.resolveStatement("Foo foo;");
       ClassElement fooElement = compiler.mainApp.find("Foo");
       FunctionElement funElement = fooElement.lookupLocalMember("foo");
       ResolverVisitor visitor = new ResolverVisitor(compiler, funElement,
           new ResolutionRegistry(compiler,
               new CollectingTreeElements(funElement)));
       FunctionExpression function =
-          (funElement as FunctionElementX).parseNode(compiler.parsing);
+          (funElement as FunctionElementX).parseNode(compiler.parsingContext);
       visitor.visit(function.body);
       DiagnosticCollector collector = compiler.diagnosticCollector;
       Expect.equals(0, collector.warnings.length);
       Expect.equals(1, collector.errors.length);
       Expect.equals(MessageKind.NO_INSTANCE_AVAILABLE,
                     collector.errors.first.message.kind);
     }),
   ]);
 }
 
@@ skipping 348 matching lines @@
     Expect.isTrue(element.isSynthesized);
   });
 }
 
 Future testTopLevelFields() {
   return MockCompiler.create((MockCompiler compiler) {
     compiler.parseScript("int a;");
     VariableElementX element = compiler.mainApp.find("a");
     Expect.equals(ElementKind.FIELD, element.kind);
     VariableDefinitions node =
-        element.variables.parseNode(element, compiler.parsing);
+        element.variables.parseNode(element, compiler.parsingContext);
     Identifier typeName = node.type.typeName;
     Expect.equals(typeName.source, 'int');
 
     compiler.parseScript("var b, c;");
     VariableElementX bElement = compiler.mainApp.find("b");
     VariableElementX cElement = compiler.mainApp.find("c");
     Expect.equals(ElementKind.FIELD, bElement.kind);
     Expect.equals(ElementKind.FIELD, cElement.kind);
     Expect.isTrue(bElement != cElement);
 
     VariableDefinitions bNode =
-        bElement.variables.parseNode(bElement, compiler.parsing);
+        bElement.variables.parseNode(bElement, compiler.parsingContext);
     VariableDefinitions cNode =
-        cElement.variables.parseNode(cElement, compiler.parsing);
+        cElement.variables.parseNode(cElement, compiler.parsingContext);
     Expect.equals(bNode, cNode);
     Expect.isNull(bNode.type);
     Expect.isTrue(bNode.modifiers.isVar);
   });
 }
 
 Future resolveConstructor(
     String script, String statement, String className,
     String constructor, int expectedElementCount,
     {List expectedWarnings: const [],
@@ skipping 748 matching lines @@
     }
     main() => A.m();
   ''', functionName: 'm');
   check('''
     class A {
       m() => () => await - 3;
     }
     main() => new A().m();
   ''', className: 'A');
 }