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

sdk/lib/_internal/compiler/implementation/ssa/builder.dart

Index: sdk/lib/_internal/compiler/implementation/ssa/builder.dart
===================================================================
--- sdk/lib/_internal/compiler/implementation/ssa/builder.dart	(revision 18249)
+++ sdk/lib/_internal/compiler/implementation/ssa/builder.dart	(working copy)
@@ -303,8 +303,10 @@
       // 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;
@@ -426,7 +428,11 @@
         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;
     }
@@ -4020,10 +4026,13 @@
     }
     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) {
@@ -4611,8 +4620,26 @@
   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) {
@@ -4632,7 +4659,12 @@
     } 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);
     }
   }