Implement implicit interfaces

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 1517 matching lines @@
   }
   // 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);
   }
   // Check for 'direct super type' in the case of an interface and check for

[regis, 2012/04/16 22:14:52]

You could clarify the comment:
... in the case of an interface, i.e. other.is_interface(), or of an implicit
interface, i.e. !other.is_interface(), and ...

[hausner, 2012/04/16 23:19:09]

Done.

   // transitivity at the same time.
-  if (other.is_interface()) {
-    Array& interfaces = Array::Handle(this->interfaces());
-    AbstractType& interface = AbstractType::Handle();
-    Class& interface_class = Class::Handle();
-    AbstractTypeArguments& interface_args = AbstractTypeArguments::Handle();
-    for (intptr_t i = 0; i < interfaces.Length(); i++) {
-      interface ^= interfaces.At(i);
-      interface_class = interface.type_class();
-      interface_args = interface.arguments();
-      if (!interface_args.IsNull() && !interface_args.IsInstantiated()) {
-        // This type class implements an interface that is parameterized with
-        // generic type(s), e.g. it implements List<T>.
-        // The uninstantiated type T must be instantiated using the type
-        // parameters of this type before performing the type test.
-        // The type arguments of this type that are referred to by the type
-        // parameters of the interface are at the end of the type vector,
-        // after the type arguments of the super type of this type.
-        // The index of the type parameters is adjusted upon finalization.
-        ASSERT(interface.IsFinalized());
-        interface_args = interface_args.InstantiateFrom(type_arguments);
-        // In checked mode, verify that the instantiated interface type
-        // arguments are within the bounds specified by the interface class.
-        // Note that the additional bounds check in checked mode may lead to a
-        // dynamic type error, but it will never change the result of the type
-        // 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;
-          }
+  Array& interfaces = Array::Handle(this->interfaces());
+  AbstractType& interface = AbstractType::Handle();
+  Class& interface_class = Class::Handle();
+  AbstractTypeArguments& interface_args = AbstractTypeArguments::Handle();
+  for (intptr_t i = 0; i < interfaces.Length(); i++) {
+    interface ^= interfaces.At(i);
+    interface_class = interface.type_class();
+    interface_args = interface.arguments();
+    if (!interface_args.IsNull() && !interface_args.IsInstantiated()) {
+      // This type class implements an interface that is parameterized with
+      // generic type(s), e.g. it implements List<T>.
+      // The uninstantiated type T must be instantiated using the type
+      // parameters of this type before performing the type test.
+      // The type arguments of this type that are referred to by the type
+      // parameters of the interface are at the end of the type vector,
+      // after the type arguments of the super type of this type.
+      // The index of the type parameters is adjusted upon finalization.
+      ASSERT(interface.IsFinalized());
+      interface_args = interface_args.InstantiateFrom(type_arguments);
+      // In checked mode, verify that the instantiated interface type
+      // arguments are within the bounds specified by the interface class.
+      // Note that the additional bounds check in checked mode may lead to a
+      // dynamic type error, but it will never change the result of the type
+      // 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.IsSubtypeOf(interface_args,
-                                      other,
-                                      other_type_arguments,
-                                      malformed_error)) {
-        return true;
-      }
+    }
+    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());
@@ skipping 7540 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