Generate a dynamic type error when creating an instance with a bound error.

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 2733 matching lines @@
     }
     type_class = type.type_class();
     if (!type_class.IsDynamicClass()) {
       return false;
     }
   }
   return true;
 }
 
 
-static RawError* FormatError(const Script& script,
+static RawError* FormatError(const Error& prev_error,
+                             const Script& script,
                              intptr_t token_index,
                              const char* format, ...) {
   va_list args;
   va_start(args, format);
-  return Parser::FormatError(script, token_index, "Error", format, args);
+  if (prev_error.IsNull()) {
+    return Parser::FormatError(script, token_index, "Error", format, args);
+  } else {
+    return Parser::FormatErrorWithAppend(prev_error, script, token_index,
+                                         "Error", format, args);
+  }
 }
 
 
 bool AbstractTypeArguments::IsWithinBoundsOf(
     const Class& cls,
     const AbstractTypeArguments& bounds_instantiator,
     Error* malformed_error) const {
   ASSERT(FLAG_enable_type_checks);
   ASSERT(IsInstantiated());
   ASSERT(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 = TypeAt(offset + i);
-      if (!bound.IsInstantiated()) {
+      Error& malformed_bound_error = Error::Handle();
+      if (bound.IsMalformed()) {
+        malformed_bound_error = bound.malformed_error();
+      } else if (!bound.IsInstantiated()) {
         bound = bound.InstantiateFrom(bounds_instantiator);
       }
-      if (!type.IsSubtypeOf(bound, malformed_error)) {
+      if (!malformed_bound_error.IsNull() ||
+          !type.IsSubtypeOf(bound, malformed_error)) {
+        // Ignore this bound error if another malformed error was already
+        // reported for this type test.
         if (malformed_error->IsNull()) {
           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());
           // Since the bound was canonicalized, its token index was lost,
           // therefore, use the token index of the corresponding type parameter.
           const TypeArguments& type_parameters =
               TypeArguments::Handle(cls.type_parameters());
           type = type_parameters.TypeAt(i);
-          *malformed_error ^= FormatError(script, type.token_index(),
+          *malformed_error ^= FormatError(malformed_bound_error,
+                                          script, type.token_index(),
                                           "type argument '%s' does not "
                                           "extend bound '%s' of '%s'\n",
                                           type_argument_name.ToCString(),
                                           bound_name.ToCString(),
                                           class_name.ToCString());
         }
         return false;
       }
     }
   }
@@ skipping 6012 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 = result.TestEntryLength();
   // IC data array must be null terminated (sentinel entry).
   const Array& ic_data = Array::Handle(Array::New(len, Heap::kOld));
   result.set_ic_data(ic_data);
   return result.raw();
 }
 
 }  // namespace dart