Fix type check to perform a subtype test at top level instead of an

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 "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 1411 matching lines @@
   return raw() == Type::Handle(Type::ObjectType()).type_class();
 }
 
 
 bool Class::IsCanonicalSignatureClass() const {
   const Function& function = Function::Handle(signature_function());
   return (!function.IsNull() && (function.signature_class() == raw()));
 }
 
 
-bool Class::IsMoreSpecificThan(
+bool Class::IsSubtypeOf(
     const AbstractTypeArguments& type_arguments,
     const Class& other,
     const AbstractTypeArguments& other_type_arguments,
     Error* malformed_error) const {
+  ASSERT(is_finalized());
+  ASSERT(other.is_finalized());
   // Check for DynamicType.
   // The DynamicType on the lefthand side is replaced by the bottom type, which
   // is more specific than any type.
   // Any type is more specific than the DynamicType on the righthand side.
   if (IsDynamicClass() || other.IsDynamicClass()) {
     return true;
   }
   // Check for reflexivity.
   if (raw() == other.raw()) {
     const intptr_t len = NumTypeArguments();
     if (len == 0) {
       return true;
     }
     // Since we do not truncate the type argument vector of a subclass (see
     // below), we only check a prefix of the proper length.
     // Check for covariance.
     if (type_arguments.IsNull() ||
         other_type_arguments.IsNull() ||
         type_arguments.IsDynamicTypes(len) ||
         other_type_arguments.IsDynamicTypes(len)) {
       return true;
     }
-    return type_arguments.IsMoreSpecificThan(other_type_arguments,
-                                             len,
-                                             malformed_error);
+    return type_arguments.IsSubtypeOf(other_type_arguments,
+                                      len,
+                                      malformed_error);
   }
   // Check for two function types.
   if (IsSignatureClass() && other.IsSignatureClass()) {
     const Function& fun = Function::Handle(signature_function());
     const Function& other_fun = Function::Handle(other.signature_function());
     return fun.IsSubtypeOf(type_arguments,
                            other_fun,
                            other_type_arguments,
                            malformed_error);
   }
@@ skipping 26 matching lines @@
         // check from true in production mode to false in checked mode.
         if (FLAG_enable_type_checks && !interface_args.IsNull()) {
           // Pass type_arguments as bounds instantiator.
           if (!interface_args.IsWithinBoundsOf(interface_class,
                                                type_arguments,
                                                malformed_error)) {
             continue;
           }
         }
       }
-      if (interface_class.IsMoreSpecificThan(interface_args,
-                                             other,
-                                             other_type_arguments,
-                                             malformed_error)) {
+      if (interface_class.IsSubtypeOf(interface_args,
+                                      other,
+                                      other_type_arguments,
+                                      malformed_error)) {
         return true;
       }
     }
   }
   // Check the interface case.
   if (is_interface()) {
     // We already checked the case where 'other' is an interface. Now, 'this',
     // an interface, cannot be more specific than a class, except class Object,
     // because although Object is not considered an interface by the vm, it is
     // one. In other words, all classes implementing this interface also extend
     // class Object. An interface is also more specific than the DynamicType.
     return (other.IsDynamicClass() || other.IsObjectClass());
   }
   const Class& super_class = Class::Handle(SuperClass());
   if (super_class.IsNull()) {
     return false;
   }
   // Instead of truncating the type argument vector to the length of the super
   // type argument vector, we make sure that the code works with a vector that
   // is longer than necessary.
-  return super_class.IsMoreSpecificThan(type_arguments,
-                                        other,
-                                        other_type_arguments,
-                                        malformed_error);
+  return super_class.IsSubtypeOf(type_arguments,
+                                 other,
+                                 other_type_arguments,
+                                 malformed_error);
 }
 
 
 bool Class::IsTopLevel() const {
   return String::Handle(Name()).Equals("::");
 }
 
 
-bool Class::TestType(TypeTestKind test,
-                     const AbstractTypeArguments& type_arguments,
-                     const Class& other,
-                     const AbstractTypeArguments& other_type_arguments,
-                     Error* malformed_error) const {
-  ASSERT(is_finalized() || !ClassFinalizer::AllClassesFinalized());
-  ASSERT(other.is_finalized() || !ClassFinalizer::AllClassesFinalized());
-  if (test == kIsAssignableTo) {
-    // The spec states that "a type T is assignable to a type S if T is a
-    // subtype of S or S is a subtype of T". This is from the perspective of a
-    // static checker, which does not know the actual type of the assigned
-    // value. However, this type information is available at run time in checked
-    // mode. We therefore apply a more restrictive subtype check, which prevents
-    // heap pollution. We only keep the assignability check when assigning
-    // values of a function type.
-    if (IsSignatureClass() && other.IsSignatureClass()) {
-      const Function& src_fun = Function::Handle(signature_function());
-      const Function& dst_fun = Function::Handle(other.signature_function());
-      return src_fun.IsAssignableTo(type_arguments,
-                                    dst_fun,
-                                    other_type_arguments,
-                                    malformed_error);
-    }
-    // Continue with a subtype test.
-    test = kIsSubtypeOf;
-  }
-  ASSERT(test == kIsSubtypeOf);
-
-  // Check for "more specific" relation.
-  return IsMoreSpecificThan(type_arguments, other, other_type_arguments,
-                            malformed_error);
-}
-
-
 RawFunction* Class::LookupDynamicFunction(const String& name) const {
   Function& function = Function::Handle(LookupFunction(name));
   if (function.IsNull() || !function.IsDynamicFunction()) {
     return Function::null();
   }
   return function.raw();
 }
 
 
 RawFunction* Class::LookupStaticFunction(const String& name) const {
@@ skipping 533 matching lines @@
       (type_class() == Type::Handle(Type::FunctionInterface()).type_class());
 }
 
 
 bool AbstractType::IsListInterface() const {
   return HasResolvedTypeClass() &&
       (type_class() == Type::Handle(Type::ListInterface()).type_class());
 }
 
 
-bool AbstractType::IsMoreSpecificThan(const AbstractType& other,
-                                      Error* malformed_error) const {
+bool AbstractType::IsSubtypeOf(const AbstractType& other,
+                               Error* malformed_error) const {
   ASSERT(IsFinalized());
   ASSERT(other.IsFinalized());
-  // AbstractType parameters cannot be handled by Class::IsMoreSpecificThan().
+  // AbstractType parameters cannot be handled by Class::IsSubtypeOf().
   if (IsTypeParameter() || other.IsTypeParameter()) {
     return IsTypeParameter() && other.IsTypeParameter() &&
         (Index() == other.Index());
   }
   const Class& cls = Class::Handle(type_class());
-  return cls.IsMoreSpecificThan(
-      AbstractTypeArguments::Handle(arguments()),
-      Class::Handle(other.type_class()),
-      AbstractTypeArguments::Handle(other.arguments()),
-      malformed_error);
-}
-
-
-bool AbstractType::Test(TypeTestKind test,
-                        const AbstractType& other,
-                        Error* malformed_error) const {
-  ASSERT(IsFinalized());
-  ASSERT(other.IsFinalized());
-  // AbstractType parameters cannot be handled by Class::TestType().
-  if (IsTypeParameter() || other.IsTypeParameter()) {
-    return IsTypeParameter() && other.IsTypeParameter() &&
-        (Index() == other.Index());
-  }
-  const Class& cls = Class::Handle(type_class());
-  if (test == kIsSubtypeOf) {
-    return cls.IsSubtypeOf(AbstractTypeArguments::Handle(arguments()),
-                           Class::Handle(other.type_class()),
-                           AbstractTypeArguments::Handle(other.arguments()),
-                           malformed_error);
-  } else {
-    ASSERT(test == kIsAssignableTo);
-    return cls.IsAssignableTo(AbstractTypeArguments::Handle(arguments()),
-                              Class::Handle(other.type_class()),
-                              AbstractTypeArguments::Handle(other.arguments()),
-                              malformed_error);
-  }
+  return cls.IsSubtypeOf(AbstractTypeArguments::Handle(arguments()),
+                         Class::Handle(other.type_class()),
+                         AbstractTypeArguments::Handle(other.arguments()),
+                         malformed_error);
 }
 
 RawAbstractType* AbstractType::NewTypeParameter(
     intptr_t index, const String& name, intptr_t token_index) {
   return TypeParameter::New(index, name, token_index);
 }
 
 
 RawAbstractType* AbstractType::NewInstantiatedType(
     const AbstractType& uninstantiated_type,
@@ skipping 647 matching lines @@
     ASSERT(super_type.IsFinalized());
     const Class& super_class = Class::Handle(super_type.type_class());
     if (!IsWithinBoundsOf(super_class, bounds_instantiator, malformed_error)) {
       return false;
     }
   }
   return true;
 }
 
 
-bool AbstractTypeArguments::IsMoreSpecificThan(
+bool AbstractTypeArguments::IsSubtypeOf(
     const AbstractTypeArguments& other,
     intptr_t len,
     Error* malformed_error) const {
   ASSERT(Length() >= len);
   ASSERT(!other.IsNull());
   ASSERT(other.Length() >= len);
   AbstractType& type = AbstractType::Handle();
   AbstractType& other_type = AbstractType::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type = TypeAt(i);
     ASSERT(!type.IsNull());
     other_type = other.TypeAt(i);
     ASSERT(!other_type.IsNull());
-    if (!type.IsMoreSpecificThan(other_type, malformed_error)) {
+    if (!type.IsSubtypeOf(other_type, malformed_error)) {
       return false;
     }
   }
   return true;
 }
 
 
 const char* AbstractTypeArguments::ToCString() const {
   // AbstractTypeArguments is an abstract class, valid only for representing
   // null.
@@ skipping 559 matching lines @@
     return true;
   }
   if (!param_type.IsSubtypeOf(other_param_type, malformed_error) &&
       !other_param_type.IsSubtypeOf(param_type, malformed_error)) {
     return false;
   }
   return true;
 }
 
 
-bool Function::TestType(
-    TypeTestKind test,
+bool Function::IsSubtypeOf(
     const AbstractTypeArguments& type_arguments,
     const Function& other,
     const AbstractTypeArguments& other_type_arguments,
     Error* malformed_error) const {
   const intptr_t num_fixed_params = num_fixed_parameters();
   const intptr_t num_opt_params = num_optional_parameters();
   const intptr_t other_num_fixed_params = other.num_fixed_parameters();
   const intptr_t other_num_opt_params = other.num_optional_parameters();
   if ((num_fixed_params != other_num_fixed_params) ||
-      ((test == AbstractType::kIsSubtypeOf) &&
-       (num_opt_params < other_num_opt_params))) {
+      (num_opt_params < other_num_opt_params)) {
     return false;
   }
   // Check the result type.
   AbstractType& other_res_type = AbstractType::Handle(other.result_type());
   if (!other_res_type.IsInstantiated()) {
     other_res_type = other_res_type.InstantiateFrom(other_type_arguments);
   }
   if (!other_res_type.IsDynamicType() && !other_res_type.IsVoidType()) {
     AbstractType& res_type = AbstractType::Handle(result_type());
     if (!res_type.IsInstantiated()) {
       res_type = res_type.InstantiateFrom(type_arguments);
     }
     if (!res_type.IsDynamicType() &&
         (res_type.IsVoidType() ||
          !(res_type.IsSubtypeOf(other_res_type, malformed_error) ||
            other_res_type.IsSubtypeOf(res_type, malformed_error)))) {
       return false;
     }
   }
   // Check the types of fixed parameters.
   for (intptr_t i = 0; i < num_fixed_params; i++) {
     if (!TestParameterType(i, type_arguments, other, other_type_arguments,
                            malformed_error)) {
       return false;
     }
   }
   // Check the names and types of optional parameters.
-  if (num_opt_params >= other_num_opt_params) {
-    // Check that for each optional named parameter of type T of the other
-    // function type, there is a corresponding optional named parameter of this
-    // function at the same position with an identical name and with a type S
-    // that is a subtype or supertype of T.
-    // Note that SetParameterNameAt() guarantees that names are symbols, so we
-    // can compare their raw pointers.
-    const intptr_t other_num_params =
-        other_num_fixed_params + other_num_opt_params;
-    String& other_param_name = String::Handle();
-    for (intptr_t i = other_num_fixed_params; i < other_num_params; i++) {
-      other_param_name = other.ParameterNameAt(i);
-      if ((ParameterNameAt(i) != other_param_name.raw()) ||
-          !TestParameterType(i, type_arguments, other, other_type_arguments,
-                             malformed_error)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  ASSERT((test == AbstractType::kIsAssignableTo) &&
-         (num_opt_params < other_num_opt_params));
-  // To verify that this function type is assignable to the other function type,
-  // check that for each optional named parameter of type T of this function
-  // type, there is a corresponding optional named parameter of the other
-  // function at the same position with an identical name and with a type S that
-  // is a subtype or supertype of T.
+  // Check that for each optional named parameter of type T of the other
+  // function type, there is a corresponding optional named parameter of this
+  // function at the same position with an identical name and with a type S
+  // that is a subtype or supertype of T.
   // Note that SetParameterNameAt() guarantees that names are symbols, so we
   // can compare their raw pointers.
-  const intptr_t num_params = num_fixed_params + num_opt_params;
+  const intptr_t other_num_params =
+      other_num_fixed_params + other_num_opt_params;
   String& other_param_name = String::Handle();
-  for (intptr_t i = num_fixed_params; i < num_params; i++) {
+  for (intptr_t i = other_num_fixed_params; i < other_num_params; i++) {
     other_param_name = other.ParameterNameAt(i);
     if ((ParameterNameAt(i) != other_param_name.raw()) ||
         !TestParameterType(i, type_arguments, other, other_type_arguments,
                            malformed_error)) {
       return false;
     }
   }
   return true;
 }
 
@@ skipping 2731 matching lines @@
 
 
 void Instance::SetTypeArguments(const AbstractTypeArguments& value) const {
   const Class& cls = Class::Handle(clazz());
   intptr_t field_offset = cls.type_arguments_instance_field_offset();
   ASSERT(field_offset != Class::kNoTypeArguments);
   *FieldAddrAtOffset(field_offset) = value.Canonicalize();
 }
 
 
-bool Instance::TestType(TypeTestKind test,
-                        const AbstractType& other,
-                        const AbstractTypeArguments& other_instantiator,
-                        Error* malformed_error) const {
+bool Instance::IsInstanceOf(const AbstractType& other,
+                            const AbstractTypeArguments& other_instantiator,
+                            Error* malformed_error) const {
   ASSERT(other.IsFinalized());
   ASSERT(!other.IsDynamicType());
   ASSERT(!other.IsVoidType());
   if (IsNull()) {
-    if (test == AbstractType::kIsSubtypeOf) {
-      Class& other_class = Class::Handle();
-      if (other.IsTypeParameter()) {
-        if (other_instantiator.IsNull()) {
-          return true;  // Other type is uninstantiated, i.e. Dynamic.
-        }
-        const AbstractType& instantiated_other =
-            AbstractType::Handle(other_instantiator.TypeAt(other.Index()));
-        ASSERT(instantiated_other.IsInstantiated());
-        other_class = instantiated_other.type_class();
-      } else {
-        other_class = other.type_class();
+    Class& other_class = Class::Handle();
+    if (other.IsTypeParameter()) {
+      if (other_instantiator.IsNull()) {
+        return true;  // Other type is uninstantiated, i.e. Dynamic.
       }
-      return other_class.IsObjectClass() || other_class.IsDynamicClass();
+      const AbstractType& instantiated_other =
+          AbstractType::Handle(other_instantiator.TypeAt(other.Index()));
+      ASSERT(instantiated_other.IsInstantiated());
+      other_class = instantiated_other.type_class();
     } else {
-      ASSERT(test == AbstractType::kIsAssignableTo);
-      return true;
+      other_class = other.type_class();
     }
+    return other_class.IsObjectClass() || other_class.IsDynamicClass();
   }
   const Class& cls = Class::Handle(clazz());
   AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
   const intptr_t num_type_arguments = cls.NumTypeArguments();
   if (num_type_arguments > 0) {
     type_arguments = GetTypeArguments();
     // Verify that the number of type arguments in the instance matches the
     // number of type arguments expected by the instance class.
     // A discrepancy is allowed for closures, which borrow the type argument
     // vector of their instantiator, which may be of a super class of the class
@@ skipping 21 matching lines @@
     other_type_arguments = instantiated_other.arguments();
   } else {
     other_class = other.type_class();
     other_type_arguments = other.arguments();
     if (!other_type_arguments.IsNull() &&
         !other_type_arguments.IsInstantiated()) {
       other_type_arguments =
           other_type_arguments.InstantiateFrom(other_instantiator);
     }
   }
-  return cls.TestType(test, type_arguments, other_class, other_type_arguments,
-                      malformed_error);
+  return cls.IsSubtypeOf(type_arguments, other_class, other_type_arguments,
+                         malformed_error);
 }
 
 
 bool Instance::IsValidNativeIndex(int index) const {
   const Class& cls = Class::Handle(clazz());
   return (index >= 0 && index < cls.num_native_fields());
 }
 
 
 RawInstance* Instance::New(const Class& cls, Heap::Space space) {
@@ skipping 2523 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart