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

sdk/lib/_internal/compiler/implementation/ssa/nodes.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;
 
 abstract class HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
@@ skipping 599 matching lines @@
     from.usedBy.clear();
   }
 
   /**
    * Rewrites all uses of the [from] instruction to using either the
    * [to] instruction, or a [HCheck] instruction that has better type
    * information on [to], and that dominates the user.
    */
   void rewriteWithBetterUser(HInstruction from, HInstruction to) {
     Link<HCheck> better = const Link<HCheck>();
-    for (HInstruction user in to.usedBy) {
-      if (user is HCheck && identical((user as HCheck).checkedInput, to)) {
+    for (var user in to.usedBy) {
+      if (user != from && user is HCheck && user.checkedInput == to) {
         better = better.prepend(user);
       }
     }
 
     if (better.isEmpty) return rewrite(from, to);
 
     L1: for (HInstruction user in from.usedBy) {
       for (HCheck check in better) {
         if (check.dominates(user)) {
           user.rewriteInput(from, check);
@@ skipping 291 matching lines @@
 
     StringBuffer buffer = new StringBuffer();
     buffer.write('(');
     addAsCommaSeparated(buffer, inputs);
     buffer.write(') - used at [');
     addAsCommaSeparated(buffer, usedBy);
     buffer.write(']');
     return buffer.toString();
   }
 
+  nonCheck(instruction) {
+    while (instruction is HCheck) instruction = instruction.checkedInput;
+    return instruction;
+  }
+
   bool gvnEquals(HInstruction other) {
     assert(useGvn() && other.useGvn());
     // Check that the type and the flags match.
     bool hasSameType = typeEquals(other);
     assert(hasSameType == (typeCode() == other.typeCode()));
     if (!hasSameType) return false;
     if (flags != other.flags) return false;
     // Check that the inputs match.
     final int inputsLength = inputs.length;
     final List<HInstruction> otherInputs = other.inputs;
     if (inputsLength != otherInputs.length) return false;
     for (int i = 0; i < inputsLength; i++) {
-      if (!identical(inputs[i], otherInputs[i])) return false;
+      if (nonCheck(inputs[i]) != nonCheck(otherInputs[i])) {
+        return false;
+      }
     }
     // Check that the data in the instruction matches.
     return dataEquals(other);
   }
 
   int gvnHashCode() {
     int result = typeCode();
     int length = inputs.length;
     for (int i = 0; i < length; i++) {
-      result = (result * 19) + (inputs[i].id) + (result >> 7);
+      result = (result * 19) + (nonCheck(inputs[i]).id) + (result >> 7);
     }
     return result;
   }
 
   // These methods should be overwritten by instructions that
   // participate in global value numbering.
   int typeCode() => HInstruction.UNDEFINED_TYPECODE;
   bool typeEquals(HInstruction other) => false;
   bool dataEquals(HInstruction other) => false;
 
@@ skipping 425 matching lines @@
     if (isSideEffectFree) {
       setUseGvn();
       setDependsOnInstancePropertyStore();
     } else {
       setDependsOnSomething();
       setAllSideEffects();
     }
   }
   toString() => 'invoke dynamic getter: $selector';
   accept(HVisitor visitor) => visitor.visitInvokeDynamicGetter(this);
+
+  int typeCode() => HInstruction.FIELD_GET_TYPECODE;
+  bool typeEquals(other) => other is HFieldGet || other is HInvokeDynamicGetter;
+  bool dataEquals(other) {
+    return other is HFieldGet
+        ? other.element.name == selector.name
+        : super.dataEquals(other);
+  }
 }
 
 class HInvokeDynamicSetter extends HInvokeDynamicField {
   HInvokeDynamicSetter(selector, element, inputs, isSideEffectFree)
     : super(selector, element, inputs, isSideEffectFree) {
     clearAllSideEffects();
     if (isSideEffectFree) {
       setChangesInstanceProperty();
     } else {
       setAllSideEffects();
@@ skipping 67 matching lines @@
     bool interceptor =
         backend.isInterceptorClass(sourceElement.getEnclosingClass());
     return interceptor && sourceElement is ThisElement;
   }
 
   bool canThrow() => receiver.canBeNull();
 
   accept(HVisitor visitor) => visitor.visitFieldGet(this);
 
   int typeCode() => HInstruction.FIELD_GET_TYPECODE;
-  bool typeEquals(other) => other is HFieldGet;
-  bool dataEquals(HFieldGet other) => element == other.element;
+  bool typeEquals(other) => other is HFieldGet || other is HInvokeDynamicGetter;
+  bool dataEquals(other) {
+    return other is HInvokeDynamicGetter
+        ? element.name == other.selector.name
+        : element == other.element;
+  }
   String toString() => "FieldGet $element";
 }
 
 class HFieldSet extends HFieldAccess {
   HFieldSet(Element element,
             HInstruction receiver,
             HInstruction value)
       : super(element, <HInstruction>[receiver, value]) {
     clearAllSideEffects();
     setChangesInstanceProperty();
@@ skipping 1162 matching lines @@
   HBasicBlock get start => expression.start;
   HBasicBlock get end {
     // We don't create a switch block if there are no cases.
     assert(!statements.isEmpty);
     return statements.last.end;
   }
 
   bool accept(HStatementInformationVisitor visitor) =>
       visitor.visitSwitchInfo(this);
 }