Run closed_world2_test using the normal compiler pipeline.

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 99 matching lines @@
 class J1 extends K1 {}
 class J2 implements K2 {}
 class K1 {}
 class K2 {}
 class L1 {}
 class A implements I1, I2 {}
 class B extends A implements J1, J2 {}
 class C extends B implements L1 {}
 """);
       compiler.resolveStatement("C c;");
-      ClassElement classA = compiler.mainApp.find("A");
-      ClassElement classB = compiler.mainApp.find("B");
-      ClassElement classC = compiler.mainApp.find("C");
+      LibraryElement mainApp = compiler.mainApp;
+      ClassElement classA = mainApp.find("A");
+      ClassElement classB = mainApp.find("B");
+      ClassElement classC = mainApp.find("C");
       Expect.equals('[ I2, I1, Object ]', classA.allSupertypes.toString());
       Expect.equals('[ A, J2, J1, I2, I1, K2, K1, Object ]',
           classB.allSupertypes.toString());
       Expect.equals('[ B, L1, A, J2, J1, I2, I1, K2, K1, Object ]',
           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");
+      LibraryElement mainApp = compiler.mainApp;
+      ClassElement classBar = mainApp.find("Bar");
       DiagnosticCollector collector = compiler.diagnosticCollector;
       Expect.equals(0, collector.warnings.length);
       Expect.equals(1, collector.errors.length);
       Expect.equals(
           MessageKind.MULTI_INHERITANCE, collector.errors.first.message.kind);
       Expect.equals(0, collector.crashes.length);
     }),
   ]);
 }
 
@@ skipping 12 matching lines @@
       Expect.equals(expectedElements[index], argument.element);
       index++;
     }
     Expect.equals(index, expectedElements.length);
   }
 
   return Future.wait([
     MockCompiler.create((MockCompiler compiler) {
       ResolverVisitor visitor = compiler.resolverVisitor();
       compiler.parseScript('class Foo<T, U> {}');
-      ClassElement foo = compiler.mainApp.find('Foo');
+      LibraryElement mainApp = compiler.mainApp;
+      ClassElement foo = mainApp.find('Foo');
       matchResolvedTypes(visitor, 'Foo<int, String> x;', 'Foo', [
         compiler.commonElements.intClass,
         compiler.commonElements.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;');
       DiagnosticCollector collector = compiler.diagnosticCollector;
@@ skipping 10 matching lines @@
       Expect.equals(0, collector.errors.length);
       Expect.equals(MessageKind.CANNOT_RESOLVE_TYPE,
           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');
+      LibraryElement mainApp = compiler.mainApp;
+      ClassElement foo = mainApp.find('Foo');
       foo.ensureResolved(compiler.resolution);
       MemberElement tMember = foo.lookupLocalMember('t');
       tMember.computeType(compiler.resolution);
       MemberElement fooMember = foo.lookupLocalMember('foo');
       fooMember.computeType(compiler.resolution);
       compiler.resolver.resolve(foo.lookupLocalMember('bar'));
       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;");
 
-    ClassElement classB = compiler.mainApp.find("B");
+    LibraryElement mainApp = compiler.mainApp;
+    ClassElement classB = mainApp.find("B");
     FunctionElement fooB = classB.lookupLocalMember("foo");
-    ClassElement classA = compiler.mainApp.find("A");
+    ClassElement classA = mainApp.find("A");
     FunctionElement fooA = classA.lookupLocalMember("foo");
 
     ResolverVisitor visitor = new ResolverVisitor(
         compiler.resolution,
         fooB,
         new ResolutionRegistry(
             compiler.backend.target, new CollectingTreeElements(fooB)),
         scope: new MockTypeVariablesScope(classB.buildScope()));
     FunctionExpression node =
         (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);
   });
 }
 
 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");
+    LibraryElement mainApp = compiler.mainApp;
+    ClassElement fooElement = mainApp.find("Foo");
     MethodElement funElement = fooElement.lookupLocalMember("foo");
     compiler.enqueuer.resolution.applyImpact(new WorldImpactBuilderImpl()
       ..registerStaticUse(new StaticUse.implicitInvoke(funElement)));
     compiler.processQueue(
         compiler.enqueuer.resolution, null, compiler.libraryLoader.libraries);
     DiagnosticCollector collector = compiler.diagnosticCollector;
     Expect.equals(0, collector.warnings.length);
     Expect.equals(1, collector.errors.length);
     Expect.equals(MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL,
         collector.errors.first.message.kind);
     Expect.equals(2, collector.infos.length);
     Expect.equals(MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL_CASE,
         collector.infos.first.message.kind);
     Expect.equals(MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL_CASE,
         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");
+      LibraryElement mainApp = compiler.mainApp;
+      ClassElement fooElement = mainApp.find("Foo");
       FunctionElement funElement = fooElement.lookupLocalMember("foo");
       ResolverVisitor visitor = new ResolverVisitor(
           compiler.resolution,
           funElement,
           new ResolutionRegistry(
               compiler.backend.target, new CollectingTreeElements(funElement)),
           scope: new MockTypeVariablesScope(fooElement.buildScope()));
       FunctionExpression function =
           (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");
+      LibraryElement mainApp = compiler.mainApp;
+      ClassElement fooElement = mainApp.find("Foo");
       FunctionElement funElement = fooElement.lookupLocalMember("foo");
       ResolverVisitor visitor = new ResolverVisitor(
           compiler.resolution,
           funElement,
           new ResolutionRegistry(
               compiler.backend.target, new CollectingTreeElements(funElement)),
           scope: new MockTypeVariablesScope(fooElement.buildScope()));
       FunctionExpression function =
           (funElement as FunctionElementX).parseNode(compiler.parsingContext);
       visitor.visit(function.body);
@@ skipping 260 matching lines @@
           false);
       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');
+      LibraryElement mainApp = compiler.mainApp;
+      ClassElement fooElement = mainApp.find('Foo');
+      ClassElement barElement = 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) {
@@ skipping 25 matching lines @@
     // correctly.
     compiler.parseScript("abstract class Bar {}");
 
     ResolverVisitor visitor = new ResolverVisitor(
         compiler.resolution,
         null,
         new ResolutionRegistry(
             compiler.backend.target, new CollectingTreeElements(null)));
     compiler.resolveStatement("Foo bar;");
 
-    ClassElement fooElement = compiler.mainApp.find('Foo');
-    ClassElement barElement = compiler.mainApp.find('Bar');
+    LibraryElement mainApp = compiler.mainApp;
+    ClassElement fooElement = mainApp.find('Foo');
+    ClassElement barElement = mainApp.find('Bar');
 
     Expect.equals(null, barElement.supertype);
     Expect.isTrue(barElement.interfaces.isEmpty);
 
     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');
+    LibraryElement mainApp = compiler.mainApp;
+    ClassElement c = mainApp.find('C');
+    ClassElement i1 = mainApp.find('I1');
+    ClassElement i2 = mainApp.find('I2');
 
     Expect.equals(2, length(c.interfaces));
     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) {
     Map mapping = compiler.resolveStatement("int f() {}").map;
     Expect.equals(2, mapping.length);
     Element element;
     Node node;
     mapping.forEach((Node n, Element e) {
       if (n is FunctionExpression) {
         element = e;
         node = n;
       }
     });
     Expect.equals(ElementKind.FUNCTION, element.kind);
     Expect.equals('f', element.name);
     Expect.equals((element as FunctionElement).node, node);
   });
 }
 
 Future testNewExpression() {
   return MockCompiler.create((MockCompiler compiler) {
     compiler.parseScript("class A {} foo() { print(new A()); }");
-    ClassElement aElement = compiler.mainApp.find('A');
+    LibraryElement mainApp = compiler.mainApp;
+    ClassElement aElement = mainApp.find('A');
 
-    FunctionElement fooElement = compiler.mainApp.find('foo');
+    FunctionElement fooElement = mainApp.find('foo');
     compiler.resolver.resolve(fooElement);
 
     Expect.isNotNull(aElement);
     Expect.isNotNull(fooElement);
 
     fooElement.node;
     compiler.resolver.resolve(fooElement);
 
     TreeElements elements = compiler.resolveStatement("new A();");
     NewExpression expression =
         compiler.parsedTree.asExpressionStatement().expression;
     Element element = elements[expression.send];
     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");
+    LibraryElement mainApp = compiler.mainApp;
+    VariableElementX element = mainApp.find("a");
     Expect.equals(ElementKind.FIELD, element.kind);
     VariableDefinitions node =
         element.variables.parseNode(element, compiler.parsingContext);
     NominalTypeAnnotation annotation = node.type;
     Identifier typeName = annotation.typeName;
     Expect.equals(typeName.source, 'int');
 
     compiler.parseScript("var b, c;");
-    VariableElementX bElement = compiler.mainApp.find("b");
-    VariableElementX cElement = compiler.mainApp.find("c");
+    VariableElementX bElement = mainApp.find("b");
+    VariableElementX cElement = 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.parsingContext);
     VariableDefinitions cNode =
         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 [],
     List expectedErrors: const [],
     List expectedInfos: const [],
     Map<String, String> corelib}) {
   MockCompiler compiler = new MockCompiler.internal(coreSource: corelib);
   return compiler.init().then((_) {
     compiler.parseScript(script);
     compiler.resolveStatement(statement);
-    ClassElement classElement = compiler.mainApp.find(className);
+    LibraryElement mainApp = compiler.mainApp;
+    ClassElement classElement = mainApp.find(className);
     Element element;
     element = classElement.lookupConstructor(constructor);
     FunctionExpression tree = (element as FunctionElement).node;
     ResolverVisitor visitor = new ResolverVisitor(
         compiler.resolution,
         element,
         new ResolutionRegistry(
             compiler.backend.target, new CollectingTreeElements(element)),
         scope: classElement.buildScope());
     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`");
 
     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);
+      LibraryElement mainApp = compiler.mainApp;
+      FunctionElement mainElement = mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
       DiagnosticCollector collector = compiler.diagnosticCollector;
       Expect.equals(0, collector.warnings.length);
       Expect.equals(1, collector.errors.length);
       Expect.equals(MessageKind.CYCLIC_CLASS_HIERARCHY,
           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);
+      LibraryElement mainApp = compiler.mainApp;
+      FunctionElement mainElement = mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
       DiagnosticCollector collector = compiler.diagnosticCollector;
       Expect.equals(0, collector.warnings.length);
       Expect.equals(2, collector.errors.length);
       Expect.equals(MessageKind.CYCLIC_CLASS_HIERARCHY,
           collector.errors.first.message.kind);
       Expect.equals(MessageKind.CANNOT_FIND_UNNAMED_CONSTRUCTOR,
           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);
+      LibraryElement mainApp = compiler.mainApp;
+      FunctionElement mainElement = mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
       DiagnosticCollector collector = compiler.diagnosticCollector;
       Expect.equals(0, collector.warnings.length);
       Expect.equals(1, collector.errors.length);
       Expect.equals(MessageKind.CYCLIC_CLASS_HIERARCHY,
           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);
+      LibraryElement mainApp = compiler.mainApp;
+      FunctionElement mainElement = mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
       DiagnosticCollector collector = compiler.diagnosticCollector;
       Expect.equals(0, collector.warnings.length);
       Expect.equals(0, collector.errors.length);
-      ClassElement aElement = compiler.mainApp.find("A");
+      ClassElement aElement = mainApp.find("A");
       Link<InterfaceType> 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);
+      LibraryElement mainApp = compiler.mainApp;
+      FunctionElement mainElement = mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
       DiagnosticCollector collector = compiler.diagnosticCollector;
       Expect.equals(0, collector.warnings.length);
       Expect.equals(0, collector.errors.length);
-      ClassElement aElement = compiler.mainApp.find("C");
+      ClassElement aElement = mainApp.find("C");
       Link<InterfaceType> 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);
+      LibraryElement mainApp = compiler.mainApp;
+      FunctionElement mainElement = mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
       DiagnosticCollector collector = compiler.diagnosticCollector;
       Expect.equals(0, collector.warnings.length);
       Expect.equals(0, collector.errors.length);
-      ClassElement aElement = compiler.mainApp.find("E");
+      ClassElement aElement = mainApp.find("E");
       Link<InterfaceType> 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);
+      LibraryElement mainApp = compiler.mainApp;
+      FunctionElement mainElement = mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
       DiagnosticCollector collector = compiler.diagnosticCollector;
       Expect.equals(0, collector.warnings.length);
       Expect.equals(1, collector.errors.length);
       Expect.equals(
           MessageKind.MULTI_INHERITANCE, 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);
+      LibraryElement mainApp = compiler.mainApp;
+      FunctionElement mainElement = mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
       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);
+      LibraryElement mainApp = compiler.mainApp;
+      FunctionElement mainElement = mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
       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);
+      LibraryElement mainApp = compiler.mainApp;
+      FunctionElement mainElement = mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
       DiagnosticCollector collector = compiler.diagnosticCollector;
       Expect.equals(1, collector.warnings.length,
           'Unexpected warnings: ${collector.warnings}');
       Expect.equals(
           MessageKind.UNDEFINED_GETTER, 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);
+      LibraryElement mainApp = compiler.mainApp;
+      FunctionElement mainElement = mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
       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);
+      LibraryElement mainApp = compiler.mainApp;
+      FunctionElement mainElement = mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
       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,
           collector.errors.first.message.kind);
     }),
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("""enum Enum { A }
                               main() { const Enum(0, ''); }""");
-      FunctionElement mainElement = compiler.mainApp.find(MAIN);
+      LibraryElement mainApp = compiler.mainApp;
+      FunctionElement mainElement = mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
       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,
           collector.errors.first.message.kind);
     }),
   ]);
@@ skipping 595 matching lines @@
       functionName: 'm');
   check(
       '''
     class A {
       m() => () => await - 3;
     }
     main() => new A().m();
   ''',
       className: 'A');
 }