Fix type inference for self-recursive functions

lib/compiler/implementation/compiler.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.
 
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
 final bool REPORT_EXCESS_RESOLUTION = false;
 
 /**
  * If true, trace information on pass2 optimizations.
  */
 final bool REPORT_PASS2_OPTIMIZATIONS = false;
 
 class WorkItem {
   final Element element;
   TreeElements resolutionTree;
   bool allowSpeculativeOptimization = true;
   List<HTypeGuard> guards = const <HTypeGuard>[];
 
   WorkItem(this.element, this.resolutionTree);
 
   bool isAnalyzed() => resolutionTree !== null;
 
-  String run(Compiler compiler, Enqueuer world) {
+  void run(Compiler compiler, Enqueuer world) {
     CodeBuffer codeBuffer = world.universe.generatedCode[element];
-    if (codeBuffer !== null) return codeBuffer.toString();
+    if (codeBuffer !== null) return;
     resolutionTree = compiler.analyze(this, world);
-    return compiler.codegen(this, world);
+    compiler.codegen(this, world);
   }
 }
 
 class Backend {
   final Compiler compiler;
 
   Backend(this.compiler);
 
   void enqueueAllTopLevelFunctions(LibraryElement lib, Enqueuer world) {
     lib.forEachExport((Element e) {
       if (e.isFunction()) world.addToWorkList(e);
     });
   }
 
   abstract void enqueueHelpers(Enqueuer world);
-  abstract CodeBuffer codegen(WorkItem work);
+  abstract void codegen(WorkItem work);
   abstract void processNativeClasses(Enqueuer world,
                                      Collection<LibraryElement> libraries);
   abstract void assembleProgram();
   abstract List<CompilerTask> get tasks();
 }
 
 class Compiler implements DiagnosticListener {
   final Map<String, LibraryElement> libraries;
   int nextFreeClassId = 0;
   World world;
@@ skipping 678 matching lines @@
     if (result !== null) return result;
     if (world !== enqueuer.resolution) {
       internalErrorOnElement(element,
                              'Internal error: unresolved element: $element.');
     }
     result = analyzeElement(element);
     enqueuer.resolution.resolvedElements[element] = result;
     return result;
   }
 
-  String codegen(WorkItem work, Enqueuer world) {
+  void codegen(WorkItem work, Enqueuer world) {
     if (world !== enqueuer.codegen) return null;
     if (progress.elapsedInMs() > 500) {
       // TODO(ahe): Add structured diagnostics to the compiler API and
       // use it to separate this from the --verbose option.
       if (phase == PHASE_COMPILING) {
         log('Compiled ${codegenWorld.generatedCode.length} methods.');
       } else {
         log('Recompiled ${world.recompilationCandidates.processed} methods.');
       }
       progress.reset();
     }
     if (work.element.kind.category == ElementCategory.VARIABLE) {
       constantHandler.compileWorkItem(work);
-      return null;
     } else {
       CodeBuffer codeBuffer = backend.codegen(work);

[ahe, 2012/08/14 07:57:56]

codeBuffer is never used.

[Søren Gjesse, 2012/08/14 08:26:30]

Removed.

-      codegenWorld.addGeneratedCode(work, codeBuffer);
-      return codeBuffer.toString();
     }
   }
 
   void registerInstantiatedClass(ClassElement cls) {
     enqueuer.resolution.registerInstantiatedClass(cls);
     enqueuer.codegen.registerInstantiatedClass(cls);
   }
 
   Type resolveTypeAnnotation(Element element, TypeAnnotation annotation) {
     return resolver.resolveTypeAnnotation(element, annotation);
@@ skipping 174 matching lines @@
     final endOffset = end.charOffset + end.slowCharCount;
 
     // [begin] and [end] might be the same for the same empty token. This
     // happens for instance when scanning '$$'.
     assert(endOffset >= beginOffset);
     return f(beginOffset, endOffset);
   }
 
   String toString() => 'SourceSpan($uri, $begin, $end)';
 }