Void is not required to be `null` anymore.

runtime/vm/flow_graph_type_propagator.cc

Index: runtime/vm/flow_graph_type_propagator.cc
diff --git a/runtime/vm/flow_graph_type_propagator.cc b/runtime/vm/flow_graph_type_propagator.cc
index 9617c03b3480e0c38da4ba21e4a48e71c1708757..be1366cdbf26d777d90435cf2861f4d09008583e 100644
--- a/runtime/vm/flow_graph_type_propagator.cc
+++ b/runtime/vm/flow_graph_type_propagator.cc
@@ -597,7 +597,7 @@ intptr_t CompileType::ToNullableCid() {
     } else if (type_->IsMalformed()) {
       cid_ = kDynamicCid;
     } else if (type_->IsVoidType()) {
-      cid_ = kNullCid;
+      cid_ = kDynamicCid;
     } else if (type_->IsFunctionType() || type_->IsDartFunctionType()) {
       cid_ = kClosureCid;
     } else if (type_->HasResolvedTypeClass()) {
@@ -684,7 +684,7 @@ bool CompileType::CanComputeIsInstanceOf(const AbstractType& type,
     return false;
   }
 
-  if (type.IsDynamicType() || type.IsObjectType()) {
+  if (type.IsDynamicType() || type.IsObjectType() || type.IsVoidType()) {
     *is_instance = true;
     return true;
   }
@@ -696,11 +696,6 @@ bool CompileType::CanComputeIsInstanceOf(const AbstractType& type,
   // 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;
   }
@@ -715,12 +710,6 @@ bool CompileType::CanComputeIsInstanceOf(const AbstractType& type,
     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) {
@@ -737,11 +726,6 @@ bool CompileType::IsMoreSpecificThan(const AbstractType& other) {
     return false;
   }
 
-  if (other.IsVoidType()) {
-    // The only value assignable to void is null.
-    return IsNull();
-  }
-
   return ToAbstractType()->IsMoreSpecificThan(other, NULL, NULL, Heap::kOld);
 }
 
@@ -943,11 +927,6 @@ CompileType AssertAssignableInstr::ComputeType() const {
     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());
 }
 
@@ -1038,13 +1017,9 @@ CompileType StaticCallInstr::ComputeType() const {
   }
 
   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.IsVoidType() ? AbstractType::ZoneHandle(Type::NullType())
-                                 : result_type);
+    return CompileType::FromAbstractType(result_type);
   }
 
   return CompileType::Dynamic();