Change many instance creation errors from compile-time errors to dynamic errors

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 444 matching lines @@
 
   // Verify that the target constructor of the redirection exists.
   target = target_class.LookupConstructor(target_name);
   if (target.IsNull()) {
     target = target_class.LookupFactory(target_name);
   }
   if (target.IsNull()) {
     const String& user_visible_target_name =
         identifier.IsNull() ? target_class_name : target_name;
     // Replace the type with a malformed type and compile a throw when called.
-    FinalizeMalformedType(Error::Handle(),  // No previous error.
-                          cls, type, kCanonicalize,
-                          "class '%s' has no constructor or factory named '%s'",
-                          target_class_name.ToCString(),
-                          user_visible_target_name.ToCString());
+    type = NewFinalizedMalformedType(
+        cls,
+        factory.token_pos(),
+        "class '%s' has no constructor or factory named '%s'",
+        target_class_name.ToCString(),
+        user_visible_target_name.ToCString());
     factory.SetRedirectionType(type);
     ASSERT(factory.RedirectionTarget() == Function::null());
     return;
   }
 
   // Verify that the target is compatible with the redirecting factory.
   if (!target.HasCompatibleParametersWith(factory)) {
-    FinalizeMalformedType(Error::Handle(),  // No previous error.
-                          cls, type, kCanonicalize,
-                          "constructor '%s' has incompatible parameters with "
-                          "redirecting factory '%s'",
-                          String::Handle(target.name()).ToCString(),
-                          String::Handle(factory.name()).ToCString());
+    type = NewFinalizedMalformedType(
+        cls,
+        factory.token_pos(),
+        "constructor '%s' has incompatible parameters with "
+        "redirecting factory '%s'",
+        String::Handle(target.name()).ToCString(),
+        String::Handle(factory.name()).ToCString());
     factory.SetRedirectionType(type);
     ASSERT(factory.RedirectionTarget() == Function::null());
     return;
   }
 
   // Verify that the target is const if the the redirecting factory is const.
   if (factory.is_const() && !target.is_const()) {
     const Script& script = Script::Handle(cls.script());
     ReportError(script, factory.token_pos(),
                 "constructor '%s' must be const as required by redirecting"
@@ skipping 972 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 Error& prev_error,
-                                           const Class& cls,
-                                           const Type& type,
-                                           FinalizationKind finalization,
-                                           const char* format, ...) {
-  va_list args;
-  va_start(args, format);
+// Either report an error or mark the type as malformed.
+void ClassFinalizer::ReportMalformedType(const Error& prev_error,
+                                         const Class& cls,
+                                         const Type& type,
+                                         FinalizationKind finalization,
+                                         const char* format,
+                                         va_list args) {
   LanguageError& error = LanguageError::Handle();
   if (FLAG_enable_type_checks ||
       !type.HasResolvedTypeClass() ||
       (finalization == kCanonicalizeWellFormed) ||
       FLAG_error_on_malformed_type) {
     const Script& script = Script::Handle(cls.script());
     if (prev_error.IsNull()) {
       error ^= Parser::FormatError(
           script, type.token_pos(), "Error", format, args);
     } else {
@@ skipping 20 matching lines @@
     type.set_is_finalized_instantiated();
     // 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());
   }
 }
 
 
+RawType* ClassFinalizer::NewFinalizedMalformedType(const Class& cls,
+                                                   intptr_t type_pos,
+                                                   const char* format, ...) {
+  va_list args;
+  va_start(args, format);
+  const String& no_name = String::Handle(Symbols::Empty());
+  const UnresolvedClass& unresolved_class = UnresolvedClass::Handle(
+      UnresolvedClass::New(LibraryPrefix::Handle(), no_name, type_pos));
+  const Type& type = Type::Handle(
+      Type::New(unresolved_class, TypeArguments::Handle(), type_pos));
+  ReportMalformedType(Error::Handle(), cls, type, kTryResolve, format, args);
+  va_end(args);
+  ASSERT(type.IsMalformed());
+  return type.raw();
+}
+
+
+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);
+  ReportMalformedType(prev_error, cls, type, finalization, format, args);
+  va_end(args);
+}
+
+
 void ClassFinalizer::ReportError(const Error& error) {
   Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 
 void ClassFinalizer::ReportError(const Script& script,
                                  intptr_t token_pos,
                                  const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
       Parser::FormatError(script, token_pos, "Error", format, args));
+  va_end(args);
   ReportError(error);
 }
 
 
 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