Emit declarations for typedefs that are needed by reflection.

sdk/lib/_internal/compiler/implementation/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 308 matching lines @@
     assert(_membersNeededForReflection != null);
     return _membersNeededForReflection;
   }
 
   /// List of symbols that the user has requested for reflection.
   final Set<String> symbolsUsed = new Set<String>();
 
   /// List of elements that the backend may use.
   final Set<Element> helpersUsed = new Set<Element>();
 
-  /// Set of typedefs that are used as type literals.
-  final Set<TypedefElement> typedefTypeLiterals = new Set<TypedefElement>();
-
   /// All the checked mode helpers.
   static const checkedModeHelpers = CheckedModeHelper.helpers;
 
   // Checked mode helpers indexed by name.
   Map<String, CheckedModeHelper> checkedModeHelperByName =
       new Map<String, CheckedModeHelper>.fromIterable(
           checkedModeHelpers,
           key: (helper) => helper.name);
 
   TypeVariableHandler typeVariableHandler;
@@ skipping 1563 matching lines @@
           reflectableMembers.add(closure);
           foundClosure = true;
         }
       }
     }
     // As we do not think about closures as classes, yet, we have to make sure
     // their superclasses are available for reflection manually.
     if (foundClosure) {
       reflectableMembers.add(closureClass);
     }
-    // It would be nice to have a better means to select
     Set<Element> closurizedMembers = compiler.resolverWorld.closurizedMembers;
     if (closurizedMembers.any(reflectableMembers.contains)) {
       reflectableMembers.add(boundClosureClass);
     }
+    // Add typedefs.
+    reflectableMembers
+        .addAll(compiler.world.allTypedefs.where(referencedFromMirrorSystem));
     // Register all symbols of reflectable elements
     for (Element element in reflectableMembers) {
       symbolsUsed.add(element.name);
     }
     _membersNeededForReflection = reflectableMembers;
   }
 
   jsAst.Call generateIsJsIndexableCall(jsAst.Expression use1,
                                        jsAst.Expression use2) {
     String dispatchPropertyName = 'init.dispatchPropertyName';
@@ skipping 200 matching lines @@
   }
 
   void onTypeLiteral(DartType type, Registry registry) {
     assert(registry.isForResolution);
     registerBackendInstantiation(backend.typeImplementation, registry);
     registerBackendStaticInvocation(backend.getCreateRuntimeType(), registry);
     // TODO(ahe): Might want to register [element] as an instantiated class
     // when reflection is used.  However, as long as we disable tree-shaking
     // eagerly it doesn't matter.
     if (type.isTypedef) {
-      backend.typedefTypeLiterals.add(type.element);
+      backend.compiler.world.allTypedefs.add(type.element);
     }
     backend.customElementsAnalysis.registerTypeLiteral(type, registry);
   }
 
   void onStackTraceInCatch(Registry registry) {
     assert(registry.isForResolution);
     registerBackendStaticInvocation(backend.getTraceFromException(), registry);
   }
 
 
@@ skipping 126 matching lines @@
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final Constant constant;
   // TODO(johnniwinther): Change to [Element] when dependency nodes are added.
   final Registry registry;
 
   const Dependency(this.constant, this.registry);
 }