Run closed_world2_test using the normal compiler pipeline.

pkg/compiler/lib/src/enqueue.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.
 
 library dart2js.enqueue;
 
 import 'dart:collection' show Queue;
 
 import 'common/resolution.dart' show Resolution;
 import 'common/tasks.dart' show CompilerTask;
 import 'common/work.dart' show WorkItem;
 import 'common.dart';
+import 'common_elements.dart' show ElementEnvironment;
 import 'constants/values.dart';
 import 'compiler.dart' show Compiler;
 import 'options.dart';
-import 'elements/elements.dart'
-    show AnalyzableElement, ClassElement, MemberElement;
+import 'elements/elements.dart' show AnalyzableElement, MemberElement;
 import 'elements/entities.dart';
 import 'elements/resolution_types.dart' show ResolutionTypedefType;
 import 'elements/types.dart';
 import 'universe/world_builder.dart';
 import 'universe/use.dart'
     show
         ConstantUse,
         DynamicUse,
         StaticUse,
         StaticUseKind,
@@ skipping 50 matching lines @@
   bool get queueIsEmpty;
 
   ImpactUseCase get impactUse;
 
   void forEach(void f(WorkItem work));
 
   /// Apply the [worldImpact] to this enqueuer. If the [impactSource] is
   /// provided the impact strategy will remove it from the element impact cache,
   /// if it is no longer needed.
   void applyImpact(WorldImpact worldImpact, {var impactSource});
-  bool checkNoEnqueuedInvokedInstanceMethods();
+  bool checkNoEnqueuedInvokedInstanceMethods(
+      ElementEnvironment elementEnvironment);
 
   /// Check the enqueuer queue is empty or fail otherwise.
   void checkQueueIsEmpty();
   void logSummary(void log(String message));
 
   Iterable<MemberEntity> get processedEntities;
 
   Iterable<ClassEntity> get processedClasses;
 }
 
@@ skipping 149 matching lines @@
     task.measure(() {
       _worldBuilder.registerTypeInstantiation(type, _applyClassUse,
           constructor: constructor,
           byMirrors: mirrorUsage,
           isRedirection: isRedirection);
       listener.registerInstantiatedType(type,
           isGlobal: globalDependency && !mirrorUsage, nativeUsage: nativeUsage);
     });
   }
 
-  bool checkNoEnqueuedInvokedInstanceMethods() {
-    return strategy.checkEnqueuerConsistency(this);
+  bool checkNoEnqueuedInvokedInstanceMethods(
+      ElementEnvironment elementEnvironment) {
+    return strategy.checkEnqueuerConsistency(this, elementEnvironment);
   }
 
   void checkClass(ClassEntity cls) {
     _worldBuilder.processClassMembers(cls,
         (MemberEntity member, EnumSet<MemberUse> useSet) {
       if (useSet.isNotEmpty) {
         _reporter.internalError(member,
             'Unenqueued use of $member: ${useSet.iterable(MemberUse.values)}');
       }
     });
@@ skipping 229 matching lines @@
   /// Process a type use in live code.
   void processTypeUse(EnqueuerImpl enqueuer, TypeUse typeUse) {}
 
   /// Process a dynamic use for a call site in live code.
   void processDynamicUse(EnqueuerImpl enqueuer, DynamicUse dynamicUse) {}
 
   /// Process a constant use in live code.
   void processConstantUse(EnqueuerImpl enqueuer, ConstantUse constantUse) {}
 
   /// Check enqueuer consistency after the queue has been closed.
-  bool checkEnqueuerConsistency(EnqueuerImpl enqueuer) => true;
+  bool checkEnqueuerConsistency(
+          EnqueuerImpl enqueuer, ElementEnvironment elementEnvironment) =>
+      true;
 
   /// Process [work] using [f].
   void processWorkItem(void f(WorkItem work), WorkItem work) {
     f(work);
   }
 }
 
 /// Strategy that only enqueues directly used elements.
 class DirectEnqueuerStrategy extends EnqueuerStrategy {
   const DirectEnqueuerStrategy();
@@ skipping 22 matching lines @@
   void processDynamicUse(EnqueuerImpl enqueuer, DynamicUse dynamicUse) {
     enqueuer.processDynamicUse(dynamicUse);
   }
 
   @override
   void processConstantUse(EnqueuerImpl enqueuer, ConstantUse constantUse) {
     enqueuer.processConstantUse(constantUse);
   }
 
   /// Check enqueuer consistency after the queue has been closed.
-  bool checkEnqueuerConsistency(EnqueuerImpl enqueuer) {
+  bool checkEnqueuerConsistency(
+      EnqueuerImpl enqueuer, ElementEnvironment elementEnvironment) {
     enqueuer.task.measure(() {
       // Run through the classes and see if we need to enqueue more methods.
-      for (ClassElement classElement
+      for (ClassEntity classElement
           in enqueuer.worldBuilder.directlyInstantiatedClasses) {
-        for (ClassElement currentClass = classElement;
+        for (ClassEntity currentClass = classElement;
             currentClass != null;
-            currentClass = currentClass.superclass) {
+            currentClass = elementEnvironment.getSuperClass(currentClass)) {
           enqueuer.checkClass(currentClass);
         }
       }
     });
     return true;
   }
 }
 
 class EnqueuerImplImpactVisitor implements WorldImpactVisitor {
   final EnqueuerImpl enqueuer;
@@ skipping 45 matching lines @@
   @override
   WorkItem createWorkItem(MemberElement element) {
     assert(invariant(element, element.isDeclaration));
     if (element.isMalformed) return null;
 
     assert(invariant(element, element is AnalyzableElement,
         message: 'Element $element is not analyzable.'));
     return _resolution.createWorkItem(element);
   }
 }