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

runtime/vm/flow_graph_builder.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_builder.h"
 
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
@@ skipping 10 matching lines @@
 
 namespace dart {
 
 DEFINE_FLAG(bool, eliminate_type_checks, true,
             "Eliminate type checks when allowed by static type analysis.");
 DEFINE_FLAG(bool, print_ast, false, "Print abstract syntax tree.");
 DEFINE_FLAG(bool, print_flow_graph, false, "Print the IR flow graph.");
 DEFINE_FLAG(bool, trace_type_check_elimination, false,
             "Trace type check elimination at compile time.");
 DECLARE_FLAG(bool, enable_type_checks);
+DECLARE_FLAG(bool, use_ssa);
 
 
 FlowGraphBuilder::FlowGraphBuilder(const ParsedFunction& parsed_function)
   : parsed_function_(parsed_function),
     copied_parameter_count_(parsed_function.copied_parameter_count()),
     // All parameters are copied if any parameter is.
     non_copied_parameter_count_((copied_parameter_count_ == 0)
         ? parsed_function.function().num_fixed_parameters()
         : 0),
     stack_local_count_(parsed_function.stack_local_count()),
@@ skipping 2147 matching lines @@
       // Skip type checking of receiver for instance functions.
       pos = 1;
     }
     while (pos < num_params) {
       const LocalVariable& parameter = *scope->VariableAt(pos);
       ASSERT(parameter.owner() == scope);
       if (!CanSkipTypeCheck(parameter.token_pos(),
                             NULL,
                             parameter.type(),
                             parameter.name())) {
-        Value* load = Bind(BuildLoadLocal(parameter));
-        Do(BuildAssertAssignable(parameter.token_pos(),
-                                 load,
-                                 parameter.type(),
-                                 parameter.name()));
+        Value* parameter_value = Bind(BuildLoadLocal(parameter));
+        AssertAssignableComp* assert_assignable =
+            BuildAssertAssignable(parameter.token_pos(),
+                                  parameter_value,
+                                  parameter.type(),
+                                  parameter.name());
+        if (FLAG_use_ssa) {
+          parameter_value = Bind(assert_assignable);
+          // Store the type checked argument back to its corresponding local
+          // variable so that ssa renaming detects the dependency and makes use
+          // of the checked type in type propagation.
+          Do(BuildStoreLocal(parameter, parameter_value));
+        } else {
+          // No need to store the check parameter value back when not using ssa.
+          Do(assert_assignable);
+        }
       }
       pos++;
     }
   }
 
   intptr_t i = 0;
   while (is_open() && (i < node->length())) {
     EffectGraphVisitor for_effect(owner(), temp_index());
     node->NodeAt(i++)->Visit(&for_effect);
     Append(for_effect);
@@ skipping 598 matching lines @@
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart