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

sdk/lib/_internal/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.
 
 part of ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 1549 matching lines @@
                                    Selector defaultSelector) {
     // If [JSInvocationMirror.invokeOn] has been called, we must not create a
     // typed selector based on the receiver type.
     if (node.element == null && // Invocation is not exact.
         backend.compiler.enabledInvokeOn) {
       return defaultSelector;
     }
     int receiverIndex = node.isInterceptorCall ? 1 : 0;
     HType receiverHType = types[node.inputs[receiverIndex]];
     DartType receiverType = receiverHType.computeType(compiler);
-    if (receiverType != null &&
-        !identical(receiverType.kind, TypeKind.MALFORMED_TYPE)) {
-      return new TypedSelector(receiverType, defaultSelector);
+    if (receiverType != null && !receiverType.isMalformed) {
+      if (receiverHType.isExact()) {
+        return new TypedSelector.exact(receiverType, defaultSelector);
+      } else if (receiverHType.isInterfaceType()) {
+        return new TypedSelector.subtype(receiverType, defaultSelector);
+      } else {
+        return new TypedSelector.subclass(receiverType, defaultSelector);
+      }
     } else {
       return defaultSelector;
     }
   }
 
   void registerInvoke(HInvokeDynamic node) {
     bool inLoop = node.block.enclosingLoopHeader != null;
     SourceString name = node.selector.name;
     if (inLoop) {
       Element target = node.element;
@@ skipping 119 matching lines @@
           new js.PropertyAccess.field(classReference, "prototype");
       js.PropertyAccess method =
           new js.PropertyAccess.field(prototype, methodName);
       push(jsPropertyCall(method, "call", visitArguments(node.inputs)), node);
     }
     world.registerStaticUse(superMethod);
   }
 
   visitFieldGet(HFieldGet node) {
     use(node.receiver);
-    if (node.element == backend.jsArrayLength
-        || node.element == backend.jsStringLength) {
+    Element element = node.element;
+    if (element == backend.jsArrayLength || element == backend.jsStringLength) {
       // We're accessing a native JavaScript property called 'length'
       // on a JS String or a JS array. Therefore, the name of that
       // property should not be mangled.
       push(new js.PropertyAccess.field(pop(), 'length'), node);
     } else {
-      String name = _fieldPropertyName(node.element);
+      String name = _fieldPropertyName(element);
       push(new js.PropertyAccess.field(pop(), name), node);
-      HType receiverHType = types[node.receiver];
-      DartType type = receiverHType.computeType(compiler);
+      DartType type = types[node.receiver].computeType(compiler);
       if (type != null && !identical(type.kind, TypeKind.MALFORMED_TYPE)) {
-        world.registerFieldGetter(
-            node.element.name, node.element.getLibrary(), type);
+        world.registerFieldGetter(element);
       }
     }
   }
 
   visitFieldSet(HFieldSet node) {
-    String name = _fieldPropertyName(node.element);
+    Element element = node.element;
+    String name = _fieldPropertyName(element);
     DartType type = types[node.receiver].computeType(compiler);
     if (type != null && !identical(type.kind, TypeKind.MALFORMED_TYPE)) {
       // Field setters in the generative constructor body are handled in a
       // step "SsaConstructionFieldTypes" in the ssa optimizer.
       if (!work.element.isGenerativeConstructorBody()) {
-        world.registerFieldSetter(
-            node.element.name, node.element.getLibrary(), type);
-        backend.registerFieldSetter(
-            work.element, node.element, types[node.value]);
+        world.registerFieldSetter(element);
+        backend.registerFieldSetter(work.element, element, types[node.value]);
       }
     }
     use(node.receiver);
     js.Expression receiver = pop();
     use(node.value);
     push(new js.Assignment(new js.PropertyAccess.field(receiver, name), pop()),
         node);
   }
 
   String _fieldPropertyName(Element element) => element.hasFixedBackendName()
@@ skipping 1246 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }