Reland "VM: Handle null-comparisons in the flow graph type propagation"

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/object_store.h"
@@ skipping 332 matching lines @@
   if (load_cid != NULL && comparison->InputAt(1)->BindsToConstant()) {
     intptr_t cid = Smi::Cast(comparison->InputAt(1)->BoundConstant()).Value();
     BlockEntryInstr* true_successor =
         negated ? instr->false_successor() : instr->true_successor();
     redef = flow_graph_->EnsureRedefinition(true_successor,
                                             load_cid->object()->definition(),
                                             CompileType::FromCid(cid));
   } else if ((call != NULL) &&
              call->MatchesCoreName(Symbols::_simpleInstanceOf()) &&
              comparison->InputAt(1)->BindsToConstant() &&
-             (comparison->InputAt(1)->BoundConstant().IsBool())) {
+             comparison->InputAt(1)->BoundConstant().IsBool()) {
     ASSERT(call->ArgumentAt(1)->IsConstant());
     if (comparison->InputAt(1)->BoundConstant().raw() == Bool::False().raw()) {
       negated = !negated;
     }
     BlockEntryInstr* true_successor =
         negated ? instr->false_successor() : instr->true_successor();
     const Object& type = call->ArgumentAt(1)->AsConstant()->value();
     if (type.IsType() && !Type::Cast(type).IsDynamicType() &&
         !Type::Cast(type).IsObjectType()) {
       const bool is_nullable = Type::Cast(type).IsNullType()
                                    ? CompileType::kNullable
                                    : CompileType::kNonNullable;
       redef = flow_graph_->EnsureRedefinition(
           true_successor, call->ArgumentAt(0),
           CompileType::FromAbstractType(Type::Cast(type), is_nullable));
     }
+  } else if (comparison->InputAt(0)->BindsToConstant() &&
+             comparison->InputAt(0)->BoundConstant().IsNull()) {
+    // Handle for expr != null.
+    BlockEntryInstr* true_successor =
+        negated ? instr->true_successor() : instr->false_successor();
+    redef = flow_graph_->EnsureRedefinition(
+        true_successor, comparison->InputAt(1)->definition(),
+        comparison->InputAt(1)->Type()->CopyNonNullable());
+
+  } else if (comparison->InputAt(1)->BindsToConstant() &&
+             comparison->InputAt(1)->BoundConstant().IsNull()) {
+    // Handle for null != expr.
+    BlockEntryInstr* true_successor =
+        negated ? instr->true_successor() : instr->false_successor();
+    redef = flow_graph_->EnsureRedefinition(
+        true_successor, comparison->InputAt(0)->definition(),
+        comparison->InputAt(0)->Type()->CopyNonNullable());
   }
-  // TODO(fschneider): Add propagation for null-comparisons.
   // TODO(fschneider): Add propagation for generic is-tests.
 
   // Grow types array if a new redefinition was inserted.
   if (redef != NULL) {
     for (intptr_t i = types_.length(); i <= redef->ssa_temp_index() + 1; ++i) {
       types_.Add(NULL);
     }
   }
 }
 
@@ skipping 161 matching lines @@
   return Create(kNullCid, Type::ZoneHandle(Type::NullType()));
 }
 
 
 CompileType CompileType::Bool() {
   return Create(kBoolCid, Type::ZoneHandle(Type::BoolType()));
 }
 
 
 CompileType CompileType::Int() {
-  return FromAbstractType(Type::ZoneHandle(Type::IntType()), kNonNullable);
+  return FromAbstractType(Type::ZoneHandle(Type::Int64Type()), kNonNullable);
 }
 
 
 CompileType CompileType::Smi() {
   return Create(kSmiCid, Type::ZoneHandle(Type::SmiType()));
 }
 
 
 CompileType CompileType::String() {
   return FromAbstractType(Type::ZoneHandle(Type::StringType()), kNonNullable);
@@ skipping 200 matching lines @@
   return UpdateType(result);
 }
 
 
 CompileType RedefinitionInstr::ComputeType() const {
   if (constrained_type_ != NULL) {
     // Check if the type associated with this redefinition is more specific
     // than the type of its input. If yes, return it. Otherwise, fall back
     // to the input's type.
 
-    // If either type has a concrete cid, stick with it.
-    if (value()->Type()->ToCid() != kDynamicCid) {
-      return *value()->Type();
-    }
-    if (constrained_type_->ToCid() != kDynamicCid) {
-      return *constrained_type_;
-    }
     // If either type is non-nullable, the resulting type is non-nullable.
     const bool is_nullable =
         value()->Type()->is_nullable() && constrained_type_->is_nullable();
+
+    // If either type has a concrete cid, stick with it.
+    if (value()->Type()->ToNullableCid() != kDynamicCid) {
+      return CompileType::CreateNullable(is_nullable,
+                                         value()->Type()->ToNullableCid());
+    }
+    if (constrained_type_->ToNullableCid() != kDynamicCid) {
+      return CompileType::CreateNullable(is_nullable,
+                                         constrained_type_->ToNullableCid());
+    }
     if (value()->Type()->IsMoreSpecificThan(
             *constrained_type_->ToAbstractType())) {
       return is_nullable ? *value()->Type()
                          : value()->Type()->CopyNonNullable();
     } else {
       return is_nullable ? *constrained_type_
                          : constrained_type_->CopyNonNullable();
     }
   }
   return *value()->Type();
@@ skipping 731 matching lines @@
 CompileType MergedMathInstr::ComputeType() const {
   return CompileType::Dynamic();
 }
 
 
 CompileType ExtractNthOutputInstr::ComputeType() const {
   return CompileType::FromCid(definition_cid_);
 }
 
 }  // namespace dart