Reduce use of elements/resolution_types in enqueuer.

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 'compiler.dart' show Compiler;
 import 'options.dart';
 import 'elements/elements.dart'
-    show
-        AnalyzableElement,
-        ClassElement,
-        ConstructorElement,
-        Element,
-        MemberElement;
+    show AnalyzableElement, ClassElement, MemberElement;
 import 'elements/entities.dart';
-import 'elements/resolution_types.dart'
-    show ResolutionDartType, ResolutionInterfaceType;
-import 'elements/types.dart' show InterfaceType;
+import 'elements/resolution_types.dart' show ResolutionTypedefType;
+import 'elements/types.dart';
 import 'native/native.dart' as native;
 import 'universe/world_builder.dart';
 import 'universe/use.dart'
     show DynamicUse, StaticUse, StaticUseKind, TypeUse, TypeUseKind;
 import 'universe/world_impact.dart'
     show ImpactStrategy, ImpactUseCase, WorldImpact, WorldImpactVisitor;
 import 'util/enumset.dart';
 import 'util/util.dart' show Setlet;
 
 class EnqueueTask extends CompilerTask {
@@ skipping 190 matching lines @@
   }
 
   Iterable<ClassEntity> get processedClasses => _worldBuilder.processedClasses;
 
   void applyImpact(WorldImpact worldImpact, {var impactSource}) {
     if (worldImpact.isEmpty) return;
     impactStrategy.visitImpact(
         impactSource, worldImpact, _impactVisitor, impactUse);
   }
 
-  void _registerInstantiatedType(ResolutionInterfaceType type,
-      {ConstructorElement constructor,
+  void _registerInstantiatedType(InterfaceType type,
+      {ConstructorEntity constructor,
       bool mirrorUsage: false,
       bool nativeUsage: false,
       bool globalDependency: false,
       bool isRedirection: false}) {
     task.measure(() {
       _worldBuilder.registerTypeInstantiation(type, _applyClassUse,
           constructor: constructor,
           byMirrors: mirrorUsage,
           isRedirection: isRedirection);
       if (nativeUsage) {
@@ skipping 67 matching lines @@
             constructor: staticUse.element,
             globalDependency: false,
             isRedirection: true);
         break;
       default:
         break;
     }
   }
 
   void processTypeUse(TypeUse typeUse) {
-    ResolutionDartType type = typeUse.type;
+    DartType type = typeUse.type;
     switch (typeUse.kind) {
       case TypeUseKind.INSTANTIATION:
         _registerInstantiatedType(type, globalDependency: false);
         break;
       case TypeUseKind.MIRROR_INSTANTIATION:
         _registerInstantiatedType(type,
             mirrorUsage: true, globalDependency: false);
         break;
       case TypeUseKind.NATIVE_INSTANTIATION:
         _registerInstantiatedType(type,
             nativeUsage: true, globalDependency: true);
         break;
       case TypeUseKind.IS_CHECK:
       case TypeUseKind.AS_CAST:
       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) {
-          worldBuilder.registerTypedef(type.element);
+          ResolutionTypedefType typedef = type;
+          worldBuilder.registerTypedef(typedef.element);
         }
         break;
     }
   }
 
-  void _registerIsCheck(ResolutionDartType type) {
-    type = _worldBuilder.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.
-    assert(!type.isTypeVariable || !type.element.enclosingElement.isTypedef);
+  void _registerIsCheck(DartType type) {
+    _worldBuilder.registerIsCheck(type);
   }
 
-  void _registerClosurizedMember(MemberElement element) {
+  void _registerClosurizedMember(MemberEntity element) {
     assert(element.isInstanceMember);
     applyImpact(listener.registerClosurizedMember(element));
     _worldBuilder.registerClosurizedMember(element);
   }
 
   void forEach(void f(WorkItem work)) {
     do {
       while (_queue.isNotEmpty) {
         // TODO(johnniwinther): Find an optimal process order.
         WorkItem work = _queue.removeLast();
@@ skipping 17 matching lines @@
 
   String toString() => 'Enqueuer($name)';
 
   Iterable<Entity> get processedEntities => _processedEntities;
 
   ImpactUseCase get impactUse => IMPACT_USE;
 
   bool get isResolutionQueue => true;
 
   /// Returns `true` if [element] has been processed by the resolution enqueuer.
-  // TODO(johnniwinther): Move this to the [OpenWorld]/[ResolutionWorldBuilder].
+  // TODO(johnniwinther): Remove this together with the resolver.
   bool hasBeenProcessed(MemberElement element) {
     assert(invariant(element, element == element.analyzableElement.declaration,
         message: "Unexpected element $element"));
     return _processedEntities.contains(element);
   }
 
   /// Registers [entity] as processed by the resolution enqueuer. Used only for
   /// testing.
   void registerProcessedElementInternal(Entity entity) {
     _processedEntities.add(entity);
   }
 
   /// Create a [WorkItem] for [entity] and add it to the work list if it has not
   /// already been processed.
   void _addToWorkList(MemberEntity entity) {
-    if (hasBeenProcessed(entity)) return;
+    if (_processedEntities.contains(entity)) return;
     WorkItem workItem = _workItemBuilder.createWorkItem(entity);
     if (workItem == null) return;
 
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(
           entity, "Resolution work list is closed. Trying to add $entity.");
     }
 
     applyImpact(listener.registerUsedElement(entity));
     _worldBuilder.registerUsedElement(entity);
@@ skipping 122 matching lines @@
 
   @override
   void visitTypeUse(TypeUse typeUse) {
     enqueuer.strategy.processTypeUse(enqueuer, typeUse);
   }
 }
 
 typedef void _DeferredActionFunction();
 
 class _DeferredAction {
-  final Element element;
+  final Entity element;
   final _DeferredActionFunction action;
 
   _DeferredAction(this.element, this.action);
 }
 
 /// Interface for creating work items for enqueued member entities.
 abstract class WorkItemBuilder {
   WorkItem createWorkItem(MemberEntity entity);
 }
 
 /// Builder that creates work item necessary for the resolution of a
 /// [MemberElement].
 class ResolutionWorkItemBuilder extends WorkItemBuilder {
   final Resolution _resolution;
 
   ResolutionWorkItemBuilder(this._resolution);
 
   @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);
   }
 }