In checked mode, make sure the ssa compiler propagates the checked types of

runtime/vm/flow_graph_optimizer.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/flow_graph_optimizer.h"
 
 #include "vm/flow_graph_builder.h"
 #include "vm/il_printer.h"
 #include "vm/object_store.h"
+#include "vm/parser.h"
+#include "vm/scopes.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, eliminate_type_checks);
 DECLARE_FLAG(bool, enable_type_checks);
 DEFINE_FLAG(bool, trace_optimization, false, "Print optimization details.");
 DECLARE_FLAG(bool, trace_type_check_elimination);
 
 void FlowGraphOptimizer::ApplyICData() {
   VisitBlocks();
@@ skipping 572 matching lines @@
 void FlowGraphTypePropagator::VisitGraphEntry(GraphEntryInstr* graph_entry) {
   if (graph_entry->start_env() == NULL) {
     return;
   }
   // Visit incoming parameters.
   for (intptr_t i = 0; i < graph_entry->start_env()->values().length(); i++) {
     Value* val = graph_entry->start_env()->values()[i];
     if (val->IsUse()) {
       ParameterInstr* param = val->AsUse()->definition()->AsParameter();
       if (param != NULL) {
+        ASSERT(param->index() == i);
         VisitParameter(param);
       }
     }
   }
 }
 
 
 void FlowGraphTypePropagator::VisitJoinEntry(JoinEntryInstr* join_entry) {
   if (join_entry->phis() != NULL) {
     for (intptr_t i = 0; i < join_entry->phis()->length(); ++i) {
@@ skipping 30 matching lines @@
   bool changed = phi->SetPropagatedType(type);
   if (changed) {
     still_changing_ = true;
   }
 }
 
 
 void FlowGraphTypePropagator::VisitParameter(ParameterInstr* param) {
   // TODO(regis): Once we inline functions, the propagated type of the formal
   // parameter will reflect the compile type of the passed-in argument.
-  // For now, we do not known anything about this type and therefore set it to
-  // the DynamicType.
-  bool changed = param->SetPropagatedType(Type::Handle(Type::DynamicType()));
+  // For now, we do not know anything about the argument type and therefore set
+  // it to the DynamicType, unless the argument is a compiler generated value,
+  // i.e. the receiver argument or the constructor phase argument.
+  AbstractType& param_type = AbstractType::Handle(Type::DynamicType());
+  if (param->index() < 2) {
+    const Function& function = parsed_function().function();
+    if (((param->index() == 0) && function.IsDynamicFunction()) ||
+        ((param->index() == 1) && function.IsConstructor())) {
+      // Parameter is the receiver or the constructor phase.
+      LocalScope* scope = parsed_function().node_sequence()->scope();
+      param_type = scope->VariableAt(param->index())->type().raw();
+    }
+  }
+  bool changed = param->SetPropagatedType(param_type);
   if (changed) {
     still_changing_ = true;
   }
 }
 
 
 void FlowGraphTypePropagator::PropagateTypes() {
   // TODO(regis): Is there a way to make this more efficient, e.g. by visiting
   // only blocks depending on blocks that have changed and not the whole graph.
   do {
@@ skipping 11 matching lines @@
       LocationSummary* locs = it.Current()->locs();
       if ((locs != NULL) && locs->is_call()) {
         is_leaf_ = false;
         return;
       }
     }
   }
 }
 
 }  // namespace dart