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

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 509 matching lines @@
 }
 
 
 RawAbstractType* ClassFinalizer::FinalizeType(const Class& cls,
                                               const AbstractType& type,
                                               FinalizationKind finalization) {
   if (type.IsFinalized()) {
     return type.raw();
   }
   ASSERT(type.IsResolved());
+  ASSERT((finalization == kFinalize) || (finalization == kFinalizeWellFormed));
 
   if (FLAG_trace_type_finalization) {
     OS::Print("Finalize type '%s'\n", String::Handle(type.Name()).ToCString());
   }
 
   if (type.IsTypeParameter()) {
     ASSERT(!cls.IsNull());
     TypeParameter& type_parameter = TypeParameter::Handle();
     type_parameter ^= type.raw();
     // The index must reflect the position of this type parameter in the type
@@ skipping 121 matching lines @@
       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.
+        // Note that malformed bounds never result in a compile time error, even
+        // in checked mode. Therefore, overwrite finalization with kFinalize
+        // when finalizing the malformed type.
         FinalizeMalformedType(
             malformed_error,
-            cls, parameterized_type, finalization,
+            cls, parameterized_type, kFinalize,
             "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.
   AbstractType& type = AbstractType::Handle(function.result_type());
   FinalizationKind result_finalization = kFinalize;
   if (function.IsFactory()) {
     // The name of a factory must always be resolved to a class or interface.
     // The parser sets the factory result type to a type with an unresolved
     // class whose name matches the factory name.
     result_finalization = kFinalizeWellFormed;
+    // TODO(regis): Gilad asks if this compile-time error could be relaxed.
+    // The result type of such a factory method would simply be malformed.
   }
   ResolveType(cls, type, result_finalization);
   type = FinalizeType(cls, type, result_finalization);
   function.set_result_type(type);
   // Resolve formal parameter types.
   const intptr_t num_parameters = function.NumberOfParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = function.ParameterTypeAt(i);
     ResolveType(cls, type, kFinalize);
     type = FinalizeType(cls, type, kFinalize);
@@ skipping 44 matching lines @@
 // Resolve and finalize the upper bounds of the type parameters of class cls.
 void ClassFinalizer::ResolveAndFinalizeUpperBounds(const Class& cls) {
   const intptr_t num_type_params = cls.NumTypeParameters();
   AbstractType& bound = AbstractType::Handle();
   const AbstractTypeArguments& bounds =
       AbstractTypeArguments::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()) {
+    if (bound.IsFinalized()) {
       continue;
     }
     ResolveType(cls, bound, kFinalize);
     bound = FinalizeType(cls, bound, kFinalize);
     bounds.SetTypeAt(i, bound);
   }
 }
 
 
 void ClassFinalizer::ResolveAndFinalizeMemberTypes(const Class& cls) {
@@ skipping 435 matching lines @@
       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);
+  } else {
+     // In production mode, replace malformed type with Dynamic type.
+    type.set_type_class(Class::Handle(Object::dynamic_class()));
+    type.set_arguments(AbstractTypeArguments::Handle());
   }
   if (!type.IsFinalized()) {
     type.set_is_finalized();
-    type.Canonicalize();
+    // Do not canonicalize malformed types, since they may not be resolved.
   } 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);
@@ skipping 15 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