Handle typedefs in registerRequiredType.

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 988 matching lines @@
 
   void registerSuperNoSuchMethod(TreeElements elements) {
     enqueueInResolution(getCreateInvocationMirror(), elements);
     enqueueInResolution(
         compiler.objectClass.lookupLocalMember(Compiler.NO_SUCH_METHOD),
         elements);
     enqueueClass(compiler.enqueuer.resolution, compiler.listClass, elements);
   }
 
   void registerRequiredType(DartType type, Element enclosingElement) {
-    /**
-     * 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 [annotation].
-     * If the class of [annotation] requires RTI, then the class of
-     * the type variable does too.
-     */
-    void analyzeTypeArgument(DartType annotation, DartType argument) {
-      if (argument == null) return;
-      if (argument.element.isTypeVariable()) {
-        ClassElement enclosing = argument.element.getEnclosingClass();
-        assert(enclosing == enclosingElement.getEnclosingClass().declaration);
-        rti.registerRtiDependency(annotation.element, enclosing);
-      } else if (argument is InterfaceType) {
-        InterfaceType type = argument;
-        type.typeArguments.forEach((DartType argument) {
-          analyzeTypeArgument(annotation, argument);
-        });
-      }
-    }
-
-    if (type is InterfaceType) {
-      InterfaceType itf = type;
-      itf.typeArguments.forEach((DartType argument) {
-        analyzeTypeArgument(type, argument);
-      });
+    // 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) {
+      assert(contextClass == enclosingElement.getEnclosingClass().declaration);
+      rti.registerRtiDependency(type.element, contextClass);
     }
   }
 
   void registerClassUsingVariableExpression(ClassElement cls) {
     rti.classesUsingTypeVariableExpression.add(cls);
   }
 
   bool classNeedsRti(ClassElement cls) {
     return rti.classesNeedingRti.contains(cls.declaration) ||
         compiler.enabledRuntimeType;
@@ skipping 816 matching lines @@
     copy(constant.values);
     copy(constant.protoValue);
     copy(constant);
   }
 
   void visitConstructed(ConstructedConstant constant) {
     copy(constant.fields);
     copy(constant);
   }
 }