Fix http://dartbug.com/23578:

runtime/vm/flow_graph_type_propagator.cc

 // 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.
 
 #include "vm/flow_graph_type_propagator.h"
 
 #include "vm/cha.h"
 #include "vm/bit_vector.h"
 #include "vm/il_printer.h"
 #include "vm/regexp_assembler.h"
@@ skipping 20 matching lines @@
           flow_graph->zone(), flow_graph->reverse_postorder().length())),
       types_(flow_graph->current_ssa_temp_index()),
       in_worklist_(new(flow_graph->zone()) BitVector(
           flow_graph->zone(), flow_graph->current_ssa_temp_index())),
       asserts_(NULL),
       collected_asserts_(NULL) {
   for (intptr_t i = 0; i < flow_graph->current_ssa_temp_index(); i++) {
     types_.Add(NULL);
   }
 
-  if (Isolate::Current()->TypeChecksEnabled()) {
+  if (Isolate::Current()->flags().type_checks()) {
     asserts_ = new ZoneGrowableArray<AssertAssignableInstr*>(
         flow_graph->current_ssa_temp_index());
     for (intptr_t i = 0; i < flow_graph->current_ssa_temp_index(); i++) {
       asserts_->Add(NULL);
     }
 
     collected_asserts_ = new ZoneGrowableArray<intptr_t>(10);
   }
 }
 
@@ skipping 61 matching lines @@
 
 
 void FlowGraphTypePropagator::PropagateRecursive(BlockEntryInstr* block) {
   if (visited_blocks_->Contains(block->postorder_number())) {
     return;
   }
   visited_blocks_->Add(block->postorder_number());
 
   const intptr_t rollback_point = rollback_.length();
 
-  if (Isolate::Current()->TypeChecksEnabled()) {
+  if (Isolate::Current()->flags().type_checks()) {
     StrengthenAsserts(block);
   }
 
   block->Accept(this);
 
   for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
     Instruction* instr = it.Current();
 
     for (intptr_t i = 0; i < instr->InputCount(); i++) {
       VisitValue(instr->InputAt(i));
@@ skipping 780 matching lines @@
                      kContextCid,
                      &AbstractType::ZoneHandle(Type::DynamicType()));
 }
 
 
 CompileType StaticCallInstr::ComputeType() const {
   if (result_cid_ != kDynamicCid) {
     return CompileType::FromCid(result_cid_);
   }
 
-  if (Isolate::Current()->TypeChecksEnabled()) {
+  if (Isolate::Current()->flags().type_checks()) {
     // Void functions are known to return null, which is checked at the return
     // from the function.
     const AbstractType& result_type =
         AbstractType::ZoneHandle(function().result_type());
     return CompileType::FromAbstractType(result_type.IsVoidType()
         ? AbstractType::ZoneHandle(Type::NullType())
         : result_type);
   }
 
   return CompileType::Dynamic();
 }
 
 
 CompileType LoadLocalInstr::ComputeType() const {
-  if (Isolate::Current()->TypeChecksEnabled()) {
+  if (Isolate::Current()->flags().type_checks()) {
     return CompileType::FromAbstractType(local().type());
   }
   return CompileType::Dynamic();
 }
 
 
 CompileType PushTempInstr::ComputeType() const {
   return CompileType::Dynamic();
 }
 
@@ skipping 23 matching lines @@
   // TODO(srdjan): Do better and determine if it is a one or two byte string.
   return CompileType::String();
 }
 
 
 CompileType LoadStaticFieldInstr::ComputeType() const {
   bool is_nullable = CompileType::kNullable;
   intptr_t cid = kDynamicCid;
   AbstractType* abstract_type = NULL;
   const Field& field = this->StaticField();
-  if (Isolate::Current()->TypeChecksEnabled()) {
+  if (Isolate::Current()->flags().type_checks()) {
     cid = kIllegalCid;
     abstract_type = &AbstractType::ZoneHandle(field.type());
   }
   ASSERT(field.is_static());
   if (field.is_final()) {
     const Instance& obj = Instance::Handle(field.value());
     if ((obj.raw() != Object::sentinel().raw()) &&
         (obj.raw() != Object::transition_sentinel().raw()) &&
         !obj.IsNull()) {
       is_nullable = CompileType::kNonNullable;
@@ skipping 37 matching lines @@
 
 CompileType LoadFieldInstr::ComputeType() const {
   // Type may be null if the field is a VM field, e.g. context parent.
   // Keep it as null for debug purposes and do not return dynamic in production
   // mode, since misuse of the type would remain undetected.
   if (type().IsNull()) {
     return CompileType::Dynamic();
   }
 
   const AbstractType* abstract_type = NULL;
-  if (Isolate::Current()->TypeChecksEnabled()) {
+  if (Isolate::Current()->flags().type_checks()) {
     ASSERT(!type().HasResolvedTypeClass() ||
            !Field::IsExternalizableCid(Class::Handle(
                 type().type_class()).id()));
     abstract_type = &type();
   }
 
   if ((field_ != NULL) && (field_->guarded_cid() != kIllegalCid)) {
     bool is_nullable = field_->is_nullable();
     intptr_t field_cid =  field_->guarded_cid();
     if (Field::IsExternalizableCid(field_cid)) {
@@ skipping 372 matching lines @@
 CompileType MergedMathInstr::ComputeType() const {
   return CompileType::Dynamic();
 }
 
 
 CompileType ExtractNthOutputInstr::ComputeType() const {
   return CompileType::FromCid(definition_cid_);
 }
 
 }  // namespace dart