Add a type kind to TypedSelector. A typed selector can either be

sdk/lib/_internal/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.
 
 part of ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 285 matching lines @@
       builder.graph.thisInstruction = thisInstruction;
       builder.graph.entry.addAtEntry(thisInstruction);
       updateLocal(closureData.closureElement, thisInstruction);
     } else if (element.isInstanceMember()
                || element.isGenerativeConstructor()) {
       // Once closures have been mapped to classes their instance members might
       // not have any thisElement if the closure was created inside a static
       // context.
       ClassElement cls = element.getEnclosingClass();
       DartType type = cls.computeType(builder.compiler);
-      HThis thisInstruction = new HThis(closureData.thisElement,
-                                        new HBoundedType.nonNull(type));
+      HThis thisInstruction = new HThis(
+          closureData.thisElement,
+          new HBoundedType(
+              type, isExact: false, canBeNull: false, isInterfaceType: false));
       builder.graph.thisInstruction = thisInstruction;
       builder.graph.entry.addAtEntry(thisInstruction);
       directLocals[closureData.thisElement] = thisInstruction;
     }
 
     // If this method is an intercepted method, add the extra
     // parameter to it, that is the actual receiver.
     ClassElement cls = element.getEnclosingClass();
     if (builder.backend.isInterceptorClass(cls)) {
       HType type = HType.UNKNOWN;
@@ skipping 101 matching lines @@
   HType cachedTypeOfThis;
 
   HInstruction readThis() {
     HInstruction res = readLocal(closureData.thisElement);
     if (res.guaranteedType == null) {
       if (cachedTypeOfThis == null) {
         assert(closureData.isClosure());
         Element element = closureData.thisElement;
         ClassElement cls = element.enclosingElement.getEnclosingClass();
         DartType type = cls.computeType(builder.compiler);
-        cachedTypeOfThis = new HBoundedType.nonNull(type);
+        cachedTypeOfThis = new HBoundedType(
+            type,
+            canBeNull: false,
+            isExact: false,
+            isInterfaceType: false);

[kasperl, 2013/02/11 08:18:12]

This needs to take mixins into account. The type of this can be an interface
type if the method that reads this is in a class that is used as a mixin. A test
case for that would be good.

[ngeoffray, 2013/02/11 10:20:55]

Done.

       }
       res.guaranteedType = cachedTypeOfThis;
     }
     return res;
   }
 
   HLocalValue getLocal(Element element) {
     // If the element is a parameter, we already have a
     // HParameterValue for it. We cannot create another one because
     // it could then have another name than the real parameter. And
@@ skipping 3573 matching lines @@
     List<HInstruction> inputs = <HInstruction>[];
     for (Link<Node> link = node.entries.nodes;
          !link.isEmpty;
          link = link.tail) {
       visit(link.head);
       inputs.addLast(pop());
       inputs.addLast(pop());
     }
     HLiteralList keyValuePairs = new HLiteralList(inputs);
     add(keyValuePairs);
+    DartType mapType = compiler.mapLiteralClass.computeType(compiler);
     pushInvokeHelper1(backend.getMapMaker(), keyValuePairs,

[kasperl, 2013/02/11 08:18:12]

A comment that explains why this type isn't exact would be nice.

[ngeoffray, 2013/02/11 10:20:55]

Done.

-        new HType.fromBoundedType(compiler.mapClass.computeType(compiler),
+        new HType.fromBoundedType(mapType,
                                   compiler,
-                                  false));
+                                  canBeNull: false,
+                                  isExact: false,
+                                  isInterfaceType: true));
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
     visit(node.value);
     visit(node.key);
   }
 
   visitNamedArgument(NamedArgument node) {
     visit(node.expression);
   }
@@ skipping 567 matching lines @@
     compiler.unimplemented('SsaBuilder.visitTypedef', node: node);
   }
 
   visitTypeVariable(TypeVariable node) {
     compiler.internalError('SsaBuilder.visitTypeVariable');
   }
 
   HType mapBaseType(BaseType baseType) {
     if (!baseType.isClass()) return HType.UNKNOWN;
     ClassBaseType classBaseType = baseType;
-    return new HType.fromBoundedType(
-        classBaseType.element.computeType(compiler), compiler, false);
+    ClassElement cls = classBaseType.element;
+    // Special case the list and map classes that are used as types
+    // for literals in the type inferrer.
+    if (cls == compiler.listClass) {
+      return HType.READABLE_ARRAY;
+    } else if (cls == compiler.mapClass) {
+      return new HType.fromBoundedType(

[kasperl, 2013/02/11 08:18:12]

How many different variants of this constructor are actually used? Would it make
sense to just have them like:

   new HType.exactClass(type, compiler)
   new HType.nonNullExactClass(type, compiler)
   new HType.subclass(type, compiler)
   new HType.nonNullSubclass(type, compiler)
   new HType.subtype(type, compiler)
   new HType.nonNullSubtype(type, compiler)

To me that's a lot more readable.

[ngeoffray, 2013/02/11 10:20:55]

Done.

+          compiler.mapLiteralClass.computeType(compiler),
+          compiler,
+          canBeNull: false,
+          isExact: false,
+          isInterfaceType: true);
+    } else {
+      return new HType.fromBoundedType(
+          cls.computeType(compiler),
+          compiler,
+          canBeNull: false,
+          isExact: true,
+          isInterfaceType: false);
+    }
   }
 
   HType mapInferredType(ConcreteType concreteType) {
     if (concreteType == null) return HType.UNKNOWN;
     HType ssaType = HType.CONFLICTING;
     for (BaseType baseType in concreteType.baseTypes) {
       ssaType = ssaType.union(mapBaseType(baseType), compiler);
     }
     assert(!ssaType.isConflicting());
     return ssaType;
   }
 
   HType mapNativeType(type) {
     if (type == native.SpecialType.JsObject) {
       return new HBoundedType.exact(
           compiler.objectClass.computeType(compiler));
     } else if (type == native.SpecialType.JsArray) {
       return HType.READABLE_ARRAY;
     } else {
-      return new HType.fromBoundedType(type, compiler, false);
+      return new HType.fromBoundedType(
+          type,
+          compiler,
+          canBeNull: false,
+          isExact: false,
+          isInterfaceType: false);
     }
   }
 
   HType mapNativeBehaviorType(native.NativeBehavior nativeBehavior) {
     if (nativeBehavior.typesInstantiated.isEmpty) return HType.UNKNOWN;
 
     HType ssaType = HType.CONFLICTING;
     for (final type in nativeBehavior.typesInstantiated) {
       ssaType = ssaType.union(mapNativeType(type), compiler);
     }
@@ skipping 379 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;
   }
 }