Add TypeUse.

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.dart';
@@ skipping 36 matching lines @@
 import 'js/js.dart' as js;
 import 'native/native.dart' as native;
 import 'types/types.dart' show
     TypeMaskStrategy;
 import 'universe/selector.dart' show
     Selector;
 import 'universe/universe.dart';
 import 'universe/use.dart' show
     DynamicUse,
     StaticUse,
-    StaticUseKind;
+    StaticUseKind,
+    TypeUse,
+    TypeUseKind;
 import 'universe/world_impact.dart' show
     WorldImpact;
 import 'util/util.dart' show
     Link,
     Setlet;
 
 typedef ItemCompilationContext ItemCompilationContextCreator();
 
 class EnqueueTask extends CompilerTask {
   final ResolutionEnqueuer resolution;
@@ skipping 92 matching lines @@
    *
    * Returns [true] if the element was actually added to the queue.
    */
   bool internalAddToWorkList(Element element);
 
   /// Apply the [worldImpact] of processing [element] to this enqueuer.
   void applyImpact(Element element, WorldImpact worldImpact) {
     // TODO(johnniwinther): Optimize the application of the world impact.
     worldImpact.dynamicUses.forEach(registerDynamicUse);
     worldImpact.staticUses.forEach(registerStaticUse);
-    worldImpact.instantiatedTypes.forEach(registerInstantiatedType);
-    worldImpact.isChecks.forEach(registerIsCheck);
-    worldImpact.asCasts.forEach(registerIsCheck);
-    if (compiler.enableTypeAssertions) {
-      worldImpact.checkedModeChecks.forEach(registerIsCheck);
-    }
-    worldImpact.onCatchTypes.forEach(registerIsCheck);
+    worldImpact.typeUses.forEach(registerTypeUse);
     worldImpact.closures.forEach(registerClosure);
   }
 
   void registerInstantiatedType(InterfaceType type,
                                 {bool mirrorUsage: false}) {
     task.measure(() {
       ClassElement cls = type.element;
       cls.ensureResolved(resolution);
       universe.registerTypeInstantiation(
           type,
@@ skipping 446 matching lines @@
         break;
       case StaticUseKind.SUPER_TEAR_OFF:
       case StaticUseKind.GENERAL:
         break;
     }
     if (addElement) {
       addToWorkList(element);
     }
   }
 
-  void registerIsCheck(DartType type) {
+  void registerTypeUse(TypeUse typeUse) {
+    DartType type = typeUse.type;
+    switch (typeUse.kind) {
+      case TypeUseKind.INSTANTIATION:
+        registerInstantiatedType(type);
+        break;
+      case TypeUseKind.INSTANTIATION:
+      case TypeUseKind.IS_CHECK:
+      case TypeUseKind.AS_CAST:
+      case TypeUseKind.CATCH_TYPE:
+        _registerIsCheck(type);
+        break;
+      case TypeUseKind.CHECKED_MODE_CHECK:
+        if (compiler.enableTypeAssertions) {
+          _registerIsCheck(type);
+        }
+        break;
+      case TypeUseKind.TYPE_LITERAL:
+        break;
+    }
+  }
+
+  void _registerIsCheck(DartType type) {
     type = universe.registerIsCheck(type, compiler);
     // 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 registerCallMethodWithFreeTypeVariables(Element element) {
     compiler.backend.registerCallMethodWithFreeTypeVariables(
@@ skipping 358 matching lines @@
   @override
   void processStaticUse(Enqueuer enqueuer, StaticUse staticUse) {
     enqueuer.registerStaticUseInternal(staticUse);
   }
 
   @override
   void processDynamicUse(Enqueuer enqueuer, DynamicUse dynamicUse) {
     enqueuer.handleUnseenSelectorInternal(dynamicUse);
   }
 }