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 150 matching lines @@
       CacheStrategy cacheStrategy,
       [this.name = 'resolution enqueuer'])
       : 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;

[Siggi Cherem (dart-lang), 2016/12/20 15:42:33]

let's add a TODO: rename `universe` to `worldBuilder` ?

When doing so, consider getting rid of the getter too (since the underlying
_universe is final, we could use the public name for the field instead)

[Johnni Winther, 2016/12/21 08:52:28]

Added a TODO to [Enqueuer.universe].

_universe has type ResolutionWorldBuilderImpl and I want to have two levels of
visibility. For now it is a misuse of implementation details but the
internal/external interfaces will be cleaned up.

 
-  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);
 }