Start inferring return types for static 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 = -1;
   List<HType> providedTypes;
   List<Element> compiledFunctions;
 
   InvocationInfo(HInvoke node, HTypeMap types)
@@ skipping 48 matching lines @@
   }
 
   addCompiledFunction(FunctionElement function) =>
       compiledFunctions.add(function);
 
   void clearTypeInformation() => providedTypes = null;
   bool get hasTypeInformation() => providedTypes != null;
 
 }
 
+class ReturnInfo {
+  HType returnType;
+  List<Element> compiledFunctions;
+
+  ReturnInfo(HType this.returnType)
+      : compiledFunctions = new List<Element>();
+
+  ReturnInfo.unknownType()
+      : this.returnType = null,
+        compiledFunctions = new List<Element>();
+
+  void update(HType type, var recompile) {
+    HType newType = returnType != null ? returnType.union(type) : type;
+    if (newType != returnType) {
+      if (returnType == null && newType === HType.UNKNOWN) {
+        // If the first actual piece of information is not providing any type
+        // information there is no need to recompile callers.
+        compiledFunctions.clear();
+      }
+      returnType = newType;
+      if (recompile != null) {
+        compiledFunctions.forEach(recompile);
+      }
+      compiledFunctions.clear();
+    }
+  }
+
+  addCompiledFunction(FunctionElement function) =>
+      compiledFunctions.add(function);
+}
+
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final HTypeMap types;
 
   JavaScriptItemCompilationContext() : types = new HTypeMap();
 }
 
 class JavaScriptBackend extends Backend {
   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<Element, InvocationInfo> staticInvocationInfo;
   final Map<SourceString, Map<Selector, InvocationInfo>> invocationInfo;
+  final Map<Element, ReturnInfo> returnInfo;
 
   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>>(),
         staticInvocationInfo = new Map<Element, InvocationInfo>(),
+        returnInfo = new Map<Element, ReturnInfo>(),
         invalidateAfterCodegen = new List<Element>(),
         super(compiler) {
     builder = new SsaBuilderTask(this);
     optimizer = new SsaOptimizerTask(this);
     generator = new SsaCodeGeneratorTask(this);
   }
 
   JavaScriptItemCompilationContext createItemCompilationContext() {
     return new JavaScriptItemCompilationContext();
   }
@@ skipping 235 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;
     }
   }
+
+  void registerReturnType(FunctionElement element, HType returnType) {
+    ReturnInfo info = returnInfo[element];
+    if (info != null) {
+      recompile(Element element) {
+        if (compiler.phase == Compiler.PHASE_COMPILING) {
+          invalidateAfterCodegen.add(element);
+        }
+      }
+
+      info.update(returnType, recompile);
+    } else {
+      returnInfo[element] = new ReturnInfo(returnType);
+    }
+  }
+
+  /**
+   * Retreive the return type of the function [calee]. The type is optimistic

[ngeoffray, 2012/08/17 10:02:51]

why not callee?

[Søren Gjesse, 2012/08/17 10:08:54]

Because I cannot spell - fixed.

[kasperl, 2012/08/17 10:11:07]

i before e except after c (Retrieve).

[Søren Gjesse, 2012/08/17 10:21:04]

Done.

+   * in the sense that is is based on the compilation og [calee]. If [calee] is

[ngeoffray, 2012/08/17 10:02:51]

og -> of

[Søren Gjesse, 2012/08/17 10:08:54]

Done.

+   * recompiled the return type might change to someting broader. For that
+   * reason [calller] is registered for recompilation if this happens. If the

[ngeoffray, 2012/08/17 10:02:51]

calller -> caller

[Søren Gjesse, 2012/08/17 10:08:54]

Done.

+   * function [calee] has not yet been compiled the returned type is [null].
+   */
+  HType optimisticReturnTypesWithRecompilationOnTypeChange(
+      FunctionElement caller, FunctionElement calee) {
+    returnInfo.putIfAbsent(calee, () => new ReturnInfo.unknownType());

[ngeoffray, 2012/08/17 10:02:51]

Why do you need to put a return info? Could you just return null if there is no
return info?

[Søren Gjesse, 2012/08/17 10:08:54]

The ReturnInfo with returnType null indicates that there are callers but the
callee has not been compiled yet. When the callee is compiled the callers will
be re-compiled - unless the return type of the callee turns out to be
HType.UNKNOWN.

+    ReturnInfo info = returnInfo[calee];
+    if (info.returnType != HType.UNKNOWN && caller != null) {
+      info.addCompiledFunction(caller);
+    }
+    return info.returnType;
+  }
 }