Implement subtype relation for kernel based elements.

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;
@@ skipping 260 matching lines @@
 
   /// Callback for applying the use of a [member].
   void _applyMemberUse(Entity member, EnumSet<MemberUse> useSet) {
     if (useSet.contains(MemberUse.NORMAL)) {
       _addToWorkList(member);
     }
     if (useSet.contains(MemberUse.CLOSURIZE_INSTANCE)) {
       _registerClosurizedMember(member);
     }
     if (useSet.contains(MemberUse.CLOSURIZE_STATIC)) {
-      applyImpact(listener.registerGetOfStaticFunction());
+      applyImpact(listener.registerGetOfStaticFunction(),
+          impactSource: 'get of static function');
     }
   }
 
   /// Callback for applying the use of a [cls].
   void _applyClassUse(ClassEntity cls, EnumSet<ClassUse> useSet) {
     if (useSet.contains(ClassUse.INSTANTIATED)) {
       _recentClasses.add(cls);
       _worldBuilder.processClassMembers(cls, _applyMemberUse);
       // We only tell the backend once that [cls] was instantiated, so
       // any additional dependencies must be treated as global
       // dependencies.
-      applyImpact(listener.registerInstantiatedClass(cls));
+      applyImpact(listener.registerInstantiatedClass(cls),
+          impactSource: 'instantiated class');
     }
     if (useSet.contains(ClassUse.IMPLEMENTED)) {
-      applyImpact(listener.registerImplementedClass(cls));
+      applyImpact(listener.registerImplementedClass(cls),
+          impactSource: 'implemented class');
     }
   }
 
   void processDynamicUse(DynamicUse dynamicUse) {
     task.measure(() {
       _worldBuilder.registerDynamicUse(dynamicUse, _applyMemberUse);
     });
   }
 
   void processConstantUse(ConstantUse constantUse) {
     task.measure(() {
       if (_worldBuilder.registerConstantUse(constantUse)) {
-        applyImpact(listener.registerUsedConstant(constantUse.value));
+        applyImpact(listener.registerUsedConstant(constantUse.value),
+            impactSource: 'constant use');
         _recentConstants = true;
       }
     });
   }
 
   void processStaticUse(StaticUse staticUse) {
     _worldBuilder.registerStaticUse(staticUse, _applyMemberUse);
     // TODO(johnniwinther): Add `ResolutionWorldBuilder.registerConstructorUse`
     // for these:
     switch (staticUse.kind) {
@@ skipping 45 matching lines @@
         break;
     }
   }
 
   void _registerIsCheck(DartType type) {
     _worldBuilder.registerIsCheck(type);
   }
 
   void _registerClosurizedMember(MemberEntity element) {
     assert(element.isInstanceMember);
-    applyImpact(listener.registerClosurizedMember(element));
+    applyImpact(listener.registerClosurizedMember(element),
+        impactSource: 'closurized member');
     _worldBuilder.registerClosurizedMember(element);
   }
 
   void forEach(void f(WorkItem work)) {
     do {
       while (_queue.isNotEmpty) {
         // TODO(johnniwinther): Find an optimal process order.
         WorkItem work = _queue.removeLast();
         if (!_processedEntities.contains(work.element)) {
           strategy.processWorkItem(f, work);
@@ skipping 44 matching lines @@
   void _addToWorkList(MemberEntity entity) {
     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));
+    applyImpact(listener.registerUsedElement(entity),
+        impactSource: 'used element');
     _worldBuilder.registerUsedElement(entity);
     _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.
   void addDeferredAction(DeferredAction deferredAction) {
@@ skipping 158 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);
   }
 }