Infer guaranteed types for static calls that are only called once.

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 3278 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;

[kasperl, 2012/08/08 12:36:47]

I'm a bit worried about how we deal with null here. I think the compiler assumes
that anything that has HType.INTEGER associated with it cannot be null, but I'm
pretty sure that is not the case everywhere we know something has the type
represented with the intClass element.

[ahe, 2012/08/08 12:40:04]

Right now, I use the intClass to mean the concrete type non-null SMI. I really
should have something like this:

new ConcreteType(compiler.intClass);

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

[ngeoffray, 2012/08/16 12:55:40]

Why?

[ahe, 2012/08/16 17:15:19]

What else would you use?

[ngeoffray, 2012/08/17 07:59:28]

HBoundedPotentialPrimitiveArray. A user-defined class that extends List will not
be a readable array. Maybe the assumption here is that it will always be a JS
array (because that's what READABLE_ARRAY is), but this deserves a comment.

[ahe, 2012/08/21 15:05:38]

It will always be a JS array. That is what concrete-type inference is about.

I assume we will get a better infrastructure for this, so we don't use elements
to represent concrete types.

     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));
     }
@@ skipping 286 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;
   }
 }