Fix type inference for self-recursive functions

lib/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.
 
 class InvocationInfo {
   int parameterCount;
   List<HType> providedTypes;
   List<Element> compiledFunctions;
 
   InvocationInfo(List<HType> types)
@@ skipping 13 matching lines @@
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
   SsaCodeGeneratorTask generator;
   CodeEmitterTask emitter;
   final Map<Element, Map<Element, HType>> fieldInitializers;
   final Map<Element, Map<Element, HType>> fieldConstructorSetters;
   final Map<Element, Map<Element, HType>> fieldSettersType;
 
   final Map<SourceString, Map<Selector, InvocationInfo>> invocationInfo;
 
+  final List<Element> invalidateAfterCodegen;
+
   List<CompilerTask> get tasks() {
     return <CompilerTask>[builder, optimizer, generator, emitter];
   }
 
   JavaScriptBackend(Compiler compiler, bool generateSourceMap)
       : emitter = new CodeEmitterTask(compiler, generateSourceMap),
         fieldInitializers = new Map<Element, Map<Element, HType>>(),
         fieldConstructorSetters = new Map<Element, Map<Element, HType>>(),
         fieldSettersType = new Map<Element, Map<Element, HType>>(),
         invocationInfo = new Map<SourceString, Map<Selector, InvocationInfo>>(),
+        invalidateAfterCodegen = new List<Element>(),
         super(compiler) {
     builder = new SsaBuilderTask(this);
     optimizer = new SsaOptimizerTask(this);
     generator = new SsaCodeGeneratorTask(this);
   }
 
   void enqueueHelpers(Enqueuer world) {
     enqueueAllTopLevelFunctions(compiler.jsHelperLibrary, world);
     enqueueAllTopLevelFunctions(compiler.interceptorsLibrary, world);
     for (var helper in [const SourceString('Closure'),
                         const SourceString('ConstantMap'),
                         const SourceString('ConstantProtoMap')]) {
       var e = compiler.findHelper(helper);
       if (e !== null) world.registerInstantiatedClass(e);
     }
   }
 
-  CodeBuffer codegen(WorkItem work) {
+  void codegen(WorkItem work) {
     HGraph graph = builder.build(work);
     optimizer.optimize(work, graph);
     if (work.allowSpeculativeOptimization
         && optimizer.trySpeculativeOptimizations(work, graph)) {
       CodeBuffer codeBuffer = generator.generateBailoutMethod(work, graph);
       compiler.codegenWorld.addBailoutCode(work, codeBuffer);
       optimizer.prepareForSpeculativeOptimizations(work, graph);
       optimizer.optimize(work, graph);
     }
-    return generator.generateMethod(work, graph);
+    CodeBuffer codeBuffer = generator.generateMethod(work, graph);
+    compiler.codegenWorld.addGeneratedCode(work, codeBuffer);
+    invalidateAfterCodegen.forEach((Element element) {
+      compiler.codegenWorld.invalidateCode(element);
+      compiler.enqueuer.codegen.eagerRecompile(element);
+    });
+    invalidateAfterCodegen.clear();
   }
 
   void processNativeClasses(Enqueuer world,
                             Collection<LibraryElement> libraries) {
     native.processNativeClasses(world, emitter, libraries);
   }
 
   void assembleProgram() {
     emitter.assembleProgram();
   }
@@ skipping 120 matching lines @@
         if (newType != types[i]) {
           typesChanged = true;
           types[i] = newType;
         }
         if (types[i] != HType.UNKNOWN) allUnknown = false;
       }
       // If the provided types change we need to recompile all functions which
       // have been compiled under the now invalidated assumptions.
       if (typesChanged && info.compiledFunctions.length != 0) {
         if (compiler.phase == Compiler.PHASE_COMPILING) {
-          info.compiledFunctions.forEach(
-              compiler.enqueuer.codegen.eagerRecompile);
+          info.compiledFunctions.forEach(invalidateAfterCodegen.add);
           info.compiledFunctions.clear();
         }
       }
       // If all information is lost no need to keep it around.
       if (allUnknown) info.clearTypeInformation();
     } else {
       // Gather the type information provided. If the types contains no useful
       // information there is no need to actually store them.
       bool allUnknown = true;
       for (int i = 1; i < node.inputs.length; i++) {
@@ skipping 40 matching lines @@
     if (foundCount == 1 && found.hasTypeInformation) {
       FunctionSignature signature = element.computeSignature(compiler);
       if (signature.parameterCount == found.parameterCount) {
         found.addCompiledFunction(element);
         return found.providedTypes;
       }
     }
     return null;
   }
 }