Remove requiredTypes

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 1421 matching lines @@
         Element element = find(isolateHelperLibrary, name);
         enqueuer.addToWorkList(element);
         compiler.globalDependencies.registerDependency(element);
         helpersUsed.add(element.declaration);
       }
     } else {
       enqueuer.addToWorkList(find(isolateHelperLibrary, START_ROOT_ISOLATE));
     }
   }
 
-  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
-    // defined (that is the enclosing class of the current element being
-    // resolved) and the class of [type]. If the class of [type] requires RTI,
-    // then the class of the type variable does too.
-    ClassElement contextClass = Types.getClassContext(type);
-    if (contextClass != null) {
-      rti.registerRtiDependency(type.element, contextClass);
-    }
-  }
-
   bool classNeedsRti(ClassElement cls) {
     return rti.classesNeedingRti.contains(cls.declaration) ||
         compiler.enabledRuntimeType;
   }
 
   bool isComplexNoSuchMethod(FunctionElement element) =>
     noSuchMethodRegistry.isComplex(element);
 
   bool isDefaultEqualityImplementation(Element element) {
     assert(element.name == '==');
@@ skipping 1438 matching lines @@
           registerBackendImpact(transformed, impacts.throwNoSuchMethod);
           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);
+    }
+
     for (DartType type in worldImpact.isChecks) {
       onIsCheck(type, transformed);
     }
 
     if (worldImpact.asCasts.isNotEmpty) {
       for (DartType type in worldImpact.asCasts) {
         onIsCheck(type, transformed);
       }
       registerBackendImpact(transformed, impacts.asCheck);
     }
 
     if (backend.compiler.enableTypeAssertions) {
       for (DartType type in worldImpact.checkedModeChecks) {
         onIsCheck(type, transformed);
       }
     }
 
-    for (DartType requiredType in worldImpact.requiredTypes) {
-      backend.registerRequiredType(requiredType);
+    for (DartType type in worldImpact.onCatchTypes) {
+      onIsCheck(type, transformed);
     }
 
     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);
       }
+      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);
+      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);
         }
       }
     }
 
-    for (String constSymbolName in worldImpact.constSymbolNames) {
-      backend.registerConstSymbol(constSymbolName);
+    if (worldImpact.constSymbolNames.isNotEmpty) {
+      registerBackendImpact(transformed, impacts.constSymbol);
+      for (String constSymbolName in worldImpact.constSymbolNames) {
+        backend.registerConstSymbol(constSymbolName);
+      }
     }
 
-    for (LocalFunctionElement closure in worldImpact.closures) {
-      if (closure.computeType(backend.resolution).containsTypeVariables) {
-        backend.compiler.enqueuer.resolution.universe
-            .closuresWithFreeTypeVariables.add(closure);
-        registerBackendImpact(transformed, impacts.computeSignature);
+    if (worldImpact.closures.isNotEmpty) {
+      registerBackendImpact(transformed, impacts.closure);
+      for (LocalFunctionElement closure in worldImpact.closures) {
+        if (closure.computeType(backend.resolution).containsTypeVariables) {
+          backend.compiler.enqueuer.resolution.universe
+              .closuresWithFreeTypeVariables.add(closure);
+          registerBackendImpact(transformed, impacts.computeSignature);
+        }
       }
     }
+
     return transformed;
   }
 
   void registerBackendImpact(TransformedWorldImpact worldImpact,
                              BackendImpact backendImpact) {
     for (Element staticUse in backendImpact.staticUses) {
       assert(staticUse != null);
       backend.registerBackendUse(staticUse);
       worldImpact.registerStaticUse(staticUse);
     }
     for (InterfaceType instantiatedType in backendImpact.instantiatedTypes) {
       backend.registerBackendUse(instantiatedType.element);
       worldImpact.registerInstantiatedType(instantiatedType);
     }
     for (ClassElement cls in backendImpact.instantiatedClasses) {
       cls.ensureResolved(backend.resolution);
       backend.registerBackendUse(cls);
       worldImpact.registerInstantiatedType(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
+    // defined (that is the enclosing class of the current element being
+    // resolved) and the class of [type]. If the class of [type] requires RTI,
+    // then the class of the type variable does too.
+    ClassElement contextClass = Types.getClassContext(type);
+    if (contextClass != null) {
+      backend.rti.registerRtiDependency(type.element, contextClass);
+    }
+  }
+
   // TODO(johnniwinther): Maybe split this into [onAssertType] and [onTestType].
   void onIsCheck(DartType type, TransformedWorldImpact transformed) {
+    registerRequiredType(type);
     type.computeUnaliased(backend.resolution);
     type = type.unaliased;
     registerBackendImpact(transformed, impacts.typeCheck);
 
     bool inCheckedMode = backend.compiler.enableTypeAssertions;
     if (inCheckedMode) {
       registerBackendImpact(transformed, impacts.checkedModeTypeCheck);
     }
     if (type.isMalformed) {
       registerBackendImpact(transformed, impacts.malformedTypeCheck);
@@ skipping 21 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);
 }