Generate dynamic type errors according to spec.

runtime/vm/class_finalizer.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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 148 matching lines @@
       while (class_function.IsNull()) {
         test_class = test_class.SuperClass();
         if (test_class.IsNull()) break;
         class_function = test_class.LookupDynamicFunction(function_name);
       }
       if (class_function.IsNull()) {
         OS::Print("%s implements '%s' missing: '%s'\n",
             class_name.ToCString(),
             interface_name.ToCString(),
             function_name.ToCString());
-      } else if (!class_function.IsSubtypeOf(TypeArguments::Handle(),
+      } else {
+        Error& malformed_error = Error::Handle();
+        if (!class_function.IsSubtypeOf(TypeArguments::Handle(),
                                              interface_function,
-                                             TypeArguments::Handle())) {
-        OS::Print("The type of instance method '%s' in class '%s' is not a "
-                  "subtype of the type of '%s' in interface '%s'\n",
-                  function_name.ToCString(),
-                  class_name.ToCString(),
-                  function_name.ToCString(),
-                  interface_name.ToCString());
+                                             TypeArguments::Handle(),
+                                             &malformed_error)) {
+          if (!malformed_error.IsNull()) {
+            OS::Print("%s\n", malformed_error.ToErrorCString());

[srdjan, 2012/03/07 00:41:23]

Shouldn't this be going to PrintErr?

[regis, 2012/03/07 02:22:38]

Done.

+          }
+          OS::Print("The type of instance method '%s' in class '%s' is not a "
+                    "subtype of the type of '%s' in interface '%s'\n",
+                    function_name.ToCString(),
+                    class_name.ToCString(),
+                    function_name.ToCString(),
+                    interface_name.ToCString());
+        }
       }
     }
   }
 }
 #else
 
 void ClassFinalizer::VerifyClassImplements(const Class& cls) {}
 
 #endif
 
@@ skipping 258 matching lines @@
         Class::Handle(ResolveClass(cls, unresolved_class));
 
     // Replace unresolved class with resolved type class.
     ASSERT(type.IsType());
     Type& parameterized_type = Type::Handle();
     parameterized_type ^= type.raw();
     if (!type_class.IsNull()) {
       parameterized_type.set_type_class(Object::Handle(type_class.raw()));
     } else {
       // The type class could not be resolved. The type is malformed.
-      FinalizeMalformedType(cls, parameterized_type, finalization,
+      FinalizeMalformedType(Error::Handle(),  // No previous error.
+                            cls, parameterized_type, finalization,
                             "cannot resolve class name '%s' from '%s'",
                             String::Handle(unresolved_class.Name()).ToCString(),
                             String::Handle(cls.Name()).ToCString());
       return;
     }
   }
 
   // Resolve type arguments, if any.
   const AbstractTypeArguments& arguments =
       AbstractTypeArguments::Handle(type.arguments());
@@ skipping 79 matching lines @@
     return type_parameter.raw();
   }
 
   // At this point, we can only have a parameterized_type.
   Type& parameterized_type = Type::Handle();
   parameterized_type ^= type.raw();
 
   if (parameterized_type.IsBeingFinalized()) {
     // Self reference detected. The type is malformed.
     FinalizeMalformedType(
+        Error::Handle(),  // No previous error.
         cls, parameterized_type, finalization,
         "type '%s' illegally refers to itself",
         String::Handle(parameterized_type.Name()).ToCString());
     return parameterized_type.raw();
   }
 
   // Mark type as being finalized in order to detect illegal self reference.
   parameterized_type.set_is_being_finalized();
 
   // Finalize the current type arguments of the type, which are still the
@@ skipping 39 matching lines @@
   // The type class has num_type_parameters type parameters.
   const intptr_t num_type_parameters = type_class.NumTypeParameters();
 
   // Initialize the type argument vector.
   // Check the number of parsed type arguments, if any.
   // Specifying no type arguments indicates a raw type, which is not an error.
   // However, type parameter bounds are checked below, even for a raw type.
   if (!arguments.IsNull() && (arguments.Length() != num_type_parameters)) {
     // Wrong number of type arguments. The type is malformed.
     FinalizeMalformedType(
+        Error::Handle(),  // No previous error.
         cls, parameterized_type, finalization,
         "wrong number of type arguments in type '%s'",
         String::Handle(parameterized_type.Name()).ToCString());
     return parameterized_type.raw();
   }
   // The full type argument vector consists of the type arguments of the
   // super types of type_class, which may be initialized from the parsed
   // type arguments, followed by the parsed type arguments.
   if (num_type_arguments > 0) {
     TypeArguments& full_arguments = TypeArguments::Handle(
@@ skipping 20 matching lines @@
       FinalizeTypeArguments(type_class, full_arguments, finalization);
     }
     // FinalizeTypeArguments can modify 'full_arguments',
     // canonicalize afterwards.
     full_arguments ^= full_arguments.Canonicalize();
     parameterized_type.set_arguments(full_arguments);
 
     // Mark the type as finalized.
     parameterized_type.set_is_finalized();
 
-    // 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.
+    // Upper bounds of the finalized type arguments are only verified in checked
+    // mode, since bound errors are never reported by the vm in production mode.
+    if (FLAG_enable_type_checks && full_arguments.IsInstantiated()) {
+      ResolveAndFinalizeUpperBounds(type_class);
+      Error& malformed_error = Error::Handle();
+      // Pass the full type argument vector as the bounds instantiator.
+      if (!full_arguments.IsWithinBoundsOf(type_class,
+                                           full_arguments,
+                                           &malformed_error)) {
+        ASSERT(!malformed_error.IsNull());
+        // The type argument vector of the type is not within bounds. The type
+        // is malformed. Prepend malformed_error to new malformed type error in
+        // order to report both locations.
+        FinalizeMalformedType(
+            malformed_error,
+            cls, parameterized_type, finalization,
+            "type arguments of type '%s' are not within bounds",
+            String::Handle(parameterized_type.Name()).ToCString());
+        return parameterized_type.raw();
+      }
+    }
   } else {
     parameterized_type.set_is_finalized();
   }
   return parameterized_type.Canonicalize();
 }
 
 
 void ClassFinalizer::ResolveAndFinalizeSignature(const Class& cls,
                                                  const Function& function) {
   // Resolve result type.
@@ skipping 499 matching lines @@
   const Array& fields_array = Array::Handle(cls.fields());
   Field& field = Field::Handle();
   len = fields_array.Length();
   for (intptr_t i = 0; i < len; i++) {
     field ^= fields_array.At(i);
     OS::Print("  %s\n", field.ToCString());
   }
 }
 
 
-void ClassFinalizer::FinalizeMalformedType(const Class& cls,
+void ClassFinalizer::FinalizeMalformedType(const Error& prev_error,
+                                           const Class& cls,
                                            const Type& type,
                                            FinalizationKind finalization,
                                            const char* format, ...) {
   va_list args;
   va_start(args, format);
   LanguageError& error = LanguageError::Handle();
   if ((finalization == kFinalizeWellFormed) || FLAG_enable_type_checks) {
     const Script& script = Script::Handle(cls.script());
-    error ^=
-        Parser::FormatError(script, type.token_index(), "Error", format, args);
+    if (prev_error.IsNull()) {
+      error ^= Parser::FormatError(
+          script, type.token_index(), "Error", format, args);
+    } else {
+      error ^= Parser::FormatErrorWithAppend(
+          prev_error, script, type.token_index(), "Error", format, args);
+    }
     if (finalization == kFinalizeWellFormed) {
       ReportError(error);
     }
   }
   // Replace malformed type with Dynamic type.
   type.set_type_class(Class::Handle(Object::dynamic_class()));
   type.set_arguments(AbstractTypeArguments::Handle());
   if (FLAG_enable_type_checks) {
     // In checked mode, mark type as malformed.
     type.set_malformed_error(error);
   }
-  type.set_is_finalized();
-  type.Canonicalize();
+  if (!type.IsFinalized()) {
+    type.set_is_finalized();
+    type.Canonicalize();
+  } else {
+    // The only case where the malformed type was already finalized is when its
+    // type arguments are not within bounds. In that case, we have a prev_error.
+    ASSERT(!prev_error.IsNull());
+  }
 }
 
 
 void ClassFinalizer::ReportError(const Error& error) {
   Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 
 void ClassFinalizer::ReportError(const Script& script,
@@ skipping 10 matching lines @@
 void ClassFinalizer::ReportError(const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
       Parser::FormatError(Script::Handle(), -1, "Error", format, args));
   va_end(args);
   ReportError(error);
 }
 
 }  // namespace dart