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

dart/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;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked;
 
   JavaScriptItemCompilationContext()
@@ skipping 63 matching lines @@
     codegen.use(node.typeRepresentation);
     arguments.add(codegen.pop());
     String asField = codegen.backend.namer.substitutionName(element);
     arguments.add(js.string(asField));
   }
 }
 
 class FunctionTypeCheckedModeHelper extends CheckedModeHelper {
   const FunctionTypeCheckedModeHelper(String name) : super(name);
 
+  jsAst.Expression generateCall(SsaCodeGenerator codegen,
+                                HTypeConversion node) {
+    codegen.use(node.inputs[0]);
+    return codegen.pop();
+//     HInstruction functionType = node.typeRepresentation;
+//     
+// 
+// 
+// 
+//     Element helperElement = getElement(codegen.compiler);
+//     codegen.world.registerStaticUse(helperElement);
+//     List<jsAst.Expression> arguments = <jsAst.Expression>[];
+//     codegen.use(node.checkedInput);
+//     arguments.add(codegen.pop());
+//     generateAdditionalArguments(codegen, node, arguments);
+//     String helperName = codegen.backend.namer.isolateAccess(helperElement);
+//     return new jsAst.Call(new jsAst.VariableUse(helperName), arguments);
+// 
+//     
+//       List arguments = [, expression];
+//       pushInvokeDynamic(
+//           node, new Selector.call('_isTest', compiler.jsHelperLibrary, 1),
+//           arguments);
+// 
+//       return new HIs.compound(type, expression, pop());
+// 
+// 
+//       generateRuntimeError(null, '<<as-test not implemented $type>>');
+
+
+
+
+  }
+
+  // DEAD CODE, delete this.
   void generateAdditionalArguments(SsaCodeGenerator codegen,
                                    HTypeConversion node,
                                    List<jsAst.Expression> arguments) {
     DartType type = node.typeExpression;
     String signatureName = codegen.backend.namer.getFunctionTypeName(type);
     arguments.add(js.string(signatureName));
 
     if (type.containsTypeVariables) {
       ClassElement contextClass = Types.getClassContext(type);
       // TODO(ahe): Creating a string here is unfortunate. It is slow (due to
@@ skipping 917 matching lines @@
       enqueueInResolution(getCheckSubtype(), elements);
       if (isTypeVariable) {
         enqueueInResolution(getCheckSubtypeOfRuntimeType(), elements);
         if (inCheckedMode) {
           enqueueInResolution(getAssertSubtypeOfRuntimeType(), elements);
         }
       }
       enqueueClass(world, compiler.listClass, elements);
     }
     if (type is FunctionType) {
-      enqueueInResolution(getCheckFunctionSubtype(), elements);
+      // enqueueInResolution(getCheckFunctionSubtype(), elements);
+      enqueueInResolution(getThrowRuntimeError(), elements);
+      enqueueInResolution(compiler.findHelper('buildFunctionType'), elements);
+      enqueueInResolution(
+          compiler.findHelper('buildNamedFunctionType'), elements);
+      enqueueInResolution(compiler.findHelper('buildInterfaceType'), elements);
+      enqueueInResolution(
+          compiler.findHelper('getDynamicRuntimeType'), elements);
+      enqueueInResolution(
+          compiler.findHelper('getVoidRuntimeType'), elements);
+      enqueueInResolution(compiler.findHelper('buildDummyType'), elements);
+      enqueueInResolution(
+          compiler.findHelper('convertRtiToRuntimeType'),elements);
+      compiler.enqueuer.resolution.registerInvocation(
+          new Selector.call('_isTest', compiler.jsHelperLibrary, 1));
+      compiler.enqueuer.resolution.registerInvocation(
+          new Selector.call('_asCheck', compiler.jsHelperLibrary, 1));
+      compiler.enqueuer.resolution.registerInvocation(
+          new Selector.call('_assertCheck', compiler.jsHelperLibrary, 1));
     }
     if (type.element.isNative()) {
       // We will neeed to add the "$is" and "$as" properties on the
       // JavaScript object prototype, so we make sure
       // [:defineProperty:] is compiled.
       enqueue(world,
               compiler.findHelper('defineProperty'),
               elements);
     }
   }
@@ skipping 494 matching lines @@
   }
 
   Element getCheckSubtypeOfRuntimeType() {
     return compiler.findHelper('checkSubtypeOfRuntimeType');
   }
 
   Element getAssertSubtypeOfRuntimeType() {
     return compiler.findHelper('assertSubtypeOfRuntimeType');
   }
 
-  Element getCheckFunctionSubtype() {
-    return compiler.findHelper('checkFunctionSubtype');
-  }
-
   Element getThrowNoSuchMethod() {
     return compiler.findHelper('throwNoSuchMethod');
   }
 
   Element getCreateRuntimeType() {
     return compiler.findHelper('createRuntimeType');
   }
 
   Element getFallThroughError() {
     return compiler.findHelper("getFallThroughError");
@@ skipping 306 matching lines @@
     copy(constant.values);
     copy(constant.protoValue);
     copy(constant);
   }
 
   void visitConstructed(ConstructedConstant constant) {
     copy(constant.fields);
     copy(constant);
   }
 }