Start inferring return types for static functions

lib/compiler/implementation/ssa/codegen.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 SsaCodeGeneratorTask extends CompilerTask {
   final JavaScriptBackend backend;
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
         super(backend.compiler);
   String get name() => 'SSA code generator';
   NativeEmitter get nativeEmitter() => backend.emitter.nativeEmitter;
 
 
   js.Fun buildJavaScriptFunction(FunctionElement element,
                                  List<js.Parameter> parameters,
                                  js.Block body) {
     FunctionExpression expression = element.cachedNode;
     js.Fun result = new js.Fun(parameters, body);
     result.sourcePosition = expression.getBeginToken();
     result.endSourcePosition = expression.getEndToken();
     return result;
   }
 
   CodeBuffer prettyPrint(js.Node node, Element positionElement) {
     return js.prettyPrint(node, compiler, positionElement);
   }
 
   CodeBuffer generateMethod(WorkItem work, HGraph graph) {
     return measure(() {
+      HTypeMap types = work.compilationContext.types;
+      graph.exit.predecessors.forEach((block) {
+        assert(block.last is HGoto || block.last is HReturn);
+        if (block.last is HReturn) {

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

How about a function with multiple return?

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

This should be handled by the

graph.exit.predecessors.forEach((block) {

above.

[ngeoffray, 2012/08/17 10:13:29]

Hmm, a HReturn block has the HExit block as a successor? Is that always true and
checked?

To make it simpler in the SSA, maybe we should have one HReturn and all return
values flow into a phi in the exit block, which will contain the HReturn.

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

I checked the (3) places where HReturn nodes are created, which is how I got to
this in the first place. For functions which don't return a value a HGoto is
normally taking control flow to the HExit node.

+          backend.registerReturnType(work.element, types[block.last.inputs[0]]);
+        } else {
+          backend.registerReturnType(work.element, HType.NULL);
+        }
+      });
       compiler.tracer.traceGraph("codegen", graph);
       Map<Element, String> parameterNames = getParameterNames(work);
       parameterNames.forEach((element, name) {
         compiler.enqueuer.codegen.addToWorkList(element);
       });
       List<js.Parameter> parameters = <js.Parameter>[];
       parameterNames.forEach((element, name) {
         parameters.add(new js.Parameter(name));
       });
       String parametersString = Strings.join(parameterNames.getValues(), ", ");
@@ skipping 2861 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }