Fix type tests involving an implicit closure of a non-parameterized class

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 1220 matching lines @@
     // below), we only check a prefix of the proper length.
     // Check for covariance.
     if (type_arguments.IsNull() ||
         other_type_arguments.IsNull() ||
         type_arguments.IsVarTypes(len) ||
         other_type_arguments.IsVarTypes(len)) {
       return true;
     }
     return type_arguments.IsMoreSpecificThan(other_type_arguments, len);
   }
+  // 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);
+  }
   // Check for 'direct super type' in the case of an interface and check for
   // transitivity at the same time.
   if (other.is_interface()) {
     Array& interfaces = Array::Handle(this->interfaces());
     Type& interface = Type::Handle();
     Class& interface_class = Class::Handle();
     TypeArguments& interface_args = TypeArguments::Handle();
     for (intptr_t i = 0; i < interfaces.Length(); i++) {
       interface ^= interfaces.At(i);
       interface_class = interface.type_class();
@@ skipping 21 matching lines @@
           // return null on failure?
         }
       }
       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());
-    return fun.IsSubtypeOf(type_arguments,
-                           other_fun,
-                           other_type_arguments);
-  }
-
+  // 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 VarType.
     return (other.IsVarClass() || other.IsObjectClass());
   }
   const Class& super_class = Class::Handle(SuperClass());
   if (super_class.IsNull()) {
@@ skipping 5486 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