Check type argument bounds of interfaces in type tests (work in progress).

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 16 matching lines @@
 #include "vm/runtime_entry.h"
 #include "vm/scopes.h"
 #include "vm/timer.h"
 #include "vm/unicode.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, generate_gdb_symbols, false,
     "Generate symbols of generated dart functions for debugging with GDB");
 DECLARE_FLAG(bool, trace_compiler);
+DECLARE_FLAG(bool, enable_type_checks);
 
 static const char* kGetterPrefix = "get:";
 static const intptr_t kGetterPrefixLength = strlen(kGetterPrefix);
 static const char* kSetterPrefix = "set:";
 static const intptr_t kSetterPrefixLength = strlen(kSetterPrefix);
 
 cpp_vtable Object::handle_vtable_ = 0;
 cpp_vtable Smi::handle_vtable_ = 0;
 
 // These are initialized to a value that will force a illegal memory access if
@@ skipping 1403 matching lines @@
   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 implements an interface that is parameterized with generic
-        // type(s), e.g. it implements Array<T>.
+        // 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.
-        if (type_arguments.IsNull()) {
-          // This type is raw, so the uninstantiated type arguments of the
-          // interface cannot be instantiated and we must check against a raw
-          // interface.
-          interface_args = TypeArguments::null();
-        } else {
-          // 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);
-          // TODO(regis): Do we have to consider the bounds of the type
-          // parameters of the interface?
+        // 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.

[srdjan, 2012/03/01 19:05:02]

Can you please add comment how is the difference at runtime in checked mode
on/off (not true/false, but true/error).

[regis, 2012/03/01 19:54:25]

Done.

+        if (FLAG_enable_type_checks && !interface_args.IsNull()) {
+          AbstractTypeArguments& interface_bounds =
+              AbstractTypeArguments::Handle(
+                  interface_class.type_parameter_bounds());
+          ASSERT(!interface_bounds.IsNull());
+          if (!interface_bounds.IsInstantiated()) {
+            interface_bounds = interface_bounds.InstantiateFrom(type_arguments);
+          }
+          const intptr_t len = interface_args.Length();
+          if (!interface_args.IsMoreSpecificThan(interface_bounds, len)) {
+            // TODO(regis): Handle malformed type error.
+            continue;
+          }
         }
       }
       if (interface_class.IsMoreSpecificThan(interface_args,
                                              other,
                                              other_type_arguments)) {
         return true;
       }
     }
   }
   // Check the interface case.
@@ skipping 7024 matching lines @@
   result.set_num_args_tested(num_args_tested);
   // Number of array elements in one test entry (num_args_tested + 1)
   intptr_t len = num_args_tested + 1;
   // IC data array must be null terminated (sentinel entry).
   Array& ic_data = Array::Handle(Array::New(len, Heap::kOld));
   result.set_ic_data(ic_data);
   return result.raw();
 }
 
 }  // namespace dart