Use entity WorldImpl where possible

tests/compiler/dart2js/world_test.dart

 // Copyright (c) 2015, 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.
 
 library world_test;
 
 import 'package:expect/expect.dart';
 import 'package:async_helper/async_helper.dart';
 import 'type_test_helper.dart';
 import 'package:compiler/src/common/names.dart';
 import 'package:compiler/src/elements/elements.dart'
-    show Element, ClassElement, LibraryElement;
+    show ClassElement, LibraryElement;
+import 'package:compiler/src/elements/entities.dart';
 import 'package:compiler/src/universe/class_set.dart';
 import 'package:compiler/src/world.dart' show ClassQuery, ClosedWorld;
 
 void main() {
   asyncTest(() async {
     await testClassSets();
     await testProperties();
     await testNativeClasses();
     await testCommonSubclasses();
   });
@@ skipping 32 matching lines @@
   ClassElement Object_ = env.getElement("Object");
   ClassElement A = env.getElement("A");
   ClassElement B = env.getElement("B");
   ClassElement C = env.getElement("C");
   ClassElement D = env.getElement("D");
   ClassElement E = env.getElement("E");
   ClassElement F = env.getElement("F");
   ClassElement G = env.getElement("G");
   ClassElement X = env.getElement("X");
 
-  void checkClasses(String property, ClassElement cls,
-      Iterable<ClassElement> foundClasses, List<ClassElement> expectedClasses,
+  void checkClasses(String property, ClassEntity cls,
+      Iterable<ClassEntity> foundClasses, List<ClassEntity> expectedClasses,
       {bool exact: true}) {
-    for (ClassElement expectedClass in expectedClasses) {
+    for (ClassEntity expectedClass in expectedClasses) {
       Expect.isTrue(
           foundClasses.contains(expectedClass),
           "Expect $expectedClass in '$property' on $cls. "
           "Found:\n ${foundClasses.join('\n ')}\n"
           "${closedWorld.dump(cls)}");
     }
     if (exact) {
       Expect.equals(
           expectedClasses.length,
           foundClasses.length,
           "Unexpected classes "
           "${foundClasses.where((c) => !expectedClasses.contains(c))} "
           "in '$property' on $cls.\n"
           "${closedWorld.dump(cls)}");
     }
   }
 
-  void check(String property, ClassElement cls,
-      Iterable<ClassElement> foundClasses, List<ClassElement> expectedClasses,
+  void check(String property, ClassEntity cls,
+      Iterable<ClassEntity> foundClasses, List<ClassEntity> expectedClasses,
       {bool exact: true,
-      void forEach(ClassElement cls, ForEachFunction f),
-      int getCount(ClassElement cls)}) {
+      void forEach(ClassEntity cls, ForEachFunction f),
+      int getCount(ClassEntity cls)}) {
     checkClasses(property, cls, foundClasses, expectedClasses, exact: exact);
 
     if (forEach != null) {
-      List<ClassElement> visited = <ClassElement>[];
-      forEach(cls, (ClassElement c) {
+      List<ClassEntity> visited = <ClassEntity>[];
+      forEach(cls, (ClassEntity c) {
         visited.add(c);
       });
       checkClasses('forEach($property)', cls, visited, expectedClasses,
           exact: exact);
     }
 
     if (getCount != null && exact) {
       int count = getCount(cls);
       Expect.equals(
           expectedClasses.length,
           count,
           "Unexpected class count in '$property' on $cls.\n"
           "${closedWorld.dump(cls)}");
     }
   }
 
-  void testSubclasses(ClassElement cls, List<ClassElement> expectedClasses,
+  void testSubclasses(ClassEntity cls, List<ClassEntity> expectedClasses,
       {bool exact: true}) {
     check('subclassesOf', cls, closedWorld.subclassesOf(cls), expectedClasses,
         exact: exact);
   }
 
-  void testStrictSubclasses(
-      ClassElement cls, List<ClassElement> expectedClasses,
+  void testStrictSubclasses(ClassEntity cls, List<ClassEntity> expectedClasses,
       {bool exact: true}) {
     check('strictSubclassesOf', cls, closedWorld.strictSubclassesOf(cls),
         expectedClasses,
         exact: exact,
         forEach: closedWorld.forEachStrictSubclassOf,
         getCount: closedWorld.strictSubclassCount);
   }
 
-  void testStrictSubtypes(ClassElement cls, List<ClassElement> expectedClasses,
+  void testStrictSubtypes(ClassEntity cls, List<ClassEntity> expectedClasses,
       {bool exact: true}) {
     check('strictSubtypesOf', cls, closedWorld.strictSubtypesOf(cls),
         expectedClasses,
         exact: exact,
         forEach: closedWorld.forEachStrictSubtypeOf,
         getCount: closedWorld.strictSubtypeCount);
   }
 
-  void testMixinUses(ClassElement cls, List<ClassElement> expectedClasses,
+  void testMixinUses(ClassEntity cls, List<ClassEntity> expectedClasses,
       {bool exact: true}) {
     check('mixinUsesOf', cls, closedWorld.mixinUsesOf(cls), expectedClasses,
         exact: exact);
   }
 
   testSubclasses(Object_, [A, B, C, D, E, F, G], exact: false);
   testSubclasses(A, [A, C]);
   testSubclasses(B, [B, E]);
   testSubclasses(C, [C]);
   testSubclasses(D, [D]);
@@ skipping 88 matching lines @@
         new F2();
         new G2();
         new G3();
         new H4();
       }
       """,
       useMockCompiler: false);
   ClosedWorld closedWorld = env.closedWorld;
 
   check(String name, {bool hasStrictSubtype, bool hasOnlySubclasses}) {
-    ClassElement cls = env.getElement(name);
+    ClassEntity cls = env.getElement(name);
     Expect.equals(hasStrictSubtype, closedWorld.hasAnyStrictSubtype(cls),
         "Unexpected hasAnyStrictSubtype property on $cls.");
     Expect.equals(hasOnlySubclasses, closedWorld.hasOnlySubclasses(cls),
         "Unexpected hasOnlySubclasses property on $cls.");
   }
 
   check("Object", hasStrictSubtype: true, hasOnlySubclasses: true);
 
   // No instantiated Ax classes.
   check("A", hasStrictSubtype: false, hasOnlySubclasses: true);
@@ skipping 67 matching lines @@
   ClassElement clsEventTarget = dart_html.findExported('EventTarget');
   ClassElement clsWindow = dart_html.findExported('Window');
   ClassElement clsAbstractWorker = dart_html.findExported('AbstractWorker');
   ClassElement clsWorker = dart_html.findExported('Worker');
   ClassElement clsCanvasElement = dart_html.findExported('CanvasElement');
   ClassElement clsCanvasRenderingContext =
       dart_html.findExported('CanvasRenderingContext');
   ClassElement clsCanvasRenderingContext2D =
       dart_html.findExported('CanvasRenderingContext2D');
 
-  List<ClassElement> allClasses = [
+  List<ClassEntity> allClasses = [
     clsEventTarget,
     clsWindow,
     clsAbstractWorker,
     clsWorker,
     clsCanvasElement,
     clsCanvasRenderingContext,
     clsCanvasRenderingContext2D
   ];
 
-  check(ClassElement cls,
+  check(ClassEntity cls,
       {bool isDirectlyInstantiated,
       bool isAbstractlyInstantiated,
       bool isIndirectlyInstantiated,
       bool hasStrictSubtype,
       bool hasOnlySubclasses,
-      ClassElement lubOfInstantiatedSubclasses,
-      ClassElement lubOfInstantiatedSubtypes,
+      ClassEntity lubOfInstantiatedSubclasses,
+      ClassEntity lubOfInstantiatedSubtypes,
       int instantiatedSubclassCount,
       int instantiatedSubtypeCount,
-      List<ClassElement> subclasses: const <ClassElement>[],
-      List<ClassElement> subtypes: const <ClassElement>[]}) {
+      List<ClassEntity> subclasses: const <ClassEntity>[],
+      List<ClassEntity> subtypes: const <ClassEntity>[]}) {
     ClassSet classSet = closedWorld.getClassSet(cls);
     ClassHierarchyNode node = classSet.node;
 
     String dumpText = '\n${closedWorld.dump(cls)}';
 
     Expect.equals(
         isDirectlyInstantiated,
         closedWorld.isDirectlyInstantiated(cls),
         "Unexpected isDirectlyInstantiated property on $cls.$dumpText");
     Expect.equals(
@@ skipping 17 matching lines @@
         classSet.getLubOfInstantiatedSubtypes(),
         "Unexpected getLubOfInstantiatedSubtypes() result on $cls.$dumpText");
     if (instantiatedSubclassCount != null) {
       Expect.equals(instantiatedSubclassCount, node.instantiatedSubclassCount,
           "Unexpected instantiatedSubclassCount property on $cls.$dumpText");
     }
     if (instantiatedSubtypeCount != null) {
       Expect.equals(instantiatedSubtypeCount, classSet.instantiatedSubtypeCount,
           "Unexpected instantiatedSubtypeCount property on $cls.$dumpText");
     }
-    for (ClassElement other in allClasses) {
+    for (ClassEntity other in allClasses) {
       if (other == cls) continue;
       if (!closedWorld.isExplicitlyInstantiated(other)) continue;
       Expect.equals(
           subclasses.contains(other),
           closedWorld.isSubclassOf(other, cls),
           "Unexpected subclass relation between $other and $cls.");
       Expect.equals(
           subtypes.contains(other),
           closedWorld.isSubtypeOf(other, cls),
           "Unexpected subtype relation between $other and $cls.");
     }
 
-    Set<ClassElement> strictSubclasses = new Set<ClassElement>();
-    closedWorld.forEachStrictSubclassOf(cls, (ClassElement other) {
+    Set<ClassEntity> strictSubclasses = new Set<ClassEntity>();
+    closedWorld.forEachStrictSubclassOf(cls, (ClassEntity other) {
       if (allClasses.contains(other)) {
         strictSubclasses.add(other);
       }
     });
     Expect.setEquals(subclasses, strictSubclasses,
         "Unexpected strict subclasses of $cls: ${strictSubclasses}.");
 
-    Set<ClassElement> strictSubtypes = new Set<ClassElement>();
-    closedWorld.forEachStrictSubtypeOf(cls, (ClassElement other) {
+    Set<ClassEntity> strictSubtypes = new Set<ClassEntity>();
+    closedWorld.forEachStrictSubtypeOf(cls, (ClassEntity other) {
       if (allClasses.contains(other)) {
         strictSubtypes.add(other);
       }
     });
     Expect.setEquals(subtypes, strictSubtypes,
         "Unexpected strict subtypes of $cls: $strictSubtypes.");
   }
 
   // Extended by Window.
   check(clsEventTarget,
@@ skipping 118 matching lines @@
   ClassElement A = env.getElement("A");
   ClassElement B = env.getElement("B");
   ClassElement C = env.getElement("C");
   ClassElement D = env.getElement("D");
   ClassElement F = env.getElement("F");
   ClassElement G = env.getElement("G");
   ClassElement H = env.getElement("H");
   ClassElement I = env.getElement("I");
   ClassElement J = env.getElement("J");
 
-  void check(ClassElement cls1, ClassQuery query1, ClassElement cls2,
-      ClassQuery query2, List<ClassElement> expectedResult) {
-    Iterable<ClassElement> result1 =
+  void check(ClassEntity cls1, ClassQuery query1, ClassEntity cls2,
+      ClassQuery query2, List<ClassEntity> expectedResult) {
+    Iterable<ClassEntity> result1 =
         closedWorld.commonSubclasses(cls1, query1, cls2, query2);
-    Iterable<ClassElement> result2 =
+    Iterable<ClassEntity> result2 =
         closedWorld.commonSubclasses(cls2, query2, cls1, query1);
     Expect.setEquals(
         result1,
         result2,
         "Asymmetric results for ($cls1,$query1) vs ($cls2,$query2):"
         "\n a vs b: $result1\n b vs a: $result2");
     Expect.setEquals(
         expectedResult,
         result1,
         "Unexpected results for ($cls1,$query1) vs ($cls2,$query2):"
@@ skipping 30 matching lines @@
   check(B, ClassQuery.EXACT, C, ClassQuery.EXACT, []);
   check(B, ClassQuery.EXACT, C, ClassQuery.SUBCLASS, []);
   check(B, ClassQuery.SUBCLASS, C, ClassQuery.EXACT, []);
   check(B, ClassQuery.EXACT, C, ClassQuery.SUBTYPE, []);
   check(B, ClassQuery.SUBTYPE, C, ClassQuery.EXACT, []);
   check(B, ClassQuery.SUBCLASS, C, ClassQuery.SUBCLASS, []);
   check(B, ClassQuery.SUBCLASS, C, ClassQuery.SUBTYPE, []);
   check(B, ClassQuery.SUBTYPE, C, ClassQuery.SUBCLASS, [G]);
   check(B, ClassQuery.SUBTYPE, C, ClassQuery.SUBTYPE, [F, G]);
 }