Basic type inference skeleton

dart/lib/compiler/implementation/ssa/builder.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 Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 199 matching lines @@
    */
   Map<Element, HInstruction> directLocals;
   Map<Element, Element> redirectionMapping;
   SsaBuilder builder;
   ClosureData closureData;
 
   LocalsHandler(this.builder)
       : directLocals = new Map<Element, HInstruction>(),
         redirectionMapping = new Map<Element, Element>();
 
+  get typesTask() => builder.compiler.typesTask;
+
   /**
    * Creates a new [LocalsHandler] based on [other]. We only need to
    * copy the [directLocals], since the other fields can be shared
    * throughout the AST visit.
    */
   LocalsHandler.from(LocalsHandler other)
       : directLocals = new Map<Element, HInstruction>.from(other.directLocals),
         redirectionMapping = other.redirectionMapping,
         builder = other.builder,
         closureData = other.closureData;
@@ skipping 78 matching lines @@
 
     ClosureTranslator translator = new ClosureTranslator(builder);
     closureData = translator.translate(node);
 
     FunctionSignature signature = function.computeSignature(builder.compiler);
     signature.forEachParameter((Element element) {
       HInstruction parameter = new HParameterValue(element);
       builder.add(parameter);
       builder.parameters[element] = parameter;
       directLocals[element] = parameter;
+      parameter.guaranteedType =
+        builder.mapInferredType(typesTask.getGuaranteedTypeOfElement(element));
     });
 
     enterScope(node);
 
     // If the freeVariableMapping is not empty, then this function was a
     // nested closure that captures variables. Redirect the captured
     // variables to fields in the closure.
     closureData.freeVariableMapping.forEach((Element from, Element to) {
       redirectElement(from, to);
     });
@@ skipping 2956 matching lines @@
   }
 
   visitTypedef(Typedef node) {
     compiler.unimplemented('SsaBuilder.visitTypedef', node: node);
   }
 
   visitTypeVariable(TypeVariable node) {
     compiler.internalError('SsaBuilder.visitTypeVariable');
   }
 
+  HType mapInferredType(Element element) {
+    if (element === builder.compiler.boolClass) return HType.BOOLEAN;

[ngeoffray, 2012/08/16 12:53:10]

Should those be BOOLEAN_OR_NULL, ... ?

[ahe, 2012/08/16 17:26:54]

No. It has been inferred that it must be a bool. This is the "concrete" part of
concrete-type inference, and why it felt appropriate to use elements.

However, I think when Paul's changes land, we will probably switch to a cleaner
abstraction for concrete types.

See the discussion of concrete types vs abstract types in
http://labs.oracle.com/techrep/1996/smli_tr-96-52.pdf page 4.

+    if (element === builder.compiler.doubleClass) return HType.DOUBLE;
+    if (element === builder.compiler.intClass) return HType.INTEGER;
+    // TODO(ahe): How to map listClass to HType?

[ngeoffray, 2012/08/16 12:53:10]

new HBoundedPotentialPrimitiveArray(element.computeType(), canBeNull: true)

(or something)

[ahe, 2012/08/16 17:26:54]

It can't be null and it will be a primitive array.

+    if (element === builder.compiler.listClass) return HType.UNKNOWN;
+    if (element === builder.compiler.nullClass) return HType.NULL;
+    if (element === builder.compiler.stringClass) return HType.STRING;
+    return HType.UNKNOWN;
+  }
+
   /** HACK HACK HACK */
   void hackAroundPossiblyAbortingBody(Node statement, void body()) {
     visitCondition() {
       stack.add(graph.addConstantBool(true));
     }
     buildBody() {
       // TODO(lrn): Make sure to take continue into account.
       body();
     }
     handleIf(statement, visitCondition, buildBody, null);
@@ skipping 281 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }