Fix snapshot reading of canonicalized types.

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 391 matching lines @@
 
 void ClassFinalizer::ResolveRedirectingFactoryTarget(
     const Class& cls,
     const Function& factory,
     const GrowableObjectArray& visited_factories) {
   ASSERT(factory.IsRedirectingFactory());
 
   // Check for redirection cycle.
   for (int i = 0; i < visited_factories.Length(); i++) {
     if (visited_factories.At(i) == factory.raw()) {
-      // TODO(regis): Throw or report error?
+      // A redirection cycle is reported as a compile-time error.
       const Script& script = Script::Handle(cls.script());
       ReportError(script, factory.token_pos(),
                   "factory '%s' illegally redirects to itself",
                   String::Handle(factory.name()).ToCString());
     }
   }
   visited_factories.Add(factory);
 
   // Check if target is already resolved.
   Type& type = Type::Handle(factory.RedirectionType());
@@ skipping 10 matching lines @@
 
   // Target is not resolved yet.
   if (FLAG_trace_class_finalization) {
     OS::Print("Resolving redirecting factory: %s\n",
               String::Handle(factory.name()).ToCString());
   }
   ResolveType(cls, type, kCanonicalize);
   type ^= FinalizeType(cls, type, kCanonicalize);
   factory.SetRedirectionType(type);
   if (type.IsMalformed()) {
-    ASSERT(target.IsNull());
-    factory.SetRedirectionTarget(target);
+    ASSERT(factory.RedirectionTarget() == Function::null());
     return;
   }
   const Class& target_class = Class::Handle(type.type_class());
   String& target_class_name = String::Handle(target_class.Name());
   const String& period = String::Handle(Symbols::Dot());
   String& target_name = String::Handle(
       String::Concat(target_class_name, period));
   const String& identifier = String::Handle(factory.RedirectionIdentifier());
   if (!identifier.IsNull()) {
     target_name = String::Concat(target_name, identifier);
   }
 
   // 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;
-    const Script& script = Script::Handle(cls.script());
-    // TODO(regis): Instead of reporting an error, should we replace the type
-    // with a malformed type and compile a throw? We should then also do it
-    // below for incompatible signatures. Wait for spec to stabilize.
-    ReportError(script, factory.token_pos(),
-                "class '%s' has no constructor or factory named '%s'",
-                target_class_name.ToCString(),
-                user_visible_target_name.ToCString());
+    // 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());
+    factory.SetRedirectionType(type);
+    ASSERT(factory.RedirectionTarget() == Function::null());
+    return;
   }
 
   // Verify that the target is compatible with the redirecting factory.
   if (!target.HasCompatibleParametersWith(factory)) {
-    const Script& script = Script::Handle(cls.script());
-    ReportError(script, factory.token_pos(),
-                "constructor '%s' has incompatible parameters with redirecting "
-                "factory '%s'",
-                String::Handle(target.name()).ToCString(),
-                String::Handle(factory.name()).ToCString());
+    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());
+    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"
                 "const factory '%s'",
                 String::Handle(target.name()).ToCString(),
                 String::Handle(factory.name()).ToCString());
   }
 
   // Update redirection data with resolved target.
   factory.SetRedirectionTarget(target);
   factory.SetRedirectionIdentifier(String::Handle());  // Not needed anymore.
   if (!target.IsRedirectingFactory()) {
     return;
   }
 
   // The target is itself a redirecting factory. Recursively resolve its own
   // target and update the current redirection data to point to the end target
   // of the redirection chain.
   ResolveRedirectingFactoryTarget(target_class, target, visited_factories);
   Type& target_type = Type::Handle(target.RedirectionType());
-  const Function& target_target = Function::Handle(target.RedirectionTarget());
+  Function& target_target = Function::Handle(target.RedirectionTarget());
   if (target_target.IsNull()) {
     ASSERT(target_type.IsMalformed());
   } else {
+    // If the target type refers to type parameters, substitute them with the
+    // type arguments of the redirection type.
     if (!target_type.IsInstantiated()) {
       const AbstractTypeArguments& type_args = AbstractTypeArguments::Handle(
           type.arguments());
       target_type ^= target_type.InstantiateFrom(type_args);
-      // TODO(regis): Do we need to check bounds?
+      // TODO(regis): Check bounds in checked mode.
       target_type ^= FinalizeType(cls, target_type, kCanonicalize);
+      if (target_type.IsMalformed()) {
+        target_target = Function::null();
+      }
     }
   }
   factory.SetRedirectionType(target_type);
   factory.SetRedirectionTarget(target_target);
 }
 
 
 void ClassFinalizer::ResolveType(const Class& cls,
                                  const AbstractType& type,
                                  FinalizationKind finalization) {
@@ skipping 1005 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