Generic bound errors are static type errors not to be reported by the VM.

runtime/vm/class_finalizer.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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 491 matching lines @@
         super_type_arg = super_type_arg.InstantiateFrom(arguments);
       }
       super_type_arg = super_type_arg.Canonicalize();
       arguments.SetTypeAt(super_offset + i, super_type_arg);
     }
     FinalizeTypeArguments(super_class, arguments);
   }
 }
 
 
-// Verify the upper bounds of the type arguments of class cls.
-void ClassFinalizer::VerifyUpperBounds(const Class& cls,
-                                       const AbstractTypeArguments& arguments) {
-  ASSERT(FLAG_enable_type_checks);
-  ASSERT(arguments.Length() >= cls.NumTypeArguments());
-  const intptr_t num_type_params = cls.NumTypeParameters();
-  const intptr_t offset = cls.NumTypeArguments() - num_type_params;
-  AbstractType& type = AbstractType::Handle();
-  AbstractType& bound = AbstractType::Handle();
-  const TypeArguments& bounds =
-      TypeArguments::Handle(cls.type_parameter_bounds());
-  ASSERT((bounds.IsNull() && (num_type_params == 0)) ||
-         (bounds.Length() == num_type_params));
-  for (intptr_t i = 0; i < num_type_params; i++) {
-    bound = bounds.TypeAt(i);
-    if (!bound.IsDynamicType()) {
-      type = arguments.TypeAt(offset + i);
-      if (type.IsInstantiated()) {
-        if (!bound.IsInstantiated()) {
-          bound = bound.InstantiateFrom(arguments);
-        }
-        // TODO(regis): Where do we check the bound when the type is generic?
-        if (!type.IsSubtypeOf(bound)) {
-          const String& type_argument_name = String::Handle(type.Name());
-          const String& class_name = String::Handle(cls.Name());
-          const String& bound_name = String::Handle(bound.Name());
-          const Script& script = Script::Handle(cls.script());
-          ReportError(script, type.token_index(),
-                      "type argument '%s' of class '%s' "
-                      "does not extend bound '%s'\n",
-                      type_argument_name.ToCString(),
-                      class_name.ToCString(),
-                      bound_name.ToCString());
-        }
-      }
-    }
-  }
-  const Type& super_type = Type::Handle(cls.super_type());
-  if (!super_type.IsNull()) {
-    ASSERT(super_type.IsFinalized());
-    const Class& super_class = Class::Handle(super_type.type_class());
-    VerifyUpperBounds(super_class, arguments);
-  }
-}
-
-
 RawAbstractType* ClassFinalizer::FinalizeType(const Class& cls,
                                               const AbstractType& type) {
   ASSERT(type.IsResolved());
   if (type.IsFinalized()) {
     return type.raw();
   }
   if (FLAG_trace_type_finalization) {
     OS::Print("Finalize type '%s'\n", String::Handle(type.Name()).ToCString());
   }
 
@@ skipping 103 matching lines @@
     // FinalizeTypeArguments can modify 'full_arguments',
     // canonicalize afterwards.
     full_arguments ^= full_arguments.Canonicalize();
     parameterized_type.set_arguments(full_arguments);
 
     // Mark the type as finalized before finalizing the upper bounds, because
     // cycles via upper bounds are legal at compile time.
     parameterized_type.set_is_finalized();
 
     ResolveAndFinalizeUpperBounds(type_class);
-    if (FLAG_enable_type_checks) {
-      VerifyUpperBounds(type_class, full_arguments);
-    }
+    // No need to verify the upper bounds of the finalized type arguments, since
+    // bound errors are static type errors, which are not reported by the VM.
   } else {
     parameterized_type.set_is_finalized();
   }
   return parameterized_type.Canonicalize();
 }
 
 
 void ClassFinalizer::ResolveAndFinalizeSignature(const Class& cls,
                                                  const Function& function) {
   // Resolve result type.
@@ skipping 530 matching lines @@
   va_end(args);
   if (FLAG_warning_as_error) {
     Isolate::Current()->long_jump_base()->Jump(1, error);
     UNREACHABLE();
   } else {
     OS::Print("%s", error.ToErrorCString());
   }
 }
 
 }  // namespace dart