Revert "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 3802 matching lines @@
                                  const Class& other,
                                  const TypeArguments& other_type_arguments,
                                  Error* bound_error,
                                  TrailPtr bound_trail,
                                  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()) {
       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.
     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/VoidType.
-    if (other.IsObjectClass() || other.IsVoidClass()) {
+    // (already checked above), is more specific than ObjectType.
+    if (other.IsObjectClass()) {
       return true;
     }
-    // If other is neither Object, dynamic or void, then ObjectType/VoidType
-    // can't be a subtype of other.
-    if (thsi.IsObjectClass() || thsi.IsVoidClass()) {
-      return false;
-    }
     // 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;
       // Since we do not truncate the type argument vector of a subclass (see
       // below), we only check a subvector of the proper length.
@@ skipping 11967 matching lines @@
     const AbstractType& other,
     const TypeArguments& other_instantiator_type_arguments,
     const TypeArguments& other_function_type_arguments,
     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 true;
+    return false;
   }
   Zone* zone = Thread::Current()->zone();
   const Class& cls = Class::Handle(zone, clazz());
   if (cls.IsClosureClass()) {
     if (other.IsObjectType() || other.IsDartFunctionType() ||
         other.IsDartClosureType()) {
       return true;
     }
     AbstractType& instantiated_other = AbstractType::Handle(zone, other.raw());
     // Note that we may encounter a bound error in checked mode.
@@ skipping 797 matching lines @@
     return false;
   }
   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.24, void is dynamically treated like Object (except when
-  // comparing function-types).
   // As of Dart 1.5, the Null type is a subtype of (and is more specific than)
   // any type.
-  if (other.IsObjectType() || other.IsDynamicType() || other.IsVoidType() ||
-      IsNullType()) {
+  if (other.IsObjectType() || other.IsDynamicType() || IsNullType()) {
     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 6661 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart