Remove Compiler.commonElements

tests/compiler/dart2js/type_combination_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 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
 import 'package:compiler/src/js_backend/backend.dart' show JavaScriptBackend;
 import 'package:compiler/src/js_backend/js_backend.dart';
 import 'package:compiler/src/types/types.dart';
 import 'package:compiler/src/world.dart';
@@ skipping 731 matching lines @@
 
 void main() {
   asyncTest(() async {
     MockCompiler compiler = new MockCompiler.internal();
     await compiler.init("""
     class PatternImpl implements Pattern {}
     """);
     JavaScriptBackend backend = compiler.backend;
     WorldImpactBuilderImpl impactBuilder = new WorldImpactBuilderImpl();
     LibraryElement interceptorsLibrary =
-        compiler.commonElements.interceptorsLibrary;
+        compiler.resolution.commonElements.interceptorsLibrary;
     interceptorsLibrary.forEachLocalMember((element) {
       if (element.isClass) {
         element.ensureResolved(compiler.resolution);
         impactBuilder
             .registerTypeUse(new TypeUse.instantiation(element.rawType));
       }
     });
     LibraryElement mainApp = compiler.mainApp;
     ClassElement patternImplClass = mainApp.find('PatternImpl');
     patternImplClass.ensureResolved(compiler.resolution);
 
-    impactBuilder.registerTypeUse(
-        new TypeUse.instantiation(compiler.commonElements.mapType()));
-    impactBuilder.registerTypeUse(
-        new TypeUse.instantiation(compiler.commonElements.functionType));
+    impactBuilder.registerTypeUse(new TypeUse.instantiation(
+        compiler.resolution.commonElements.mapType()));
+    impactBuilder.registerTypeUse(new TypeUse.instantiation(
+        compiler.resolution.commonElements.functionType));
     impactBuilder
         .registerTypeUse(new TypeUse.instantiation(patternImplClass.rawType));
     compiler.enqueuer.resolution.applyImpact(impactBuilder);
     backend.onResolutionEnd();
     compiler.closeResolution();
     ClosedWorld closedWorld =
         compiler.resolutionWorldBuilder.closedWorldForTesting;
 
     // Grab hold of a supertype for String so we can produce potential
     // string types.
     LibraryElement coreLibrary = closedWorld.commonElements.coreLibrary;
     patternClass = coreLibrary.find('Pattern');
 
     nonPrimitive1 = new TypeMask.nonNullSubtype(
         closedWorld.commonElements.mapClass, closedWorld);
     nonPrimitive2 = new TypeMask.nonNullSubtype(
         closedWorld.commonElements.functionClass, closedWorld);
     potentialArray =
         new TypeMask.subtype(closedWorld.commonElements.listClass, closedWorld);
     potentialString = new TypeMask.subtype(patternClass, closedWorld);
     jsInterceptor = new TypeMask.nonNullSubclass(
-        compiler.commonElements.jsInterceptorClass, closedWorld);
+        closedWorld.commonElements.jsInterceptorClass, closedWorld);
     jsArrayOrNull = new TypeMask.subclass(
-        compiler.commonElements.jsArrayClass, closedWorld);
+        closedWorld.commonElements.jsArrayClass, closedWorld);
     jsReadableArray = new TypeMask.nonNullSubclass(
-        compiler.commonElements.jsArrayClass, closedWorld);
+        closedWorld.commonElements.jsArrayClass, closedWorld);
     jsMutableArrayOrNull = new TypeMask.subclass(
-        compiler.commonElements.jsMutableArrayClass, closedWorld);
+        closedWorld.commonElements.jsMutableArrayClass, closedWorld);
     jsMutableArray = new TypeMask.nonNullSubclass(
-        compiler.commonElements.jsMutableArrayClass, closedWorld);
+        closedWorld.commonElements.jsMutableArrayClass, closedWorld);
     jsFixedArrayOrNull = new TypeMask.exact(
-        compiler.commonElements.jsFixedArrayClass, closedWorld);
+        closedWorld.commonElements.jsFixedArrayClass, closedWorld);
     jsFixedArray = new TypeMask.nonNullExact(
-        compiler.commonElements.jsFixedArrayClass, closedWorld);
+        closedWorld.commonElements.jsFixedArrayClass, closedWorld);
     jsExtendableArrayOrNull = new TypeMask.exact(
-        compiler.commonElements.jsExtendableArrayClass, closedWorld);
+        closedWorld.commonElements.jsExtendableArrayClass, closedWorld);
     jsExtendableArray = new TypeMask.nonNullExact(
-        compiler.commonElements.jsExtendableArrayClass, closedWorld);
+        closedWorld.commonElements.jsExtendableArrayClass, closedWorld);
     jsUnmodifiableArrayOrNull = new TypeMask.exact(
-        compiler.commonElements.jsUnmodifiableArrayClass, closedWorld);
+        closedWorld.commonElements.jsUnmodifiableArrayClass, closedWorld);
     jsUnmodifiableArray = new TypeMask.nonNullExact(
-        compiler.commonElements.jsUnmodifiableArrayClass, closedWorld);
+        closedWorld.commonElements.jsUnmodifiableArrayClass, closedWorld);
     jsIndexableOrNull = new TypeMask.subtype(
-        compiler.commonElements.jsIndexableClass, closedWorld);
+        closedWorld.commonElements.jsIndexableClass, closedWorld);
     jsIndexable = new TypeMask.nonNullSubtype(
-        compiler.commonElements.jsIndexableClass, closedWorld);
+        closedWorld.commonElements.jsIndexableClass, closedWorld);
     jsInterceptorOrNull = new TypeMask.subclass(
-        compiler.commonElements.jsInterceptorClass, closedWorld);
-    jsStringOrNull =
-        new TypeMask.exact(compiler.commonElements.jsStringClass, closedWorld);
+        closedWorld.commonElements.jsInterceptorClass, closedWorld);
+    jsStringOrNull = new TypeMask.exact(
+        closedWorld.commonElements.jsStringClass, closedWorld);
     jsString = new TypeMask.nonNullExact(
-        compiler.commonElements.jsStringClass, closedWorld);
+        closedWorld.commonElements.jsStringClass, closedWorld);
     jsBoolean = new TypeMask.nonNullExact(
-        compiler.commonElements.jsBoolClass, closedWorld);
+        closedWorld.commonElements.jsBoolClass, closedWorld);
     jsNumber = new TypeMask.nonNullSubclass(
-        compiler.commonElements.jsNumberClass, closedWorld);
+        closedWorld.commonElements.jsNumberClass, closedWorld);
     jsInteger = new TypeMask.nonNullExact(
-        compiler.commonElements.jsIntClass, closedWorld);
+        closedWorld.commonElements.jsIntClass, closedWorld);
     jsDouble = new TypeMask.nonNullExact(
-        compiler.commonElements.jsDoubleClass, closedWorld);
+        closedWorld.commonElements.jsDoubleClass, closedWorld);
     jsBooleanOrNull =
-        new TypeMask.exact(compiler.commonElements.jsBoolClass, closedWorld);
+        new TypeMask.exact(closedWorld.commonElements.jsBoolClass, closedWorld);
     jsNumberOrNull = new TypeMask.subclass(
-        compiler.commonElements.jsNumberClass, closedWorld);
+        closedWorld.commonElements.jsNumberClass, closedWorld);
     jsIntegerOrNull =
-        new TypeMask.exact(compiler.commonElements.jsIntClass, closedWorld);
-    jsDoubleOrNull =
-        new TypeMask.exact(compiler.commonElements.jsDoubleClass, closedWorld);
+        new TypeMask.exact(closedWorld.commonElements.jsIntClass, closedWorld);
+    jsDoubleOrNull = new TypeMask.exact(
+        closedWorld.commonElements.jsDoubleClass, closedWorld);
     nullType = const TypeMask.empty();
     objectType = new TypeMask.nonNullSubclass(
         closedWorld.commonElements.objectClass, closedWorld);
     emptyType = const TypeMask.nonNullEmpty();
     dynamicType = new TypeMask.subclass(
         closedWorld.commonElements.objectClass, closedWorld);
 
     Expect.notEquals(
         emptyType, nonPrimitive1, "nonPrimitive1 expected to be non-empty.");
     Expect.notEquals(jsStringOrNull, potentialString,
         "potentialString expected not to be exact JSString");
     Expect.notEquals(jsArrayOrNull, potentialArray,
         "potentialArray expected not to be JSArray subclass");
 
     testUnion(compiler);
     testIntersection(compiler);
     testRegressions(compiler);
   });
 }