Reapply r18377 it was reverted due to the unrelated bug it surfaced.

runtime/vm/il_printer.cc

 // 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.
 
 #include "vm/il_printer.h"
 
 #include "vm/intermediate_language.h"
 #include "vm/os.h"
 #include "vm/parser.h"
 
@@ skipping 70 matching lines @@
   OS::Print("%s", str);
 }
 
 
 void FlowGraphPrinter::PrintTypeCheck(const ParsedFunction& parsed_function,
                                       intptr_t token_pos,
                                       Value* value,
                                       const AbstractType& dst_type,
                                       const String& dst_name,
                                       bool eliminated) {
-    const Script& script = Script::Handle(parsed_function.function().script());
     const char* compile_type_name = "unknown";
     if (value != NULL) {
-      const AbstractType& type = AbstractType::Handle(value->CompileType());
-      if (!type.IsNull()) {
-        compile_type_name = String::Handle(type.Name()).ToCString();
-      }
+      compile_type_name = value->Type()->ToCString();
     }
-    Parser::PrintMessage(script, token_pos, "",
-                         "%s type check: compile type '%s' is %s specific than "
-                         "type '%s' of '%s'.",
+    OS::Print("%s type check: compile type %s is %s specific than "
+              "type '%s' of '%s'.\n",
                          eliminated ? "Eliminated" : "Generated",
                          compile_type_name,
                          eliminated ? "more" : "not more",
                          String::Handle(dst_type.Name()).ToCString(),
                          dst_name.ToCString());
 }
 
 
+void CompileType::PrintTo(BufferFormatter* f) const {
+  f->Print("T{");
+  f->Print("%s, ", is_nullable_ ? "null" : "not-null");
+  if (cid_ != kIllegalCid) {
+    const Class& cls =
+      Class::Handle(Isolate::Current()->class_table()->At(cid_));
+    f->Print("%s, ", String::Handle(cls.Name()).ToCString());
+  } else {
+    f->Print("?, ");
+  }
+  f->Print("%s}", (type_ != NULL) ? String::Handle(type_->Name()).ToCString()
+                                  : "?");
+}
+
+
+const char* CompileType::ToCString() const {
+  char buffer[1024];
+  BufferFormatter f(buffer, sizeof(buffer));
+  PrintTo(&f);
+  return Isolate::Current()->current_zone()->MakeCopyOfString(buffer);
+}
+
+
+
+
 static void PrintICData(BufferFormatter* f, const ICData& ic_data) {
   f->Print(" IC[%"Pd": ", ic_data.NumberOfChecks());
   Function& target = Function::Handle();
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
     GrowableArray<intptr_t> class_ids;
     ic_data.GetCheckAt(i, &class_ids, &target);
     const intptr_t count = ic_data.GetCountAt(i);
     if (i > 0) {
       f->Print(" | ");
     }
     for (intptr_t k = 0; k < class_ids.length(); k++) {
       if (k > 0) {
         f->Print(", ");
       }
       const Class& cls =
           Class::Handle(Isolate::Current()->class_table()->At(class_ids[k]));
       f->Print("%s", String::Handle(cls.Name()).ToCString());
     }
     if (count > 0) {
       f->Print(" #%"Pd, count);
     }
     f->Print(" <%p>", static_cast<void*>(target.raw()));
   }
   f->Print("]");
 }
 
 
-static void PrintPropagatedType(BufferFormatter* f, const Definition& def) {
-  if (def.HasPropagatedType()) {
-    String& name = String::Handle();
-    name = AbstractType::Handle(def.PropagatedType()).Name();
-    f->Print(" {PT: %s}", name.ToCString());
-  }
-  if (def.has_propagated_cid()) {
-    const Class& cls = Class::Handle(
-        Isolate::Current()->class_table()->At(def.propagated_cid()));
-    f->Print(" {PCid: %s}", String::Handle(cls.Name()).ToCString());
-  }
-}
-
-
 static void PrintUse(BufferFormatter* f, const Definition& definition) {
   if (definition.is_used()) {
     if (definition.HasSSATemp()) {
       f->Print("v%"Pd, definition.ssa_temp_index());
     } else if (definition.temp_index() != -1) {
       f->Print("t%"Pd, definition.temp_index());
     }
   }
 }
 
@@ skipping 14 matching lines @@
 
 
 void Definition::PrintTo(BufferFormatter* f) const {
   PrintUse(f, *this);
   if (is_used()) {
     if (HasSSATemp() || (temp_index() != -1)) f->Print(" <- ");
   }
   f->Print("%s:%"Pd"(", DebugName(), GetDeoptId());
   PrintOperandsTo(f);
   f->Print(")");
-  PrintPropagatedType(f, *this);
   if (range_ != NULL) {
     f->Print(" ");
     range_->PrintTo(f);
   }
+
+  if (type_ != NULL) {
+    f->Print(" ");
+    type_->PrintTo(f);
+  }
 }
 
 
 void Definition::PrintOperandsTo(BufferFormatter* f) const {
   for (int i = 0; i < InputCount(); ++i) {
     if (i > 0) f->Print(", ");
     if (InputAt(i) != NULL) InputAt(i)->PrintTo(f);
   }
 }
 
 
 void Value::PrintTo(BufferFormatter* f) const {
   PrintUse(f, *definition());
+  if ((reaching_type_ != NULL) &&
+      (reaching_type_ != definition()->Type())) {
+    f->Print(" ");
+    reaching_type_->PrintTo(f);
+  }
 }
 
 
 void ConstantInstr::PrintOperandsTo(BufferFormatter* f) const {
   const char* cstr = value().ToCString();
   const char* new_line = strchr(cstr, '\n');
   if (new_line == NULL) {
     f->Print("#%s", cstr);
   } else {
     const intptr_t pos = new_line - cstr;
@@ skipping 56 matching lines @@
 const char* RangeBoundary::ToCString() const {
   char buffer[256];
   BufferFormatter f(buffer, sizeof(buffer));
   PrintTo(&f);
   return Isolate::Current()->current_zone()->MakeCopyOfString(buffer);
 }
 
 
 void AssertAssignableInstr::PrintOperandsTo(BufferFormatter* f) const {
   value()->PrintTo(f);
-  f->Print(", %s, '%s'%s",
-           String::Handle(dst_type().Name()).ToCString(),
-           dst_name().ToCString(),
-           is_eliminated() ? " eliminated" : "");
+  f->Print(", %s, '%s'",
+           dst_type().ToCString(),
+           dst_name().ToCString());
   f->Print(" instantiator(");
   instantiator()->PrintTo(f);
   f->Print(")");
   f->Print(" instantiator_type_arguments(");
   instantiator_type_arguments()->PrintTo(f);
   f->Print(")");
 }
 
 
 void AssertBooleanInstr::PrintOperandsTo(BufferFormatter* f) const {
   value()->PrintTo(f);
-  f->Print("%s", is_eliminated() ? " eliminated" : "");
 }
 
 
 void ArgumentDefinitionTestInstr::PrintOperandsTo(BufferFormatter* f) const {
   saved_arguments_descriptor()->PrintTo(f);
   f->Print(", ?%s @%"Pd"",
            formal_parameter_name().ToCString(),
            formal_parameter_index());
 }
 
@@ skipping 295 matching lines @@
 }
 
 
 void PhiInstr::PrintTo(BufferFormatter* f) const {
   f->Print("v%"Pd" <- phi(", ssa_temp_index());
   for (intptr_t i = 0; i < inputs_.length(); ++i) {
     if (inputs_[i] != NULL) inputs_[i]->PrintTo(f);
     if (i < inputs_.length() - 1) f->Print(", ");
   }
   f->Print(")");
-  PrintPropagatedType(f, *this);
   if (is_alive()) {
     f->Print(" alive");
   } else {
     f->Print(" dead");
   }
   if (range_ != NULL) {
     f->Print(" ");
     range_->PrintTo(f);
   }
+  if (type_ != NULL) {
+    f->Print(" ");
+    type_->PrintTo(f);
+  }
 }
 
 
 void ParameterInstr::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%"Pd, index());
 }
 
 
 void TargetEntryInstr::PrintTo(BufferFormatter* f) const {
   f->Print("B%"Pd"[target", block_id());
@@ skipping 59 matching lines @@
       f->Print(" [");
       locations_[i].PrintTo(f);
       f->Print("]");
     }
   }
   f->Print(" }");
   if (outer_ != NULL) outer_->PrintTo(f);
 }
 
 }  // namespace dart