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

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 175 matching lines @@
                     compiler.warnings[0].message.kind);
     }),
 
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript('class Foo<T> {'
                            '  Foo<T> t;'
                            '  foo(Foo<T> f) {}'
                            '  bar() { g(Foo<T> f) {}; g(); }'
                            '}');
       ClassElement foo = compiler.mainApp.find('Foo');
-      foo.ensureResolved(compiler);
-      foo.lookupLocalMember('t').computeType(compiler);;
-      foo.lookupLocalMember('foo').computeType(compiler);;
+      foo.ensureResolved(compiler.resolution);
+      foo.lookupLocalMember('t').computeType(compiler.resolution);
+      foo.lookupLocalMember('foo').computeType(compiler.resolution);
       compiler.resolver.resolve(foo.lookupLocalMember('bar'));
       Expect.equals(0, compiler.warnings.length);
       Expect.equals(0, compiler.errors.length);
     }),
   ]);
 }
 
 Future testSuperCalls() {
   return MockCompiler.create((MockCompiler compiler) {
     String script = """class A { foo() {} }
                        class B extends A { foo() => super.foo(); }""";
     compiler.parseScript(script);
     compiler.resolveStatement("B b;");
 
     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);
+    FunctionExpression node =
+        (fooB as FunctionElementX).parseNode(compiler.parsing);
     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 22 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);
+          (funElement as FunctionElementX).parseNode(compiler.parsing);
       visitor.visit(function.body);
       Map mapping = map(visitor);
       List<Element> values = mapping.values.toList();
       Expect.equals(0, mapping.length);
       Expect.equals(0, compiler.warnings.length);
     }),
     MockCompiler.create((MockCompiler compiler) {
       compiler.resolveStatement("main() { return this; }");
       Expect.equals(0, compiler.warnings.length);
       Expect.equals(1, compiler.errors.length);
       Expect.equals(MessageKind.NO_INSTANCE_AVAILABLE,
                     compiler.errors[0].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);
+          (funElement as FunctionElementX).parseNode(compiler.parsing);
       visitor.visit(function.body);
       Expect.equals(0, compiler.warnings.length);
       Expect.equals(1, compiler.errors.length);
       Expect.equals(MessageKind.NO_INSTANCE_AVAILABLE,
                     compiler.errors[0].message.kind);
     }),
   ]);
 }
 
 Future testLocalsOne() {
@@ skipping 224 matching lines @@
       compiler.clearMessages();
     }),
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("class Foo extends Bar {}");
       compiler.parseScript("class Bar {}");
       Map mapping = compiler.resolveStatement("Foo bar;").map;
       Expect.equals(1, mapping.length);
 
       ClassElement fooElement = compiler.mainApp.find('Foo');
       ClassElement barElement = compiler.mainApp.find('Bar');
-      Expect.equals(barElement.computeType(compiler),
+      Expect.equals(barElement.computeType(compiler.resolution),
                     fooElement.supertype);
       Expect.isTrue(fooElement.interfaces.isEmpty);
       Expect.isTrue(barElement.interfaces.isEmpty);
     }),
   ]);
 }
 
 Future testVarSuperclass() {
   return MockCompiler.create((MockCompiler compiler) {
     compiler.parseScript("class Foo extends var {}");
@@ skipping 29 matching lines @@
             new ResolutionRegistry(compiler,
                 new CollectingTreeElements(null)));
     compiler.resolveStatement("Foo bar;");
 
     ClassElement fooElement = compiler.mainApp.find('Foo');
     ClassElement barElement = compiler.mainApp.find('Bar');
 
     Expect.equals(null, barElement.supertype);
     Expect.isTrue(barElement.interfaces.isEmpty);
 
-    Expect.equals(barElement.computeType(compiler),
+    Expect.equals(barElement.computeType(compiler.resolution),
                   fooElement.interfaces.head);
     Expect.equals(1, length(fooElement.interfaces));
   });
 }
 
 Future testTwoInterfaces() {
   return MockCompiler.create((MockCompiler compiler) {
     compiler.parseScript(
         """abstract class I1 {}
            abstract class I2 {}
            class C implements I1, I2 {}""");
     compiler.resolveStatement("Foo bar;");
 
     ClassElement c = compiler.mainApp.find('C');
     ClassElement i1 = compiler.mainApp.find('I1');
     ClassElement i2 = compiler.mainApp.find('I2');
 
     Expect.equals(2, length(c.interfaces));
-    Expect.equals(i1.computeType(compiler), at(c.interfaces, 0));
-    Expect.equals(i2.computeType(compiler), at(c.interfaces, 1));
+    Expect.equals(i1.computeType(compiler.resolution), at(c.interfaces, 0));
+    Expect.equals(i2.computeType(compiler.resolution), at(c.interfaces, 1));
   });
 }
 
 Future testFunctionExpression() {
   return MockCompiler.create((MockCompiler compiler) {
     ResolverVisitor visitor = compiler.resolverVisitor();
     Map mapping = compiler.resolveStatement("int f() {}").map;
     Expect.equals(2, mapping.length);
     Element element;
     Node node;
@@ skipping 30 matching lines @@
     Expect.equals(ElementKind.GENERATIVE_CONSTRUCTOR, element.kind);
     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);
+    VariableDefinitions node =
+        element.variables.parseNode(element, compiler.parsing);
     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);
-    VariableDefinitions cNode = cElement.variables.parseNode(cElement, compiler);
+    VariableDefinitions bNode =
+        bElement.variables.parseNode(bElement, compiler.parsing);
+    VariableDefinitions cNode =
+        cElement.variables.parseNode(cElement, compiler.parsing);
     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 729 matching lines @@
     }
     main() => A.m();
   ''', functionName: 'm');
   check('''
     class A {
       m() => () => await - 3;
     }
     main() => new A().m();
   ''', className: 'A');
 }