Void is not required to be `null` anymore.

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/become.h"
@@ skipping 3769 matching lines @@
                                  Heap::Space space) {
   // Use the thsi object as if it was the receiver of this method, but instead
   // of recursing reset it to the super class and loop.
   Zone* zone = Thread::Current()->zone();
   Class& thsi = Class::Handle(zone, cls.raw());
   while (true) {
     ASSERT(!thsi.IsVoidClass());
     // Check for DynamicType.
     // Each occurrence of DynamicType in type T is interpreted as the dynamic
     // type, a supertype of all types.
     if (other.IsDynamicClass()) {

[regis, 2017/03/22 16:29:32]

|| other.IsVoidClass()   // and update the comment, but check my question below
first

       return true;
     }
     // Check for NullType, which, as of Dart 1.5, is a subtype of (and is more
     // specific than) any type. Note that the null instance is not handled here.
     if (thsi.IsNullClass()) {
       return true;
     }
     // In the case of a subtype test, each occurrence of DynamicType in type S
     // is interpreted as the bottom type, a subtype of all types.
     // However, DynamicType is not more specific than any type.

[regis, 2017/03/22 16:29:32]

If dynamic is not more specific than void, then ignore my comment above and move
the void test below with the ObjectType test.

     if (thsi.IsDynamicClass()) {
       return test_kind == Class::kIsSubtypeOf;
     }
     // Check for ObjectType. Any type that is not NullType or DynamicType
     // (already checked above), is more specific than ObjectType.
     if (other.IsObjectClass()) {

[regis, 2017/03/22 16:29:32]

if you did not handle void above, check here.

       return true;
     }
     // Check for reflexivity.
     if (thsi.raw() == other.raw()) {
       const intptr_t num_type_params = thsi.NumTypeParameters();
       if (num_type_params == 0) {
         return true;
       }
       const intptr_t num_type_args = thsi.NumTypeArguments();
       const intptr_t from_index = num_type_args - num_type_params;
@@ skipping 995 matching lines @@
     ASSERT(type_param.IsFinalized());
     if ((type_param.index() != i)) {
       return false;
     }
     // If this type parameter specifies an upper bound, then the type argument
     // vector does not really represent the identity vector. It cannot be
     // substituted by the instantiator's type argument vector without checking
     // the upper bound.
     const AbstractType& bound = AbstractType::Handle(type_param.bound());
     ASSERT(bound.IsResolved());
     if (!bound.IsObjectType() && !bound.IsDynamicType()) {

[regis, 2017/03/22 16:29:32]

Is void allowed as an upper bound? If so, && !bound.IsVoidType()

       return false;
     }
   }
   return true;
   // Note that it is not necessary to verify at runtime that the instantiator
   // type vector is long enough, since this uninstantiated vector contains as
   // many different type parameters as it is long.
 }
 
 
@@ skipping 84 matching lines @@
   AbstractType& type = AbstractType::Handle();
   const intptr_t num_types = Length();
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     if (type.IsBoundedType()) {
       return true;
     }
     if (type.IsTypeParameter()) {
       const AbstractType& bound =
           AbstractType::Handle(TypeParameter::Cast(type).bound());
       if (!bound.IsObjectType() && !bound.IsDynamicType()) {

[regis, 2017/03/22 16:29:32]

ditto

         return true;
       }
       continue;
     }
     const TypeArguments& type_args =
         TypeArguments::Handle(Type::Cast(type).arguments());
     if (!type_args.IsNull() && type_args.IsBounded()) {
       return true;
     }
   }
@@ skipping 10697 matching lines @@
 
 bool Instance::IsInstanceOf(const AbstractType& other,
                             const TypeArguments& other_instantiator,
                             Error* bound_error) const {
   ASSERT(other.IsFinalized());
   ASSERT(!other.IsDynamicType());
   ASSERT(!other.IsTypeRef());  // Must be dereferenced at compile time.
   ASSERT(!other.IsMalformed());
   ASSERT(!other.IsMalbounded());
   if (other.IsVoidType()) {
-    return false;
+    return true;
   }
   Zone* zone = Thread::Current()->zone();
   const Class& cls = Class::Handle(zone, clazz());
   if (cls.IsClosureClass()) {
     if (other.IsObjectType() || other.IsDartFunctionType() ||
         other.IsDartClosureType()) {
       return true;
     }
     Function& other_signature = Function::Handle(zone);
     TypeArguments& other_type_arguments = TypeArguments::Handle(zone);
     // Note that we may encounter a bound error in checked mode.
     if (!other.IsInstantiated()) {
       AbstractType& instantiated_other = AbstractType::Handle(
           zone, other.InstantiateFrom(other_instantiator, bound_error, NULL,
                                       NULL, Heap::kOld));
       if ((bound_error != NULL) && !bound_error->IsNull()) {
         ASSERT(Isolate::Current()->type_checks());
         return false;
       }
       if (instantiated_other.IsTypeRef()) {
         instantiated_other = TypeRef::Cast(instantiated_other).type();
       }
       if (instantiated_other.IsDynamicType() ||
           instantiated_other.IsObjectType() ||
           instantiated_other.IsDartFunctionType()) {

[regis, 2017/03/22 16:29:32]

This may not yet be necessary, but it will as soon as we allow void as a type
argument:
|| instantiated_other.IsVoidType()

         return true;
       }
       if (!instantiated_other.IsFunctionType()) {
         return false;
       }
       other_signature = Type::Cast(instantiated_other).signature();
       other_type_arguments = instantiated_other.arguments();
     } else {
       if (!other.IsFunctionType()) {
         return false;
@@ skipping 775 matching lines @@
   if (other.IsMalbounded()) {
     ASSERT(Isolate::Current()->type_checks());
     if ((bound_error != NULL) && bound_error->IsNull()) {
       *bound_error = other.error();
     }
     return false;
   }
   // Any type is a subtype of (and is more specific than) Object and dynamic.
   // As of Dart 1.5, the Null type is a subtype of (and is more specific than)
   // any type.
   if (other.IsObjectType() || other.IsDynamicType() || IsNullType()) {

[regis, 2017/03/22 16:29:32]

|| other.IsVoidType()

     return true;
   }
   Zone* zone = Thread::Current()->zone();
   if (IsBoundedType() || other.IsBoundedType()) {
     if (Equals(other)) {
       return true;
     }
     // Redundant check if other type is equal to the upper bound of this type.
     if (IsBoundedType() &&
         AbstractType::Handle(BoundedType::Cast(*this).bound()).Equals(other)) {
@@ skipping 1632 matching lines @@
                                      instantiation_trail, bound_trail, space);
     // In case types of instantiator_type_arguments are not finalized
     // (or instantiated), then the instantiated_bounded_type is not finalized
     // (or instantiated) either.
     // Note that instantiator_type_arguments must have the final length, though.
   }
   if ((Isolate::Current()->type_checks()) && (bound_error != NULL) &&
       bound_error->IsNull()) {
     AbstractType& upper_bound = AbstractType::Handle(bound());
     ASSERT(upper_bound.IsFinalized());
     ASSERT(!upper_bound.IsObjectType() && !upper_bound.IsDynamicType());

[regis, 2017/03/22 16:29:32]

&& !upper_bound.IsVoidType()

     AbstractType& instantiated_upper_bound =
         AbstractType::Handle(upper_bound.raw());
     if (!upper_bound.IsInstantiated()) {
       instantiated_upper_bound =
           upper_bound.InstantiateFrom(instantiator_type_arguments, bound_error,
                                       instantiation_trail, bound_trail, space);
       // The instantiated_upper_bound may not be finalized or instantiated.
       // See comment above.
     }
     if (bound_error->IsNull()) {
@@ skipping 4797 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart