Merge WorldImpl with ResolutionWorldBuilderImpl

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 'cache_strategy.dart';
 import 'common/backend_api.dart' show Backend;
@@ skipping 52 matching lines @@
   ResolutionEnqueuer get resolution => _resolution;
   Enqueuer get codegen => _codegen;
 
   void forgetEntity(Entity entity) {
     resolution.forgetEntity(entity, compiler);
     codegen.forgetEntity(entity, compiler);
   }
 }
 
 abstract class Enqueuer {
+  // TODO(johnniwinther): Rename to `worldBuilder`.
   WorldBuilder get universe;
   native.NativeEnqueuer get nativeEnqueuer;
   void forgetEntity(Entity entity, Compiler compiler);
 
   // TODO(johnniwinther): Initialize [_impactStrategy] to `null`.
   ImpactStrategy _impactStrategy = const ImpactStrategy();
 
   ImpactStrategy get impactStrategy => _impactStrategy;
 
   void open(ImpactStrategy impactStrategy) {
@@ skipping 80 matching lines @@
       : this.backend = backend,
         this._resolution = resolution,
         this.nativeEnqueuer = backend.nativeResolutionEnqueuer(),
         _universe = new ResolutionWorldBuilderImpl(
             backend, resolution, cacheStrategy, const OpenWorldStrategy()) {
     _impactVisitor = new EnqueuerImplImpactVisitor(this);
   }
 
   ResolutionWorldBuilder get universe => _universe;
 
-  OpenWorld get _openWorld => universe.openWorld;
-
   bool get queueIsEmpty => _queue.isEmpty;
 
   DiagnosticReporter get _reporter => _resolution.reporter;
 
   Iterable<ClassEntity> get processedClasses => _universe.processedClasses;
 
   void applyImpact(WorldImpact worldImpact, {var impactSource}) {
     if (worldImpact.isEmpty) return;
     impactStrategy.visitImpact(
         impactSource, worldImpact, _impactVisitor, impactUse);
@@ skipping 108 matching lines @@
       case TypeUseKind.CATCH_TYPE:
         _registerIsCheck(type);
         break;
       case TypeUseKind.CHECKED_MODE_CHECK:
         if (_options.enableTypeAssertions) {
           _registerIsCheck(type);
         }
         break;
       case TypeUseKind.TYPE_LITERAL:
         if (type.isTypedef) {
-          universe.openWorld.registerTypedef(type.element);
+          universe.registerTypedef(type.element);
         }
         break;
     }
   }
 
   void _registerIsCheck(DartType type) {
     type = _universe.registerIsCheck(type);
     // Even in checked mode, type annotations for return type and argument
     // types do not imply type checks, so there should never be a check
     // against the type variable of a typedef.
@@ skipping 65 matching lines @@
 
     assert(invariant(element, element is AnalyzableElement,
         message: 'Element $element is not analyzable.'));
     if (hasBeenProcessed(element)) return;
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(
           element, "Resolution work list is closed. Trying to add $element.");
     }
 
     applyImpact(backend.registerUsedElement(element, forResolution: true));
-    _openWorld.registerUsedElement(element);
+    _universe.registerUsedElement(element);
 
     ResolutionWorkItem workItem = _resolution.createWorkItem(element);
     _queue.add(workItem);
   }
 
   /// Adds an action to the deferred task queue.
   /// The action is performed the next time the resolution queue has been
   /// emptied.
   ///
   /// The queue is processed in FIFO order.
@@ skipping 124 matching lines @@
 }
 
 typedef void _DeferredActionFunction();
 
 class _DeferredAction {
   final Element element;
   final _DeferredActionFunction action;
 
   _DeferredAction(this.element, this.action);
 }