Revert "Void is not required to be `null` anymore."

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 579 matching lines @@
 
 
 intptr_t CompileType::ToNullableCid() {
   if (cid_ == kIllegalCid) {
     if (type_ == NULL) {
       // Type propagation is turned off or has not yet run.
       return kDynamicCid;
     } else if (type_->IsMalformed()) {
       cid_ = kDynamicCid;
     } else if (type_->IsVoidType()) {
-      cid_ = kDynamicCid;
+      cid_ = kNullCid;
     } else if (type_->IsFunctionType() || type_->IsDartFunctionType()) {
       cid_ = kClosureCid;
     } else if (type_->HasResolvedTypeClass()) {
       const Class& type_class = Class::Handle(type_->type_class());
       Thread* thread = Thread::Current();
       CHA* cha = thread->cha();
       // Don't infer a cid from an abstract type since there can be multiple
       // compatible classes with different cids.
       if (!CHA::IsImplemented(type_class) && !CHA::HasSubclasses(type_class)) {
         if (type_class.IsPrivate()) {
@@ skipping 66 matching lines @@
 
 bool CompileType::CanComputeIsInstanceOf(const AbstractType& type,
                                          bool is_nullable,
                                          bool* is_instance) {
   ASSERT(is_instance != NULL);
   // We cannot give an answer if the given type is malformed or malbounded.
   if (type.IsMalformedOrMalbounded()) {
     return false;
   }
 
-  if (type.IsDynamicType() || type.IsObjectType() || type.IsVoidType()) {
+  if (type.IsDynamicType() || type.IsObjectType()) {
     *is_instance = true;
     return true;
   }
 
   if (IsNone()) {
     return false;
   }
 
   // Consider the compile type of the value.
   const AbstractType& compile_type = *ToAbstractType();
 
+  // The compile-type of a value should never be void. The result of a void
+  // function must always be null, which was checked to be null at the return
+  // statement inside the function.
+  ASSERT(!compile_type.IsVoidType());
+
   if (compile_type.IsMalformedOrMalbounded()) {
     return false;
   }
 
   // The null instance is an instance of Null, of Object, and of dynamic.
   // 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.
   if (compile_type.IsNullType()) {
     *is_instance = is_nullable || type.IsObjectType() || type.IsDynamicType() ||
                    type.IsNullType() || type.IsVoidType();
     return true;
   }
 
+  // A non-null value is not an instance of void.
+  if (type.IsVoidType()) {
+    *is_instance = IsNull();
+    return HasDecidableNullability();
+  }
+
   // If the value can be null then we can't eliminate the
   // check unless null is allowed.
   if (is_nullable_ && !is_nullable) {
     return false;
   }
 
   *is_instance = compile_type.IsMoreSpecificThan(type, NULL, NULL, Heap::kOld);
   return *is_instance;
 }
 
 
 bool CompileType::IsMoreSpecificThan(const AbstractType& other) {
   if (IsNone()) {
     return false;
   }
 
+  if (other.IsVoidType()) {
+    // The only value assignable to void is null.
+    return IsNull();
+  }
+
   return ToAbstractType()->IsMoreSpecificThan(other, NULL, NULL, Heap::kOld);
 }
 
 
 CompileType* Value::Type() {
   if (reaching_type_ == NULL) {
     reaching_type_ = definition()->Type();
   }
   return reaching_type_;
 }
@@ skipping 181 matching lines @@
 }
 
 
 CompileType AssertAssignableInstr::ComputeType() const {
   CompileType* value_type = value()->Type();
 
   if (value_type->IsMoreSpecificThan(dst_type())) {
     return *value_type;
   }
 
+  if (dst_type().IsVoidType()) {
+    // The only value assignable to void is null.
+    return CompileType::Null();
+  }
+
   return CompileType::Create(value_type->ToCid(), dst_type());
 }
 
 
 bool AssertAssignableInstr::RecomputeType() {
   return UpdateType(ComputeType());
 }
 
 
 CompileType AssertBooleanInstr::ComputeType() const {
@@ skipping 70 matching lines @@
              : CompileType::Dynamic();
 }
 
 
 CompileType StaticCallInstr::ComputeType() const {
   if (result_cid_ != kDynamicCid) {
     return CompileType::FromCid(result_cid_);
   }
 
   if (Isolate::Current()->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);
+    return CompileType::FromAbstractType(
+        result_type.IsVoidType() ? AbstractType::ZoneHandle(Type::NullType())
+                                 : result_type);
   }
 
   return CompileType::Dynamic();
 }
 
 
 CompileType LoadLocalInstr::ComputeType() const {
   if (Isolate::Current()->type_checks()) {
     return CompileType::FromAbstractType(local().type());
   }
@@ skipping 486 matching lines @@
 CompileType MergedMathInstr::ComputeType() const {
   return CompileType::Dynamic();
 }
 
 
 CompileType ExtractNthOutputInstr::ComputeType() const {
   return CompileType::FromCid(definition_cid_);
 }
 
 }  // namespace dart