Repro for OOM bug in test.dart (applies to r29345).

dart/sdk/lib/_internal/compiler/implementation/js_emitter/class_emitter.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 dart2js.js_emitter;
 
 class ClassEmitter extends CodeEmitterHelper {
   /**
    * Documentation wanted -- johnniwinther
    *
@@ skipping 24 matching lines @@
     }
 
     ClassBuilder builder = new ClassBuilder();
     emitClassConstructor(classElement, builder, runtimeName,
                          onlyForRti: onlyForRti);
     emitFields(classElement, builder, superName, onlyForRti: onlyForRti);
     emitClassGettersSetters(classElement, builder, onlyForRti: onlyForRti);
     emitInstanceMembers(classElement, builder, onlyForRti: onlyForRti);
     task.typeTestEmitter.emitIsTests(classElement, builder);
 
+    emitTypeVariableReaders(classElement, builder);
+
     emitClassBuilderWithReflectionData(
         className, classElement, builder, buffer);
   }
 
   void emitClassConstructor(ClassElement classElement,
                             ClassBuilder builder,
                             String runtimeName,
                             {bool onlyForRti: false}) {
     List<String> fields = <String>[];
     if (!onlyForRti && !classElement.isNative()) {
@@ skipping 539 matching lines @@
     Selector selector = isGetter
         ? new Selector.getter(member.name, member.getLibrary())
         : new Selector.setter(member.name, member.getLibrary());
     String reflectionName = task.getReflectionName(selector, name);
     if (reflectionName != null) {
       var reflectable =
           js(backend.isAccessibleByReflection(member) ? '1' : '0');
       builder.addProperty('+$reflectionName', reflectable);
     }
   }
+
+  void emitTypeVariableReaders(ClassElement cls, ClassBuilder builder) {
+    List typeVariables = [];
+    ClassElement superclass = cls;
+    while (superclass != null) {
+      GenericType type = superclass.thisType;
+      for (TypeVariableType parameter in type.typeArguments) {
+        if (task.readTypeVariables.contains(parameter.element)) {
+          emitTypeVariableReader(cls, builder, parameter.element);
+        }
+      }
+      superclass = superclass.superclass;
+    }
+  }
+
+  void emitTypeVariableReader(ClassElement cls,
+                              ClassBuilder builder,
+                              TypeVariableElement element) {
+    String name = namer.readTypeVariableName(element);
+    jsAst.Expression index =
+        js.toExpression(RuntimeTypes.getTypeVariableIndex(element));
+    jsAst.Expression computeTypeVariable;
+
+    if (!backend.rti.isTrivialSubstitution(cls, element.enclosingElement)) {
+      Substitution substitution =
+          backend.rti.computeSubstitution(
+              cls, element.enclosingElement, alwaysGenerateFunction: true);
+      jsAst.Expression typeArguments =
+          substitution.getCode(backend.rti, true)['apply'](
+              ['null', r'this.$builtinTypeInfo']);
+      computeTypeVariable = typeArguments[index];
+    } else {
+      computeTypeVariable =
+          js(r'this.$builtinTypeInfo && this.$builtinTypeInfo[#]', index);
+    }
+    jsAst.Expression convertRtiToRuntimeType =
+        namer.elementAccess(compiler.findHelper('convertRtiToRuntimeType'));
+    builder.addProperty(
+        name, js.fun(
+            [], [js.return_(convertRtiToRuntimeType(computeTypeVariable))]));
+  }
 }