Use DiagnosticMessage in MockCompiler.

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 114 matching lines @@
                     classC.allSupertypes.toString());
     }),
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("""
 class X<T> {}
 class Foo extends X<Foo> {}
 class Bar extends Foo implements X<Bar> {}
 """);
       compiler.resolveStatement("Bar bar;");
       ClassElement classBar = compiler.mainApp.find("Bar");
-      Expect.equals(0, compiler.warnings.length);
-      Expect.equals(1, compiler.errors.length);
+      DiagnosticCollector collector = compiler.diagnosticCollector;
+      Expect.equals(0, collector.warnings.length);
+      Expect.equals(1, collector.errors.length);
       Expect.equals(MessageKind.MULTI_INHERITANCE,
-                    compiler.errors[0].message.kind);
-      Expect.equals(0, compiler.crashes.length);
+                    collector.errors.first.message.kind);
+      Expect.equals(0, collector.crashes.length);
     }),
   ]);
 }
 
 Future testTypeVariables() {
   matchResolvedTypes(visitor, text, name, expectedElements) {
     VariableDefinitions definition = parseStatement(text);
     visitor.visit(definition.type);
     InterfaceType type = visitor.registry.mapping.getType(definition.type);
     Expect.equals(definition.type.typeArguments.slowLength(),
@@ skipping 15 matching lines @@
       matchResolvedTypes(visitor, 'Foo<int, String> x;', 'Foo',
                          [compiler.coreClasses.intClass,
                           compiler.coreClasses.stringClass]);
       matchResolvedTypes(visitor, 'Foo<Foo, Foo> x;', 'Foo',
                          [foo, foo]);
     }),
 
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript('class Foo<T, U> {}');
       compiler.resolveStatement('Foo<notype, int> x;');
-      Expect.equals(1, compiler.warnings.length);
+      DiagnosticCollector collector = compiler.diagnosticCollector;
+      Expect.equals(1, collector.warnings.length);
       Expect.equals(MessageKind.CANNOT_RESOLVE_TYPE,
-                    compiler.warnings[0].message.kind);
-      Expect.equals(0, compiler.errors.length);
+                    collector.warnings.first.message.kind);
+      Expect.equals(0, collector.errors.length);
     }),
 
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript('class Foo<T, U> {}');
       compiler.resolveStatement('var x = new Foo<notype, int>();');
-      Expect.equals(1, compiler.warnings.length);
-      Expect.equals(0, compiler.errors.length);
+      DiagnosticCollector collector = compiler.diagnosticCollector;
+      Expect.equals(1, collector.warnings.length);
+      Expect.equals(0, collector.errors.length);
       Expect.equals(MessageKind.CANNOT_RESOLVE_TYPE,
-                    compiler.warnings[0].message.kind);
+                    collector.warnings.first.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.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);
+      DiagnosticCollector collector = compiler.diagnosticCollector;
+      Expect.equals(0, collector.warnings.length);
+      Expect.equals(0, collector.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;");
@@ skipping 20 matching lines @@
 }
 
 Future testSwitch() {
   return MockCompiler.create((MockCompiler compiler) {
     compiler.parseScript("class Foo { foo() {"
         "switch (null) { case '': break; case 2: break; } } }");
     compiler.resolveStatement("Foo foo;");
     ClassElement fooElement = compiler.mainApp.find("Foo");
     FunctionElement funElement = fooElement.lookupLocalMember("foo");
     compiler.processQueue(compiler.enqueuer.resolution, funElement);
-    Expect.equals(0, compiler.warnings.length);
-    Expect.equals(1, compiler.errors.length);
+    DiagnosticCollector collector = compiler.diagnosticCollector;
+    Expect.equals(0, collector.warnings.length);
+    Expect.equals(1, collector.errors.length);
     Expect.equals(MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL,
-                  compiler.errors[0].message.kind);
-    Expect.equals(2, compiler.infos.length);
+                  collector.errors.first.message.kind);
+    Expect.equals(2, collector.infos.length);
     Expect.equals(MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL_CASE,
-                  compiler.infos[0].message.kind);
+                  collector.infos.first.message.kind);
     Expect.equals(MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL_CASE,
-                  compiler.infos[1].message.kind);
+                  collector.infos.elementAt(1).message.kind);
   });
 }
 
 Future testThis() {
   return Future.wait([
     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);
       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, compiler.warnings.length);
+      Expect.equals(0, collector.warnings.length);
     }),
     MockCompiler.create((MockCompiler compiler) {
       compiler.resolveStatement("main() { return this; }");
-      Expect.equals(0, compiler.warnings.length);
-      Expect.equals(1, compiler.errors.length);
+      DiagnosticCollector collector = compiler.diagnosticCollector;
+      Expect.equals(0, collector.warnings.length);
+      Expect.equals(1, collector.errors.length);
       Expect.equals(MessageKind.NO_INSTANCE_AVAILABLE,
-                    compiler.errors[0].message.kind);
+                    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);
       visitor.visit(function.body);
-      Expect.equals(0, compiler.warnings.length);
-      Expect.equals(1, compiler.errors.length);
+      DiagnosticCollector collector = compiler.diagnosticCollector;
+      Expect.equals(0, collector.warnings.length);
+      Expect.equals(1, collector.errors.length);
       Expect.equals(MessageKind.NO_INSTANCE_AVAILABLE,
-                    compiler.errors[0].message.kind);
+                    collector.errors.first.message.kind);
     }),
   ]);
 }
 
 Future testLocalsOne() {
   return Future.forEach([
       () => testLocals([["foo", false]]),
       () => testLocals([["foo", false], ["bar", false]]),
       () => testLocals([["foo", false], ["bar", false], ["foobar", false]]),
 
       () => testLocals([["foo", true]]),
       () => testLocals([["foo", false], ["bar", true]]),
       () => testLocals([["foo", true], ["bar", true]]),
 
       () => testLocals([["foo", false], ["bar", false], ["foobar", true]]),
       () => testLocals([["foo", false], ["bar", true], ["foobar", true]]),
       () => testLocals([["foo", true], ["bar", true], ["foobar", true]]),
 
       () => testLocals([["foo", false], ["foo", false]])
           .then((MockCompiler compiler) {
-      Expect.equals(1, compiler.errors.length);
+      DiagnosticCollector collector = compiler.diagnosticCollector;
+      Expect.equals(1, collector.errors.length);
       Expect.equals(
           new Message(
               MessageTemplate.TEMPLATES[MessageKind.DUPLICATE_DEFINITION],
               {'name': 'foo'}, false),
-          compiler.errors[0].message);
+          collector.errors.first.message);
     })], (f) => f());
 }
 
 
 Future testLocalsTwo() {
   return MockCompiler.create((MockCompiler compiler) {
     ResolverVisitor visitor = compiler.resolverVisitor();
     Node tree = parseStatement("if (true) { var a = 1; var b = 2; }");
     ResolutionResult result = visitor.visit(tree);
     Expect.equals(const NoneResult(), result);
@@ skipping 147 matching lines @@
 }
 
 Future testTypeAnnotation() {
   return MockCompiler.create((MockCompiler compiler) {
     String statement = "Foo bar;";
 
     // Test that we get a warning when Foo is not defined.
     Map mapping = compiler.resolveStatement(statement).map;
 
     Expect.equals(1, mapping.length); // Only [bar] has an element.
-    Expect.equals(1, compiler.warnings.length);
-
-    Node warningNode = compiler.warnings[0].node;
+    DiagnosticCollector collector = compiler.diagnosticCollector;
+    Expect.equals(1, collector.warnings.length);
 
     Expect.equals(
         new Message(
             MessageTemplate.TEMPLATES[MessageKind.CANNOT_RESOLVE_TYPE],
             {'typeName': 'Foo'}, false),
-        compiler.warnings[0].message);
-    VariableDefinitions definition = compiler.parsedTree;
-    Expect.equals(warningNode, definition.type);
-    compiler.clearMessages();
+        collector.warnings.first.message);
+    collector.clear();
 
     // Test that there is no warning after defining Foo.
     compiler.parseScript("class Foo {}");
     mapping = compiler.resolveStatement(statement).map;
     Expect.equals(1, mapping.length);
-    Expect.equals(0, compiler.warnings.length);
+    Expect.equals(0, collector.warnings.length);
 
     // Test that 'var' does not create a warning.
     mapping = compiler.resolveStatement("var foo;").map;
     Expect.equals(1, mapping.length);
-    Expect.equals(0, compiler.warnings.length);
+    Expect.equals(0, collector.warnings.length);
   });
 }
 
 Future testSuperclass() {
   return Future.wait([
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("class Foo extends Bar {}");
       compiler.resolveStatement("Foo bar;");
-      Expect.equals(1, compiler.errors.length);
+      DiagnosticCollector collector = compiler.diagnosticCollector;
+      Expect.equals(1, collector.errors.length);
       var cannotResolveBar = new Message(
           MessageTemplate.TEMPLATES[MessageKind.CANNOT_EXTEND_MALFORMED],
           {'className': 'Foo', 'malformedType': 'Bar'}, false);
-      Expect.equals(cannotResolveBar, compiler.errors[0].message);
-      compiler.clearMessages();
+      Expect.equals(cannotResolveBar, collector.errors.first.message);
+      collector.clear();
     }),
     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.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 {}");
     compiler.resolveStatement("Foo bar;");
-    Expect.equals(1, compiler.errors.length);
+    DiagnosticCollector collector = compiler.diagnosticCollector;
+    Expect.equals(1, collector.errors.length);
     Expect.equals(
         new Message(
             MessageTemplate.TEMPLATES[MessageKind.CANNOT_RESOLVE_TYPE],
             {'typeName': 'var'}, false),
-        compiler.errors[0].message);
-    compiler.clearMessages();
+        collector.errors.first.message);
+    collector.clear();
   });
 }
 
 Future testOneInterface() {
   return MockCompiler.create((MockCompiler compiler) {
     compiler.parseScript("class Foo implements Bar {}");
     compiler.resolveStatement("Foo bar;");
-    Expect.equals(1, compiler.errors.length);
+    DiagnosticCollector collector = compiler.diagnosticCollector;
+    Expect.equals(1, collector.errors.length);
     Expect.equals(
         new Message(
             MessageTemplate.TEMPLATES[MessageKind.CANNOT_RESOLVE_TYPE],
             {'typeName': 'bar'}, false),
-        compiler.errors[0].message);
-    compiler.clearMessages();
+        collector.errors.first.message);
+    collector.clear();
 
     // Add the abstract class to the world and make sure everything is setup
     // correctly.
     compiler.parseScript("abstract class Bar {}");
 
     ResolverVisitor visitor =
         new ResolverVisitor(compiler, null,
             new ResolutionRegistry(compiler,
                 new CollectingTreeElements(null)));
     compiler.resolveStatement("Foo bar;");
@@ skipping 114 matching lines @@
     FunctionExpression tree = (element as FunctionElement).node;
     ResolverVisitor visitor =
         new ResolverVisitor(compiler, element,
             new ResolutionRegistry(compiler,
                 new CollectingTreeElements(element)));
     new InitializerResolver(visitor, element, tree).resolveInitializers();
     visitor.visit(tree.body);
     Expect.equals(expectedElementCount, map(visitor).length,
         "${map(visitor).values} for '$statement' in context of `$script`");
 
-    compareWarningKinds(script, expectedWarnings, compiler.warnings);
-    compareWarningKinds(script, expectedErrors, compiler.errors);
-    compareWarningKinds(script, expectedInfos, compiler.infos);
+    DiagnosticCollector collector = compiler.diagnosticCollector;
+    compareWarningKinds(script, expectedWarnings, collector.warnings);
+    compareWarningKinds(script, expectedErrors, collector.errors);
+    compareWarningKinds(script, expectedInfos, collector.infos);
   });
 }
 
 Future testClassHierarchy() {
   final MAIN = "main";
   return Future.wait([
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("""class A extends A {}
                               main() { return new A(); }""");
       FunctionElement mainElement = compiler.mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
-      Expect.equals(0, compiler.warnings.length);
-      Expect.equals(1, compiler.errors.length);
+      DiagnosticCollector collector = compiler.diagnosticCollector;
+      Expect.equals(0, collector.warnings.length);
+      Expect.equals(1, collector.errors.length);
       Expect.equals(MessageKind.CYCLIC_CLASS_HIERARCHY,
-                    compiler.errors[0].message.kind);
+                    collector.errors.first.message.kind);
     }),
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("""class A extends B {}
                               class B extends A {}
                               main() { return new A(); }""");
       FunctionElement mainElement = compiler.mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
-      Expect.equals(0, compiler.warnings.length);
-      Expect.equals(2, compiler.errors.length);
+      DiagnosticCollector collector = compiler.diagnosticCollector;
+      Expect.equals(0, collector.warnings.length);
+      Expect.equals(2, collector.errors.length);
       Expect.equals(MessageKind.CYCLIC_CLASS_HIERARCHY,
-                    compiler.errors[0].message.kind);
+                    collector.errors.first.message.kind);
       Expect.equals(MessageKind.CANNOT_FIND_CONSTRUCTOR,
-                    compiler.errors[1].message.kind);
+                    collector.errors.elementAt(1).message.kind);
     }),
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("""abstract class A extends B {}
                               abstract class B extends A {}
                               class C implements A {}
                               main() { return new C(); }""");
       FunctionElement mainElement = compiler.mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
-      Expect.equals(0, compiler.warnings.length);
-      Expect.equals(1, compiler.errors.length);
+      DiagnosticCollector collector = compiler.diagnosticCollector;
+      Expect.equals(0, collector.warnings.length);
+      Expect.equals(1, collector.errors.length);
       Expect.equals(MessageKind.CYCLIC_CLASS_HIERARCHY,
-                    compiler.errors[0].message.kind);
+                    collector.errors.first.message.kind);
     }),
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("""class A extends B {}
                               class B extends C {}
                               class C {}
                               main() { return new A(); }""");
       FunctionElement mainElement = compiler.mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
-      Expect.equals(0, compiler.warnings.length);
-      Expect.equals(0, compiler.errors.length);
+      DiagnosticCollector collector = compiler.diagnosticCollector;
+      Expect.equals(0, collector.warnings.length);
+      Expect.equals(0, collector.errors.length);
       ClassElement aElement = compiler.mainApp.find("A");
       Link<DartType> supertypes = aElement.allSupertypes;
       Expect.equals(<String>['B', 'C', 'Object'].toString(),
                     asSortedStrings(supertypes).toString());
     }),
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("""class A<T> {}
                               class B<Z,W> extends A<int>
                                   implements I<Z,List<W>> {}
                               class I<X,Y> {}
                               class C extends B<bool,String> {}
                               main() { return new C(); }""");
       FunctionElement mainElement = compiler.mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
-      Expect.equals(0, compiler.warnings.length);
-      Expect.equals(0, compiler.errors.length);
+      DiagnosticCollector collector = compiler.diagnosticCollector;
+      Expect.equals(0, collector.warnings.length);
+      Expect.equals(0, collector.errors.length);
       ClassElement aElement = compiler.mainApp.find("C");
       Link<DartType> supertypes = aElement.allSupertypes;
       // Object is once per inheritance path, that is from both A and I.
       Expect.equals(<String>['A<int>', 'B<bool, String>',
                              'I<bool, List<String>>', 'Object'].toString(),
                     asSortedStrings(supertypes).toString());
     }),
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("""class A<T> {}
                               class D extends A<E> {}
                               class E extends D {}
                               main() { return new E(); }""");
       FunctionElement mainElement = compiler.mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
-      Expect.equals(0, compiler.warnings.length);
-      Expect.equals(0, compiler.errors.length);
+      DiagnosticCollector collector = compiler.diagnosticCollector;
+      Expect.equals(0, collector.warnings.length);
+      Expect.equals(0, collector.errors.length);
       ClassElement aElement = compiler.mainApp.find("E");
       Link<DartType> supertypes = aElement.allSupertypes;
       Expect.equals(<String>['A<E>', 'D', 'Object'].toString(),
                     asSortedStrings(supertypes).toString());
     }),
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("""class A<T> {}
                               class D extends A<int> implements A<double> {}
                               main() { return new D(); }""");
       FunctionElement mainElement = compiler.mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
-      Expect.equals(0, compiler.warnings.length);
-      Expect.equals(1, compiler.errors.length);
+      DiagnosticCollector collector = compiler.diagnosticCollector;
+      Expect.equals(0, collector.warnings.length);
+      Expect.equals(1, collector.errors.length);
       Expect.equals(MessageKind.MULTI_INHERITANCE,
-                    compiler.errors[0].message.kind);
-      Expect.equals(0, compiler.crashes.length);
+                    collector.errors.first.message.kind);
+      Expect.equals(0, collector.crashes.length);
     }),
   ]);
 }
 
 Future testEnumDeclaration() {
   final MAIN = "main";
   return Future.wait([
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("""enum Enum {}
                               main() { Enum e; }""");
       FunctionElement mainElement = compiler.mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
-      Expect.equals(0, compiler.warnings.length,
-                    'Unexpected warnings: ${compiler.warnings}');
-      Expect.equals(1, compiler.errors.length,
-                    'Unexpected errors: ${compiler.errors}');
+      DiagnosticCollector collector = compiler.diagnosticCollector;
+      Expect.equals(0, collector.warnings.length,
+                    'Unexpected warnings: ${collector.warnings}');
+      Expect.equals(1, collector.errors.length,
+                    'Unexpected errors: ${collector.errors}');
     }),
 
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("""enum Enum { A }
                               main() { Enum e = Enum.A; }""");
       FunctionElement mainElement = compiler.mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
-      Expect.equals(0, compiler.warnings.length,
-                    'Unexpected warnings: ${compiler.warnings}');
-      Expect.equals(0, compiler.errors.length,
-                    'Unexpected errors: ${compiler.errors}');
+      DiagnosticCollector collector = compiler.diagnosticCollector;
+      Expect.equals(0, collector.warnings.length,
+                    'Unexpected warnings: ${collector.warnings}');
+      Expect.equals(0, collector.errors.length,
+                    'Unexpected errors: ${collector.errors}');
     }),
 
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("""enum Enum { A }
                               main() { Enum e = Enum.B; }""");
       FunctionElement mainElement = compiler.mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
-      Expect.equals(1, compiler.warnings.length,
-                    'Unexpected warnings: ${compiler.warnings}');
+      DiagnosticCollector collector = compiler.diagnosticCollector;
+      Expect.equals(1, collector.warnings.length,
+                    'Unexpected warnings: ${collector.warnings}');
       Expect.equals(MessageKind.MEMBER_NOT_FOUND,
-                    compiler.warnings[0].message.kind);
-      Expect.equals(0, compiler.errors.length,
-                    'Unexpected errors: ${compiler.errors}');
+                    collector.warnings.first.message.kind);
+      Expect.equals(0, collector.errors.length,
+                    'Unexpected errors: ${collector.errors}');
     }),
 
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("""enum Enum { A }
                               main() { List values = Enum.values; }""");
       FunctionElement mainElement = compiler.mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
-      Expect.equals(0, compiler.warnings.length,
-                    'Unexpected warnings: ${compiler.warnings}');
-      Expect.equals(0, compiler.errors.length,
-                    'Unexpected errors: ${compiler.errors}');
+      DiagnosticCollector collector = compiler.diagnosticCollector;
+      Expect.equals(0, collector.warnings.length,
+                    'Unexpected warnings: ${collector.warnings}');
+      Expect.equals(0, collector.errors.length,
+                    'Unexpected errors: ${collector.errors}');
     }),
 
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("""enum Enum { A }
                               main() { new Enum(0, ''); }""");
       FunctionElement mainElement = compiler.mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
-      Expect.equals(0, compiler.warnings.length,
-                    'Unexpected warnings: ${compiler.warnings}');
-      Expect.equals(1, compiler.errors.length,
-                    'Unexpected errors: ${compiler.errors}');
+      DiagnosticCollector collector = compiler.diagnosticCollector;
+      Expect.equals(0, collector.warnings.length,
+                    'Unexpected warnings: ${collector.warnings}');
+      Expect.equals(1, collector.errors.length,
+                    'Unexpected errors: ${collector.errors}');
       Expect.equals(MessageKind.CANNOT_INSTANTIATE_ENUM,
-                    compiler.errors[0].message.kind);
+                    collector.errors.first.message.kind);
     }),
 
     MockCompiler.create((MockCompiler compiler) {

[sigurdm, 2015/11/10 07:52:54]

Not for this CL, but it seems these tests can be abstracted.

[Johnni Winther, 2015/11/10 09:38:52]

Acknowledged.

       compiler.parseScript("""enum Enum { A }
                               main() { const Enum(0, ''); }""");
       FunctionElement mainElement = compiler.mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
-      Expect.equals(0, compiler.warnings.length,
-                    'Unexpected warnings: ${compiler.warnings}');
-      Expect.equals(1, compiler.errors.length,
-                    'Unexpected errors: ${compiler.errors}');
+      DiagnosticCollector collector = compiler.diagnosticCollector;
+      Expect.equals(0, collector.warnings.length,
+                    'Unexpected warnings: ${collector.warnings}');
+      Expect.equals(1, collector.errors.length,
+                    'Unexpected errors: ${collector.errors}');
       Expect.equals(MessageKind.CANNOT_INSTANTIATE_ENUM,
-                    compiler.errors[0].message.kind);
+                    collector.errors.first.message.kind);
     }),
   ]);
 }
 
 Future testInitializers() {
   return Future.forEach([
     () {
       String script =
           """class A {
                     int foo; int bar;
@@ skipping 142 matching lines @@
                'const {"a": 0, "b": 1, "c": 2}'],
     'const <String, int>{"a": 0, "b": 1, "c": 2}':
         const ['"a"', '0', '"b"', '1', '"c"', '2',
                'const <String, int>{"a": 0, "b": 1, "c": 2}'],
   };
   return Future.forEach(testedConstants.keys, (String constant) {
     return MockCompiler.create((MockCompiler compiler) {
       CollectingTreeElements elements =
           compiler.resolveStatement("main() => $constant;");
       List<String> expectedConstants = testedConstants[constant];
-      Expect.equals(0, compiler.warnings.length);
-      Expect.equals(0, compiler.errors.length);
+      DiagnosticCollector collector = compiler.diagnosticCollector;
+      Expect.equals(0, collector.warnings.length);
+      Expect.equals(0, collector.errors.length);
       List<ConstantExpression> constants = elements.constants;
       String constantsText =
           '[${constants.map((c) => c.getText()).join(', ')}]';
       Expect.equals(expectedConstants.length, constants.length,
           "Expected ${expectedConstants.length} constants for `${constant}` "
           "found $constantsText.");
       for (int index = 0; index < expectedConstants.length; index++) {
         Expect.equals(expectedConstants[index], constants[index].getText(),
             "Expected ${expectedConstants} for `$constant`, "
             "found $constantsText.");
@@ skipping 87 matching lines @@
         operator==(other) => true;
       }
       class B {
         operator==(other) => true;
         get hashCode => 0;
       }
       main() {
         new A() == new B();
       }""";
   asyncTest(() => compileScript(script).then((compiler) {
-    Expect.equals(0, compiler.warnings.length);
-    Expect.equals(0, compiler.infos.length);
-    Expect.equals(1, compiler.hints.length);
+    DiagnosticCollector collector = compiler.diagnosticCollector;
+    Expect.equals(0, collector.warnings.length);
+    Expect.equals(0, collector.infos.length);
+    Expect.equals(1, collector.hints.length);
     Expect.equals(MessageKind.OVERRIDE_EQUALS_NOT_HASH_CODE,
-                  compiler.hints[0].message.kind);
-    Expect.equals(0, compiler.errors.length);
+                  collector.hints.first.message.kind);
+    Expect.equals(0, collector.errors.length);
   }));
 }
 
 testConstConstructorAndNonFinalFields() {
   void expect(compiler, List errors, List infos) {
-    Expect.equals(errors.length, compiler.errors.length);
+    DiagnosticCollector collector = compiler.diagnosticCollector;
+    Expect.equals(errors.length, collector.errors.length);
     for (int i = 0 ; i < errors.length ; i++) {
-      Expect.equals(errors[i], compiler.errors[i].message.kind);
+      Expect.equals(errors[i], collector.errors.elementAt(i).message.kind);
     }
-    Expect.equals(0, compiler.warnings.length);
-    Expect.equals(infos.length, compiler.infos.length);
+    Expect.equals(0, collector.warnings.length);
+    Expect.equals(infos.length, collector.infos.length);
     for (int i = 0 ; i < infos.length ; i++) {
-      Expect.equals(infos[i], compiler.infos[i].message.kind);
+      Expect.equals(infos[i], collector.infos.elementAt(i).message.kind);
     }
   }
 
   final script1 = r"""
       class A {
         var a;
         const A(this.a);
       }
       main() {
         new A(0);
@@ skipping 183 matching lines @@
       }
       ''', [MessageKind.SETTER_NOT_FOUND_IN_SUPER,
             // TODO(johnniwinther): Avoid duplicate warnings.
             MessageKind.SETTER_NOT_FOUND]);
 }
 
 /// Helper to test that [script] produces all the given [warnings].
 checkWarningOn(String script, List<MessageKind> warnings) {
   Expect.isTrue(warnings.length >= 0 && warnings.length <= 2);
   asyncTest(() => compileScript(script).then((compiler) {
-    Expect.equals(0, compiler.errors.length,
-        'Unexpected errors in\n$script\n${compiler.errors}');
-    Expect.equals(warnings.length, compiler.warnings.length,
+    DiagnosticCollector collector = compiler.diagnosticCollector;
+    Expect.equals(0, collector.errors.length,
+        'Unexpected errors in\n$script\n${collector.errors}');
+    Expect.equals(warnings.length, collector.warnings.length,
         'Unexpected warnings in\n$script\n'
-        'Expected:$warnings\nFound:${compiler.warnings}');
+        'Expected:$warnings\nFound:${collector.warnings}');
     for (int i = 0; i < warnings.length; i++) {
-      Expect.equals(warnings[i], compiler.warnings[i].message.kind);
+      Expect.equals(warnings[i], collector.warnings.elementAt(i).message.kind);
     }
   }));
 }
 
 testAwaitHint() {
   check(String script, {String className, String functionName}) {
     var prefix = className == null
         ? "Cannot resolve 'await'"
         : "No member named 'await' in class '$className'";
     var where = functionName == null
         ? 'the enclosing function' : "'$functionName'";
     asyncTest(() => compileScript(script).then((compiler) {
-      Expect.equals(0, compiler.errors.length);
-      Expect.equals(1, compiler.warnings.length);
+      DiagnosticCollector collector = compiler.diagnosticCollector;
+      Expect.equals(0, collector.errors.length);
+      Expect.equals(1, collector.warnings.length);
       Expect.equals("$prefix.\n"
           "Did you mean to add the 'async' marker to $where?",
-          '${compiler.warnings[0].message}');
+          '${collector.warnings.first.message}');
     }));
   }
   check('main() { await -3; }', functionName: 'main');
   check('main() { () => await -3; }');
   check('foo() => await -3; main() => foo();', functionName: 'foo');
   check('''
     class A {
       m() => await - 3;
     }
     main() => new A().m();
   ''', className: 'A', functionName: 'm');
   check('''
     class A {
       static m() => await - 3;
     }
     main() => A.m();
   ''', functionName: 'm');
   check('''
     class A {
       m() => () => await - 3;
     }
     main() => new A().m();
   ''', className: 'A');
 }