A step towards handling `new Object()` in compile_from_dill_test

pkg/compiler/lib/src/js_emitter/program_builder/collector.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.
 
 part of dart2js.js_emitter.program_builder;
 
 /**
  * Generates the code for all used classes in the program. Static fields (even
  * in classes) are ignored, since they can be treated as non-class elements.
  *
@@ skipping 192 matching lines @@
         .toList());
 
     // Compute needed classes.
     Set<ClassEntity> instantiatedClasses =
         // TODO(johnniwinther): This should be accessed from a codegen closed
         // world.
         _worldBuilder.directlyInstantiatedClasses
             .where(computeClassFilter())
             .toSet();
 
-    void addClassWithSuperclasses(ClassElement cls) {
+    void addClassWithSuperclasses(ClassEntity cls) {
       neededClasses.add(cls);
-      for (ClassElement superclass = cls.superclass;
+      for (ClassEntity superclass = _elementEnvironment.getSuperClass(cls);
           superclass != null;
-          superclass = superclass.superclass) {
+          superclass = _elementEnvironment.getSuperClass(superclass)) {
         neededClasses.add(superclass);
       }
     }
 
     void addClassesWithSuperclasses(Iterable<ClassEntity> classes) {
-      for (ClassElement cls in classes) {
+      for (ClassEntity cls in classes) {
         addClassWithSuperclasses(cls);
       }
     }
 
     // 1. We need to generate all classes that are instantiated.
     addClassesWithSuperclasses(instantiatedClasses);
 
     // 2. Add all classes used as mixins.
-    Set<ClassElement> mixinClasses = neededClasses
-        .where((ClassElement element) => element.isMixinApplication)
-        .map(computeMixinClass)
-        .toSet();
+    Set<ClassEntity> mixinClasses = new Set<ClassEntity>();
+    for (ClassEntity cls in neededClasses) {
+      _elementEnvironment.forEachMixin(cls, (ClassEntity mixinClass) {
+        mixinClasses.add(mixinClass);
+      });
+    }
     neededClasses.addAll(mixinClasses);
 
     // 3. Find all classes needed for rti.
     // It is important that this is the penultimate step, at this point,
     // neededClasses must only contain classes that have been resolved and
     // codegen'd. The rtiNeededClasses may contain additional classes, but
     // these are thought to not have been instantiated, so we neeed to be able
     // to identify them later and make sure we only emit "empty shells" without
     // fields, etc.
     classesOnlyNeededForRti = new Set<ClassElement>();
@@ skipping 29 matching lines @@
     // 4. Finally, sort the classes.
     List<ClassEntity> sortedClasses = _sorter.sortClasses(neededClasses);
 
     for (ClassEntity cls in sortedClasses) {
       if (_nativeData.isNativeOrExtendsNative(cls) &&
           !classesOnlyNeededForRti.contains(cls)) {
         // For now, native classes and related classes cannot be deferred.
         nativeClassesAndSubclasses.add(cls);
         assert(!_deferredLoadTask.isDeferredClass(cls), failedAt(cls));
         outputClassLists
-            .putIfAbsent(_deferredLoadTask.mainOutputUnit,
-                () => new List<ClassElement>())
+            .putIfAbsent(
+                _deferredLoadTask.mainOutputUnit, () => new List<ClassEntity>())
             .add(cls);
       } else {
         outputClassLists
             .putIfAbsent(_deferredLoadTask.outputUnitForClass(cls),
-                () => new List<ClassElement>())
+                () => new List<ClassEntity>())
             .add(cls);
       }
     }
   }
 
   void computeNeededStatics() {
     bool isStaticFunction(MemberEntity element) =>
         !element.isInstanceMember && !element.isField;
 
     Iterable<MemberEntity> elements =
@@ skipping 53 matching lines @@
   }
 
   void collect() {
     computeNeededDeclarations();
     computeNeededConstants();
     computeNeededStatics();
     computeNeededStaticNonFinalFields();
     computeNeededLibraries();
   }
 }