dart2js: Capture typedef arguments once

pkg/compiler/lib/src/js_backend/runtime_types.dart

 // Copyright (c) 2013, 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.backend;
 
 /// For each class, stores the possible class subtype tests that could succeed.
 abstract class TypeChecks {
   /// Get the set of checks required for class [element].
   Iterable<TypeCheck> operator [](ClassElement element);
@@ skipping 860 matching lines @@
     return '$name<$arguments>';
   }
 }
 
 class TypeRepresentationGenerator implements DartTypeVisitor {
   final Namer namer;
   final CodeEmitterTask emitter;
   OnVariableCallback onVariable;
   ShouldEncodeTypedefCallback shouldEncodeTypedef;
 
+  Map<ResolutionTypeVariableType, jsAst.Expression> typedefBindings;
+
   TypeRepresentationGenerator(this.namer, this.emitter);
 
   /**
    * Creates a type representation for [type]. [onVariable] is called to provide
    * the type representation for type variables.
    */
   jsAst.Expression getTypeRepresentation(
       ResolutionDartType type,
       OnVariableCallback onVariable,
       ShouldEncodeTypedefCallback encodeTypedef) {
+    assert(typedefBindings == null);
     this.onVariable = onVariable;
     this.shouldEncodeTypedef = (encodeTypedef != null)
         ? encodeTypedef
         : (ResolutionTypedefType type) => false;
     jsAst.Expression representation = visit(type);
     this.onVariable = null;
     this.shouldEncodeTypedef = null;
     return representation;
   }
 
   jsAst.Expression getJavaScriptClassName(Element element) {
     return emitter.typeAccess(element);
   }
 
   @override
   visit(ResolutionDartType type, [_]) => type.accept(this, null);
 
   visitTypeVariableType(ResolutionTypeVariableType type, _) {
+    if (typedefBindings != null) {
+      assert(typedefBindings[type] != null);
+      return typedefBindings[type];
+    }
     return onVariable(type);
   }
 
   visitDynamicType(ResolutionDynamicType type, _) {
     return js('null');
   }
 
   visitInterfaceType(ResolutionInterfaceType type, _) {
     jsAst.Expression name = getJavaScriptClassName(type.element);
     return type.treatAsRaw ? name : visitList(type.typeArguments, head: name);
@@ skipping 75 matching lines @@
   }
 
   visitVoidType(ResolutionVoidType type, _) {
     // TODO(ahe): Reify void type ("null" means "dynamic").
     return js('null');
   }
 
   visitTypedefType(ResolutionTypedefType type, _) {
     bool shouldEncode = shouldEncodeTypedef(type);
     ResolutionDartType unaliasedType = type.unaliased;
+
+    var oldBindings = typedefBindings;
+    if (typedefBindings == null) {
+      // First level typedef - capture arguments for re-use within typedef body.
+      //
+      // The type `Map<T, Foo<Set<T>>>` contains one type variable referenced
+      // twice, so there are two inputs into the HTypeInfoExpression
+      // instruction.
+      //
+      // If Foo is a typedef, T can be reused, e.g.
+      //
+      //     typedef E Foo<E>(E a, E b);
+      //
+      // As the typedef is expanded (to (Set<T>, Set<T>) => Set<T>) it should
+      // not consume additional types from the to-level input.  We prevent this
+      // by capturing the types and using the captured type expressions inside
+      // the typedef expansion.
+      //
+      // TODO(sra): We should make the type subexpression Foo<...> be a second
+      // HTypeInfoExpression, with Set<T> as its input (a third
+      // HTypeInfoExpression). This would share all the Set<T> subexpressions
+      // instead of duplicating them. This would require HTypeInfoExpression
+      // inputs to correspond to type variables AND typedefs.
+      typedefBindings = <ResolutionTypeVariableType, jsAst.Expression>{};
+      type.forEachTypeVariable((variable) {
+        if (variable is! MethodTypeVariableType) {
+          typedefBindings[variable] = onVariable(variable);
+        }
+      });
+    }
+
+    jsAst.Expression finish(jsAst.Expression result) {
+      typedefBindings = oldBindings;
+      return result;
+    }
+
     if (shouldEncode) {
       jsAst.ObjectInitializer initializer = unaliasedType.accept(this, null);
       // We have to encode the aliased type.
       jsAst.Expression name = getJavaScriptClassName(type.element);
       jsAst.Expression encodedTypedef =
           type.treatAsRaw ? name : visitList(type.typeArguments, head: name);
 
       // Add it to the function-type object.
       jsAst.LiteralString tag = js.string(namer.typedefTag);
       initializer.properties.add(new jsAst.Property(tag, encodedTypedef));
-      return initializer;
+      return finish(initializer);
     } else {
-      return unaliasedType.accept(this, null);
+      return finish(unaliasedType.accept(this, null));
     }
   }
 }
 
 class TypeCheckMapping implements TypeChecks {
   final Map<ClassElement, Set<TypeCheck>> map =
       new Map<ClassElement, Set<TypeCheck>>();
 
   Iterable<TypeCheck> operator [](ClassElement element) {
     Set<TypeCheck> result = map[element];
@@ skipping 107 matching lines @@
  * substition for this check.
  */
 class TypeCheck {
   final ClassElement cls;
   final Substitution substitution;
   final int hashCode = _nextHash = (_nextHash + 100003).toUnsigned(30);
   static int _nextHash = 0;
 
   TypeCheck(this.cls, this.substitution);
 }