Cleanup handling of NullType in type propagation.

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 17 matching lines @@
 
 
 void UseVal::SetDefinition(Definition* definition) {
   ASSERT(definition != NULL);
   RemoveFromUseList();
   definition_ = definition;
   AddToUseList();
 }
 
 
+// Returns true if the value represents a constant.
+bool UseVal::BindsToConstant() const {
+  BindInstr* bind = definition()->AsBind();
+  if (bind == NULL) {
+    return false;
+  }
+  return bind->computation()->AsConstant() != NULL;
+}
+
+
+// Returns true if the value represents constant null.
+bool UseVal::BindsToConstantNull() const {
+  BindInstr* bind = definition()->AsBind();
+  if (bind == NULL) {
+    return false;
+  }
+  ConstantVal* constant = bind->computation()->AsConstant();
+  if (constant != NULL) {
+    return constant->value().IsNull();
+  }
+  return false;
+}
+
+
 void UseVal::RemoveFromUseList() {
   ASSERT(definition_ != NULL);
   if (next_use_ != NULL) {
     next_use_->previous_use_ = previous_use_;
   }
   if (previous_use_ != NULL) {
     previous_use_->next_use_ = next_use_;
   } else {
     // This is the head of the list.
     ASSERT(definition_->use_list() == this);
@@ skipping 94 matching lines @@
 }
 
 
 void ForwardInstructionIterator::RemoveCurrentFromGraph() {
   current_ = current_->RemoveFromGraph(true);  // Set current_ to previous.
 }
 
 
 // Default implementation of visiting basic blocks.  Can be overridden.
 void FlowGraphVisitor::VisitBlocks() {
+  ASSERT(current_iterator_ == NULL);
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     BlockEntryInstr* entry = block_order_[i];
     entry->Accept(this);
-    for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
+    ForwardInstructionIterator it(entry);
+    current_iterator_ = &it;
+    for (; !it.Done(); it.Advance()) {
       it.Current()->Accept(this);
     }
+    current_iterator_ = NULL;
   }
 }
 
 
 // Returns true if the compile type of this value is more specific than the
 // given dst_type.
 // TODO(regis): Support a set of compile types for the given value.
 bool Value::CompileTypeIsMoreSpecificThan(const AbstractType& dst_type) const {
-  ASSERT(!dst_type.IsMalformed());  // Should be tested by caller.
-  ASSERT(!dst_type.IsDynamicType());  // Should be tested by caller.
-  ASSERT(!dst_type.IsObjectType());  // Should be tested by caller.
+  // No type is more specific than a malformed type.
+  if (dst_type.IsMalformed()) {
+    return false;
+  }
 
   // If the value is the null constant, its type (NullType) is more specific
   // than the destination type, even if the destination type is the void type,
   // since a void function is allowed to return null.
-  if (IsConstant() && AsConstant()->value().IsNull()) {
+  if (BindsToConstantNull()) {
     return true;
   }
 
   // Functions that do not explicitly return a value, implicitly return null,
   // except generative constructors, which return the object being constructed.
   // It is therefore acceptable for void functions to return null.
   // In case of a null constant, we have already returned true above, else we
   // return false here.
   if (dst_type.IsVoidType()) {
     return false;
@@ skipping 438 matching lines @@
   return Type::DynamicType();
 }
 
 
 RawAbstractType* PolymorphicInstanceCallComp::CompileType() const {
   return Type::DynamicType();
 }
 
 
 RawAbstractType* StaticCallComp::CompileType() const {
-  return function().result_type();
+  if (FLAG_enable_type_checks) {
+    return function().result_type();
+  }
+  return Type::DynamicType();
 }
 
 
 RawAbstractType* LoadLocalComp::CompileType() const {
   if (FLAG_enable_type_checks) {
     return local().type().raw();
   }
   return Type::DynamicType();
 }
 
@@ skipping 671 matching lines @@
   if (compiler->is_ssa()) {
     ASSERT(locs()->in(0).IsRegister());
     __ PushRegister(locs()->in(0).reg());
   }
 }
 
 
 #undef __
 
 }  // namespace dart