Add TypeUse.

pkg/compiler/lib/src/js_backend/backend.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.
 
 part of js_backend;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 2749 matching lines @@
           break;
         case Feature.THROW_RUNTIME_ERROR:
           registerBackendImpact(transformed, impacts.throwRuntimeError);
           break;
         case Feature.TYPE_VARIABLE_BOUNDS_CHECK:
           registerBackendImpact(transformed, impacts.typeVariableBoundCheck);
           break;
       }
     }
 
-    for (InterfaceType type in worldImpact.instantiatedTypes) {
-      registerRequiredType(type);
+    bool hasAsCast = false;
+    bool hasTypeLiteral = false;
+    for (TypeUse typeUse in worldImpact.typeUses) {
+      DartType type = typeUse.type;
+      switch (typeUse.kind) {
+        case TypeUseKind.INSTANTIATION:
+          registerRequiredType(type);
+          break;
+        case TypeUseKind.IS_CHECK:
+          onIsCheck(type, transformed);
+          break;
+        case TypeUseKind.AS_CAST:
+          onIsCheck(type, transformed);
+          hasAsCast = true;
+          break;
+        case TypeUseKind.CHECKED_MODE_CHECK:
+          if (backend.compiler.enableTypeAssertions) {
+            onIsCheck(type, transformed);
+          }
+          break;
+        case TypeUseKind.CATCH_TYPE:
+          onIsCheck(type, transformed);
+          break;
+        case TypeUseKind.TYPE_LITERAL:
+          backend.customElementsAnalysis.registerTypeLiteral(type);
+          if (type.isTypedef) {
+            backend.compiler.world.allTypedefs.add(type.element);
+          }
+          if (type.isTypeVariable) {
+            ClassElement cls = type.element.enclosingClass;
+            backend.rti.registerClassUsingTypeVariableExpression(cls);
+            registerBackendImpact(transformed, impacts.typeVariableExpression);
+          }
+          hasTypeLiteral = true;
+          break;
+      }
     }
 
-    for (DartType type in worldImpact.isChecks) {
-      onIsCheck(type, transformed);
-    }
-
-    if (worldImpact.asCasts.isNotEmpty) {
-      for (DartType type in worldImpact.asCasts) {
-        onIsCheck(type, transformed);
-      }
+    if (hasAsCast) {
       registerBackendImpact(transformed, impacts.asCheck);
     }
 
-    if (backend.compiler.enableTypeAssertions) {
-      for (DartType type in worldImpact.checkedModeChecks) {
-        onIsCheck(type, transformed);
-      }
-    }
-
-    for (DartType type in worldImpact.onCatchTypes) {
-      onIsCheck(type, transformed);
+    if (hasTypeLiteral) {
+      transformed.registerTypeUse(new TypeUse.instantiation(
+          backend.compiler.coreTypes.typeType));
+      registerBackendImpact(transformed, impacts.typeLiteral);
     }
 
     for (MapLiteralUse mapLiteralUse in worldImpact.mapLiterals) {
       // TODO(johnniwinther): Use the [isEmpty] property when factory
       // constructors are registered directly.
       if (mapLiteralUse.isConstant) {
         registerBackendImpact(transformed, impacts.constantMapLiteral);
       } else {
-        transformed.registerInstantiatedType(mapLiteralUse.type);
+        transformed.registerTypeUse(
+            new TypeUse.instantiation(mapLiteralUse.type));
       }
       registerRequiredType(mapLiteralUse.type);
     }
 
     for (ListLiteralUse listLiteralUse in worldImpact.listLiterals) {
       // TODO(johnniwinther): Use the [isConstant] and [isEmpty] property when
       // factory constructors are registered directly.
-      transformed.registerInstantiatedType(listLiteralUse.type);
+      transformed.registerTypeUse(
+          new TypeUse.instantiation(listLiteralUse.type));
       registerRequiredType(listLiteralUse.type);
     }
 
-    if (worldImpact.typeLiterals.isNotEmpty) {
-      transformed.registerInstantiatedType(backend.compiler.coreTypes.typeType);
-      registerBackendImpact(transformed, impacts.typeLiteral);
-      for (DartType typeLiteral in worldImpact.typeLiterals) {
-        backend.customElementsAnalysis.registerTypeLiteral(typeLiteral);
-        if (typeLiteral.isTypedef) {
-          backend.compiler.world.allTypedefs.add(typeLiteral.element);
-        }
-        if (typeLiteral.isTypeVariable) {
-          ClassElement cls = typeLiteral.element.enclosingClass;
-          backend.rti.registerClassUsingTypeVariableExpression(cls);
-          registerBackendImpact(transformed, impacts.typeVariableExpression);
-        }
-      }
-    }
-
     if (worldImpact.constSymbolNames.isNotEmpty) {
       registerBackendImpact(transformed, impacts.constSymbol);
       for (String constSymbolName in worldImpact.constSymbolNames) {
         backend.registerConstSymbol(constSymbolName);
       }
     }
 
     if (worldImpact.closures.isNotEmpty) {
       registerBackendImpact(transformed, impacts.closure);
       for (LocalFunctionElement closure in worldImpact.closures) {
@@ skipping 12 matching lines @@
                              BackendImpact backendImpact) {
     for (Element staticUse in backendImpact.staticUses) {
       assert(staticUse != null);
       backend.registerBackendUse(staticUse);
       worldImpact.registerStaticUse(
           // TODO(johnniwinther): Store the correct use in impacts.
           new StaticUse.foreignUse(staticUse));
     }
     for (InterfaceType instantiatedType in backendImpact.instantiatedTypes) {
       backend.registerBackendUse(instantiatedType.element);
-      worldImpact.registerInstantiatedType(instantiatedType);
+      worldImpact.registerTypeUse(
+          new TypeUse.instantiation(instantiatedType));
     }
     for (ClassElement cls in backendImpact.instantiatedClasses) {
       cls.ensureResolved(backend.resolution);
       backend.registerBackendUse(cls);
-      worldImpact.registerInstantiatedType(cls.rawType);
+      worldImpact.registerTypeUse(
+          new TypeUse.instantiation(cls.rawType));
     }
     for (BackendImpact otherImpact in backendImpact.otherImpacts) {
       registerBackendImpact(worldImpact, otherImpact);
     }
   }
 
   /// Register [type] as required for the runtime type information system.
   void registerRequiredType(DartType type) {
     // If [argument] has type variables or is a type variable, this method
     // registers a RTI dependency between the class where the type variable is
@@ skipping 78 matching lines @@
       registerBackendImpact(transformed, impacts.nativeTypeCheck);
     }
   }
 
   @override
   WorldImpact transformCodegenImpact(CodegenImpact impact) {
     TransformedWorldImpact transformed = new TransformedWorldImpact(impact);
     EagerRegistry registry = impact.registry;
     Enqueuer world = registry.world;
 
-    for (InterfaceType type in impact.instantiatedTypes) {
-      backend.lookupMapAnalysis.registerInstantiatedType(type, registry);
-    }
-
-    for (DartType type in impact.isChecks) {
-      onIsCheckForCodegen(type, transformed);
+    for (TypeUse typeUse in impact.typeUses) {
+      DartType type = typeUse.type;
+      switch (typeUse.kind) {
+        case TypeUseKind.INSTANTIATION:
+          backend.lookupMapAnalysis.registerInstantiatedType(type, registry);
+          break;
+        case TypeUseKind.IS_CHECK:
+          onIsCheckForCodegen(type, transformed);
+          break;
+        default:
+      }
     }
 
     for (ConstantValue constant in impact.compileTimeConstants) {
       backend.registerCompileTimeConstant(constant, registry);
       backend.addCompileTimeConstantForEmission(constant);
     }
 
     for (Pair<DartType, DartType> check in
             impact.typeVariableBoundsSubtypeChecks) {
       backend.registerTypeVariableBoundsSubtypeCheck(check.a, check.b);
@@ skipping 41 matching lines @@
   }
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final ConstantValue constant;
   final Element annotatedElement;
 
   const Dependency(this.constant, this.annotatedElement);
 }