Complete generic closure type checking.

runtime/vm/object.cc

 // Copyright (c) 2011, 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 "vm/assembler.h"
 #include "vm/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 1267 matching lines @@
       if (interface_class.IsMoreSpecificThan(interface_args,
                                              other,
                                              other_type_arguments)) {
         return true;
       }
     }
   }
   if (IsSignatureClass() && other.IsSignatureClass()) {
     const Function& fun = Function::Handle(signature_function());
     const Function& other_fun = Function::Handle(other.signature_function());
-    // TODO(regis): We need to consider the type arguments.
-    return fun.IsSubtypeOf(other_fun);
+    return fun.IsSubtypeOf(type_arguments,
+                           other_fun,
+                           other_type_arguments);
   }
+
   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 VarType.
     return (other.IsVarClass() || other.IsObjectClass());
   }
   const Class& super_class = Class::Handle(SuperClass());
   if (super_class.IsNull()) {
@@ skipping 11 matching lines @@
 bool Class::IsTopLevel() const {
   return String::Handle(Name()).Length() == 0;
 }
 
 
 bool Class::TestType(TypeTestKind test,
                      const TypeArguments& type_arguments,
                      const Class& other,
                      const TypeArguments& other_type_arguments) const {
   if (test == kIsAssignableTo) {
-    // TODO(regis): We do not follow the guide that says that "a type T is
-    // assignable to a type S if T is a subtype of S or S is a subtype of T",
-    // since this would lead to heap pollution. We only apply that rule to
-    // parameter types when checking assignability of function types.
-    // Revisit if necessary.
+    // 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());
-      // TODO(regis): We need to consider the type arguments.
-      return src_fun.IsAssignableTo(dst_fun);
+      return src_fun.IsAssignableTo(type_arguments,
+                                    dst_fun,
+                                    other_type_arguments);
     }
     // Continue with a subtype test.
     test = kIsSubtypeOf;
   }
   ASSERT(test == kIsSubtypeOf);
 
   // Check for "more specific" relation.
   if (IsMoreSpecificThan(type_arguments, other, other_type_arguments)) {
     return true;
   }
@@ skipping 431 matching lines @@
   return HasResolvedTypeClass() &&
       (type_class() == Type::Handle(Type::FunctionInterface()).type_class());
 }
 
 
 bool Type::IsMoreSpecificThan(const Type& other) const {
   ASSERT(IsFinalized());
   ASSERT(other.IsFinalized());
   // Type parameters cannot be handled by Class::IsMoreSpecificThan().
   if (IsTypeParameter() || other.IsTypeParameter()) {
-    // TODO(regis): Revisit this temporary workaround. See issue 5474672.
-    return
-        (!IsTypeParameter() && other.IsTypeParameter()) ||
-        (IsTypeParameter() && other.IsTypeParameter() &&
-         (Index() == other.Index()));
+    return IsTypeParameter() && other.IsTypeParameter() &&
+        (Index() == other.Index());
   }
   const Class& cls = Class::Handle(type_class());
   return cls.IsMoreSpecificThan(TypeArguments::Handle(arguments()),
                                 Class::Handle(other.type_class()),
                                 TypeArguments::Handle(other.arguments()));
 }
 
 
 bool Type::Test(TypeTestKind test, const Type& other) const {
   ASSERT(IsFinalized());
   ASSERT(other.IsFinalized());
   // Type parameters cannot be handled by Class::TestType().
   if (IsTypeParameter() || other.IsTypeParameter()) {
-    // TODO(regis): Revisit this temporary workaround. See issue 5474672.
-    return
-        (!IsTypeParameter() && other.IsTypeParameter()) ||
-        (IsTypeParameter() && other.IsTypeParameter() &&
-         (Index() == other.Index()));
+    return IsTypeParameter() && other.IsTypeParameter() &&
+        (Index() == other.Index());
   }
   const Class& cls = Class::Handle(type_class());
   if (test == kIsSubtypeOf) {
     return cls.IsSubtypeOf(TypeArguments::Handle(arguments()),
                             Class::Handle(other.type_class()),
                             TypeArguments::Handle(other.arguments()));
   } else {
     ASSERT(test == kIsAssignableTo);
     return cls.IsAssignableTo(TypeArguments::Handle(arguments()),
                               Class::Handle(other.type_class()),
@@ skipping 896 matching lines @@
       }
     }
     if (!found_param_name) {
       return false;
     }
   }
   return true;
 }
 
 
-bool Function::TestType(TypeTestKind test, const Function& other) const {
+bool Function::TestType(TypeTestKind test,
+                        const TypeArguments& type_arguments,
+                        const Function& other,
+                        const TypeArguments& other_type_arguments) 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 == Type::kIsSubtypeOf) &&
        (num_opt_params < other_num_opt_params))) {
     return false;
   }
-  // TODO(regis): We currently ignore type parameters. We need to consider the
-  // parameter type upper bound, if any.
-  // Note that unless we use this code to check function overrides at compile
-  // time, all parameter types should be instantiated and we can remove code
-  // checking for type parameters.
-
   // Check the result type.
-  const Type& other_res_type = Type::Handle(other.result_type());
-  if (!other_res_type.IsTypeParameter() &&
-      !other_res_type.IsVarType() &&
-      !other_res_type.IsVoidType()) {
-    const Type& res_type = Type::Handle(result_type());
-    if (!res_type.IsTypeParameter() &&
-        !res_type.IsVarType() &&
-        (res_type.IsVoidType() || !res_type.IsSubtypeOf(other_res_type)) &&
-        ((test == Type::kIsSubtypeOf) ||
-         (!other_res_type.IsSubtypeOf(res_type)))) {
+  Type& other_res_type = Type::Handle(other.result_type());
+  if (!other_res_type.IsInstantiated()) {
+    other_res_type = other_res_type.InstantiateFrom(other_type_arguments, 0);
+  }
+  if (!other_res_type.IsVarType() && !other_res_type.IsVoidType()) {
+    Type& res_type = Type::Handle(result_type());
+    if (!res_type.IsInstantiated()) {
+      res_type = res_type.InstantiateFrom(type_arguments, 0);
+    }
+    if (!res_type.IsVarType() &&
+        (res_type.IsVoidType() || !res_type.IsAssignableTo(other_res_type))) {
       return false;
     }
   }
   // Check the types of fixed parameters.
   Type& param_type = Type::Handle();
   Type& other_param_type = Type::Handle();
   for (intptr_t i = 0; i < num_fixed_params; i++) {
     param_type = ParameterTypeAt(i);
-    if (param_type.IsTypeParameter() || param_type.IsVarType()) {
+    if (!param_type.IsInstantiated()) {
+      param_type = param_type.InstantiateFrom(type_arguments, 0);
+    }
+    if (param_type.IsVarType()) {
       continue;
     }
     other_param_type = other.ParameterTypeAt(i);
-    if (other_param_type.IsTypeParameter() || other_param_type.IsVarType()) {
+    if (!other_param_type.IsInstantiated()) {
+      other_param_type =
+          other_param_type.InstantiateFrom(other_type_arguments, 0);
+    }
+    if (other_param_type.IsVarType()) {
       continue;
     }
     // Subtyping and assignability rules are identical when applied to parameter
     // types.
     ASSERT((test == Type::kIsSubtypeOf) || (test == Type::kIsAssignableTo));
     if (!param_type.IsSubtypeOf(other_param_type) &&
         !other_param_type.IsSubtypeOf(param_type)) {
       return false;
     }
   }
   // Check the names and types of optional parameters.
   // First, check that for each optional named parameter of type T of the other
   // function type, there exists an optional named parameter of this function
   // type 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 int num_params = num_fixed_params + num_opt_params;
   const int other_num_params = other_num_fixed_params + other_num_opt_params;
   bool is_subtype = true;
   bool found_param_name;
   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);
     found_param_name = false;
     for (intptr_t j = num_fixed_params; j < num_params; j++) {
       if (ParameterNameAt(j) == other_param_name.raw()) {
         found_param_name = true;
         param_type = ParameterTypeAt(j);
-        if (param_type.IsTypeParameter() || param_type.IsVarType()) {
+        if (!param_type.IsInstantiated()) {
+          param_type = param_type.InstantiateFrom(type_arguments, 0);
+        }
+        if (param_type.IsVarType()) {
           break;
         }
         other_param_type = other.ParameterTypeAt(i);
-        if (other_param_type.IsTypeParameter() ||
-            other_param_type.IsVarType()) {
+        if (!other_param_type.IsInstantiated()) {
+          other_param_type =
+              other_param_type.InstantiateFrom(other_type_arguments, 0);
+        }
+        if (other_param_type.IsVarType()) {
           break;
         }
         if (!param_type.IsSubtypeOf(other_param_type) &&
             !other_param_type.IsSubtypeOf(param_type)) {
           is_subtype = false;
         }
         break;
       }
     }
     if (!found_param_name) {
@@ skipping 16 matching lines @@
   ASSERT(test == Type::kIsAssignableTo);
   String& param_name = String::Handle();
   is_subtype = true;
   for (intptr_t i = num_fixed_params; i < num_params; i++) {
     param_name = ParameterNameAt(i);
     found_param_name = false;
     for (intptr_t j = other_num_fixed_params; j < other_num_params; j++) {
       if (other.ParameterNameAt(j) == param_name.raw()) {
         found_param_name = true;
         other_param_type = other.ParameterTypeAt(j);
-        if (other_param_type.IsTypeParameter() ||
-            other_param_type.IsVarType()) {
+        if (!other_param_type.IsInstantiated()) {
+          other_param_type =
+              other_param_type.InstantiateFrom(other_type_arguments, 0);
+        }
+        if (other_param_type.IsVarType()) {
           break;
         }
         param_type = ParameterTypeAt(i);
-        if (param_type.IsTypeParameter() || param_type.IsVarType()) {
+        if (!param_type.IsInstantiated()) {
+          param_type = param_type.InstantiateFrom(type_arguments, 0);
+        }
+        if (param_type.IsVarType()) {
           break;
         }
         if (!other_param_type.IsSubtypeOf(param_type) &&
             !param_type.IsSubtypeOf(other_param_type)) {
           return false;
         }
         break;
       }
     }
     if (!found_param_name) {
@@ skipping 3935 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