After a dynamic call, refine the receiver type by looking at the potential targets of that call.

sdk/lib/_internal/compiler/implementation/types/simple_types_inferrer.dart

 // Copyright (c) 2013, 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.
 
 library simple_types_inferrer;
 
 import 'dart:collection' show Queue, LinkedHashSet;
 
 import '../closure.dart' show ClosureClassMap, ClosureScope;
 import '../dart_types.dart' show DartType, FunctionType, TypeKind;
@@ skipping 78 matching lines @@
     if (constructorsToVisitCount != 0) constructorsToVisitCount--;
   }
 
   /**
    * Returns whether all generative constructors of the class have
    * been analyzed.
    */
   bool get isDone => constructorsToVisitCount == 0;
 }
 
-/**
- * A sentinel type mask class used by the inferrer for the give up
- * type, and the dynamic type.
- */
-class SentinelTypeMask extends TypeMask {
-  final String name;
-
-  SentinelTypeMask(this.name) : super(null, 0, false);
-
-  bool operator==(other) {
-    return identical(this, other);
-  }
-
-  TypeMask nullable() {
-    throw 'Unsupported operation';
-  }
-
-  bool get isNullable => true;
-
-  String toString() => '$name sentinel type mask';
-}
-
 final OPTIMISTIC = 0;
 final RETRY = 1;
 final PESSIMISTIC = 2;
 
 class SimpleTypesInferrer extends TypesInferrer {
   InternalSimpleTypesInferrer internal;
   Compiler compiler;
 
   SimpleTypesInferrer(Compiler compiler) :
       compiler = compiler,
@@ skipping 123 matching lines @@
    * Heuristic for avoiding too many re-analysis of an element.
    */
   final int MAX_ANALYSIS_COUNT_PER_ELEMENT = 5;
 
   int optimismState;
 
   /**
    * Sentinel used by the inferrer to notify that it does not know
    * the type of a specific element.
    */
-  final TypeMask dynamicType = new SentinelTypeMask('dynamic');
-  bool isDynamicType(TypeMask type) => identical(type, dynamicType);
+  TypeMask dynamicType;
+  bool isDynamicType(TypeMask type) => type == dynamicType;
 
   TypeMask nullType;
   TypeMask intType;
   TypeMask doubleType;
   TypeMask numType;
   TypeMask boolType;
   TypeMask functionType;
   TypeMask listType;
   TypeMask constListType;
   TypeMask fixedListType;
@@ skipping 260 matching lines @@
         rawTypeOf(backend.growableListImplementation));
 
     mapType = new TypeMask.nonNullSubtype(
         rawTypeOf(backend.mapImplementation));
     constMapType = new TypeMask.nonNullSubtype(
         rawTypeOf(backend.constMapImplementation));
     functionType = new TypeMask.nonNullSubtype(
         rawTypeOf(backend.functionImplementation));
     typeType = new TypeMask.nonNullExact(
         rawTypeOf(backend.typeImplementation));
+
+    dynamicType = new TypeMask.subclass(
+        rawTypeOf(compiler.objectClass));
   }
 
   dump() {
     int interestingTypes = 0;
     returnTypeOf.forEach((Element element, TypeMask type) {
       if (type != nullType && !isDynamicType(type)) {
         interestingTypes++;
       }
     });
     typeOf.forEach((Element element, TypeMask type) {
@@ skipping 624 matching lines @@
         enqueueCallersOf(field);
       }
     });
   }
 
   /**
    * Returns the least upper bound between [firstType] and
    * [secondType].
    */
   TypeMask computeLUB(TypeMask firstType, TypeMask secondType) {
-    assert(secondType != null);
     if (firstType == null) {
       return secondType;
     } else if (isDynamicType(secondType)) {
       return secondType;
     } else if (isDynamicType(firstType)) {
       return firstType;
     } else {
       TypeMask union = firstType.union(secondType, compiler);
       // TODO(kasperl): If the union isn't nullable it seems wasteful
       // to use dynamic. Fix that.
@@ skipping 382 matching lines @@
     // same as [newType].
     ClosureClassMap nestedClosureData =
         compiler.closureToClassMapper.getMappingForNestedFunction(node);
     nestedClosureData.forEachNonBoxedCapturedVariable((Element variable) {
       // The type may be null for instance contexts (this and type
       // parameters), as well as captured argument checks.
       if (locals.locals[variable] == null) return;
       inferrer.recordType(variable, locals.locals[variable]);
     });
 
+    locals.update(elements[node], inferrer.functionType);
     return inferrer.functionType;
   }
 
   TypeMask visitFunctionDeclaration(FunctionDeclaration node) {
     locals.update(elements[node], inferrer.functionType);
     return visit(node.function);
   }
 
   TypeMask visitLiteralString(LiteralString node) {
     return inferrer.stringType;
@@ skipping 468 matching lines @@
                              Selector selector,
                              TypeMask receiver,
                              ArgumentsTypes arguments,
                              [Selector constraint]) {
     if (selector.mask != receiver) {
       selector = inferrer.isDynamicType(receiver)
           ? selector.asUntyped
           : new TypedSelector(receiver, selector);
       updateSelectorInTree(node, selector);
     }
+   
+    // If the receiver of the call is a local, we may know more about
+    // its type by refining it with the potential targets of the
+    // calls. 
+    if (node.asSend() != null
+        && node.asSend().receiver != null
+        && Elements.isLocal(elements[node.asSend().receiver])) {
+      Element element = elements[node.asSend().receiver];
+      TypeMask refinedMask = new TypeMask.refineWith(
+          locals.use(element), selector, compiler);
+      locals.update(element, refinedMask);
+    }
+
     return inferrer.registerCalledSelector(
         node, selector, receiver, outermostElement, arguments,
         constraint, inLoop);
   }
 
   TypeMask visitDynamicSend(Send node) {
     Element element = elements[node];
     TypeMask receiverType;
     bool isCallOnThis = false;
     if (node.receiver == null) {
@@ skipping 208 matching lines @@
   }
 
   TypeMask visitParenthesizedExpression(ParenthesizedExpression node) {
     return visit(node.expression);
   }
 
   void internalError(String reason, {Node node}) {
     compiler.internalError(reason, node: node);
   }
 }