Make ClassFinalizer indifferent on whether we are generating a snapshot or not.

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"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_classes, false, "Prints details about loaded classes.");
 DEFINE_FLAG(bool, trace_class_finalization, false, "Trace class finalization.");
 DEFINE_FLAG(bool, trace_type_finalization, false, "Trace type finalization.");
-DEFINE_FLAG(bool, verify_implements, false,
-    "Verify that all classes implement their interface.");
 DECLARE_FLAG(bool, enable_type_checks);
 
 
 bool ClassFinalizer::AllClassesFinalized() {
   ObjectStore* object_store = Isolate::Current()->object_store();
   const GrowableObjectArray& classes =
       GrowableObjectArray::Handle(object_store->pending_classes());
   return classes.Length() == 0;
 }
 
 
+bool ClassFinalizer::FinalizeAllClasses() {
+  ClassFinalizer class_finalizer(kNotGeneratingSnapshot);
+  return class_finalizer.FinalizePendingClasses();
+}
+
+
 // Class finalization occurs:
 // a) when bootstrap process completes (VerifyBootstrapClasses).
 // b) after the user classes are loaded (dart_api).
-bool ClassFinalizer::FinalizePendingClasses(bool generating_snapshot) {
+bool ClassFinalizer::FinalizePendingClasses() const {
   bool retval = true;
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ObjectStore* object_store = isolate->object_store();
   const Error& error = Error::Handle(object_store->sticky_error());
   if (!error.IsNull()) {
     return false;
   }
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
@@ skipping 10 matching lines @@
         OS::Print("Resolving super and default: %s\n", cls.ToCString());
       }
       ResolveSuperType(cls);
       if (cls.is_interface()) {
         ResolveFactoryClass(cls);
       }
     }
     // Finalize all classes.
     for (intptr_t i = 0; i < class_array.Length(); i++) {
       cls ^= class_array.At(i);
-      FinalizeClass(cls, generating_snapshot);
+      FinalizeClass(cls);
     }
     if (FLAG_print_classes) {
       for (intptr_t i = 0; i < class_array.Length(); i++) {
         cls ^= class_array.At(i);
         PrintClassInformation(cls);
       }
     }
-    if (FLAG_verify_implements) {
-      for (intptr_t i = 0; i < class_array.Length(); i++) {
-        cls ^= class_array.At(i);
-        if (!cls.is_interface()) {
-          VerifyClassImplements(cls);
-        }
-      }
-    }
     // Clear pending classes array.
     class_array = GrowableObjectArray::New();
     object_store->set_pending_classes(class_array);
   } else {
     retval = false;
   }
   isolate->set_long_jump_base(base);
   return retval;
 }
 
 
 // Adds all interfaces of cls into 'collected'. Duplicate entries may occur.
 // No cycles are allowed.
 void ClassFinalizer::CollectInterfaces(const Class& cls,
                                        const GrowableObjectArray& collected) {
   const Array& interface_array = Array::ZoneHandle(cls.interfaces());
   AbstractType& interface = AbstractType::Handle();
   Class& interface_class = Class::Handle();
   for (intptr_t i = 0; i < interface_array.Length(); i++) {
     interface ^= interface_array.At(i);
     interface_class = interface.type_class();
     collected.Add(interface_class);
     CollectInterfaces(interface_class, collected);
   }
 }
 
 
-#if defined (DEBUG)
-// Collect all interfaces of the class 'cls' and check that every function
-// defined in each interface can be found in the class.
-// No need to check instance fields since they have been turned into
-// getters/setters.
-void ClassFinalizer::VerifyClassImplements(const Class& cls) {
-  ASSERT(!cls.is_interface());
-  const GrowableObjectArray& interfaces =
-      GrowableObjectArray::Handle(GrowableObjectArray::New());
-  CollectInterfaces(cls, interfaces);
-  const String& class_name = String::Handle(cls.Name());
-  Class& interface_class = Class::Handle();
-  String& interface_name = String::Handle();
-  Array& interface_functions = Array::Handle();
-  for (int i = 0; i < interfaces.Length(); i++) {
-    interface_class ^= interfaces.At(i);
-    interface_name = interface_class.Name();
-    interface_functions = interface_class.functions();
-    for (intptr_t f = 0; f < interface_functions.Length(); f++) {
-      Function& interface_function = Function::Handle();
-      interface_function ^= interface_functions.At(f);
-      const String& function_name = String::Handle(interface_function.name());
-      // Check for constructor/factory.
-      if (function_name.StartsWith(interface_name)) {
-        // TODO(srdjan): convert 'InterfaceName.' to 'ClassName.' and check.
-        continue;
-      }
-      if (interface_function.kind() == RawFunction::kConstImplicitGetter) {
-        // This interface constants are not overridable.
-        continue;
-      }
-      // Lookup function in 'cls' and all its super classes.
-      Class& test_class = Class::Handle(cls.raw());
-      Function& class_function =
-          Function::Handle(test_class.LookupDynamicFunction(function_name));
-      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::PrintErr("%s implements '%s' missing: '%s'\n",
-                     class_name.ToCString(),
-                     interface_name.ToCString(),
-                     function_name.ToCString());
-      } else {
-        Error& malformed_error = Error::Handle();
-        if (!class_function.IsSubtypeOf(TypeArguments::Handle(),
-                                        interface_function,
-                                        TypeArguments::Handle(),
-                                        &malformed_error)) {
-          if (!malformed_error.IsNull()) {
-            OS::PrintErr("%s\n", malformed_error.ToErrorCString());
-          }
-          OS::PrintErr("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
-
-
 void ClassFinalizer::VerifyBootstrapClasses() {
   if (FLAG_trace_class_finalization) {
     OS::Print("VerifyBootstrapClasses START.\n");
   }
   ObjectStore* object_store = Isolate::Current()->object_store();
 
   Class& cls = Class::Handle();
 #if defined(DEBUG)
   // Basic checking.
   cls = object_store->object_class();
@@ skipping 74 matching lines @@
   for (intptr_t i = 0; i < class_array.Length(); i++) {
     // TODO(iposva): Add real checks.
     cls ^= class_array.At(i);
     if (cls.is_finalized() || cls.is_prefinalized()) {
       // Pre-finalized bootstrap classes must not define any fields.
       ASSERT(!cls.HasInstanceFields());
     }
   }
 
   // Finalize classes that aren't pre-finalized by Object::Init().
-  if (!FinalizePendingClasses()) {
+  ClassFinalizer class_finalizer(kGeneratingSnapshot);
+  if (!class_finalizer.FinalizePendingClasses()) {
     // TODO(srdjan): Exit like a real VM instead.
     const Error& err = Error::Handle(object_store->sticky_error());
     OS::PrintErr("Could not verify bootstrap classes : %s\n",
                  err.ToErrorCString());
     OS::Exit(255);
   }
   if (FLAG_trace_class_finalization) {
     OS::Print("VerifyBootstrapClasses END.\n");
   }
   Isolate::Current()->heap()->Verify();
@@ skipping 14 matching lines @@
     LibraryPrefix& lib_prefix = LibraryPrefix::Handle();
     lib_prefix = unresolved_class.library_prefix();
     ASSERT(!lib_prefix.IsNull());
     resolved_class = lib_prefix.LookupLocalClass(class_name);
   }
   return resolved_class.raw();
 }
 
 
 // Resolve unresolved supertype (String -> Class).
-void ClassFinalizer::ResolveSuperType(const Class& cls) {
+void ClassFinalizer::ResolveSuperType(const Class& cls) const {
   if (cls.is_finalized()) {
     return;
   }
   Type& super_type = Type::Handle(cls.super_type());
   if (super_type.IsNull()) {
     return;
   }
   // Resolve failures lead to a longjmp.
   ResolveType(cls, super_type, kCanonicalizeWellFormed);
   const Class& super_class = Class::Handle(super_type.type_class());
@@ skipping 138 matching lines @@
                 "mismatch in number or names of type parameters between "
                 "interface '%s' and default factory class '%s'",
                 interface_name.ToCString(),
                 factory_name.ToCString());
   }
 }
 
 
 void ClassFinalizer::ResolveType(const Class& cls,
                                  const AbstractType& type,
-                                 FinalizationKind finalization) {
+                                 FinalizationKind finalization) const {
   if (type.IsResolved() || type.IsFinalized()) {
     return;
   }
   if (FLAG_trace_type_finalization) {
     OS::Print("Resolve type '%s'\n", String::Handle(type.Name()).ToCString());
   }
 
   // Resolve the type class.
   if (!type.HasResolvedTypeClass()) {
     // Type parameters are always resolved in the parser in the correct
@@ skipping 30 matching lines @@
     intptr_t num_arguments = arguments.Length();
     AbstractType& type_argument = AbstractType::Handle();
     for (intptr_t i = 0; i < num_arguments; i++) {
       type_argument = arguments.TypeAt(i);
       ResolveType(cls, type_argument, finalization);
     }
   }
 }
 
 
-void ClassFinalizer::FinalizeTypeParameters(const Class& cls) {
+void ClassFinalizer::FinalizeTypeParameters(const Class& cls) const {
   const TypeArguments& type_parameters =
       TypeArguments::Handle(cls.type_parameters());
   if (!type_parameters.IsNull()) {
     TypeParameter& type_parameter = TypeParameter::Handle();
     const intptr_t num_types = type_parameters.Length();
     for (intptr_t i = 0; i < num_types; i++) {
       type_parameter ^= type_parameters.TypeAt(i);
       type_parameter ^= FinalizeType(cls,
                                      type_parameter,
                                      kCanonicalizeWellFormed);
@@ skipping 13 matching lines @@
 // Example:
 //   Declared: class C<K, V> extends B<V> { ... }
 //             class B<T> extends A<int> { ... }
 //   Input:    C<String, double> expressed as
 //             cls = C, arguments = [null, null, String, double],
 //             i.e. cls_args = [String, double], offset = 2, length = 2.
 //   Output:   arguments = [int, double, String, double]
 void ClassFinalizer::FinalizeTypeArguments(
     const Class& cls,
     const AbstractTypeArguments& arguments,
-    FinalizationKind finalization) {
+    FinalizationKind finalization) const {
   ASSERT(arguments.Length() >= cls.NumTypeArguments());
   if (!cls.is_finalized()) {
     GrowableArray<intptr_t> visited_interfaces;
     ResolveInterfaces(cls, &visited_interfaces);
     FinalizeTypeParameters(cls);
   }
   Type& super_type = Type::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     const Class& super_class = Class::Handle(super_type.type_class());
     AbstractTypeArguments& super_type_args = AbstractTypeArguments::Handle();
@@ skipping 33 matching lines @@
           super_type_arg = super_type_arg.Canonicalize();
         }
       }
       arguments.SetTypeAt(super_offset + i, super_type_arg);
     }
     FinalizeTypeArguments(super_class, arguments, finalization);
   }
 }
 
 
-RawAbstractType* ClassFinalizer::FinalizeType(const Class& cls,
-                                              const AbstractType& type,
-                                              FinalizationKind finalization) {
+RawAbstractType* ClassFinalizer::FinalizeType(
+    const Class& cls,
+    const AbstractType& type,
+    FinalizationKind finalization) const {
   if (type.IsFinalized()) {
     return type.raw();
   }
   ASSERT(type.IsResolved());
   ASSERT(finalization >= kFinalize);
 
   if (FLAG_trace_type_finalization) {
     OS::Print("Finalize type '%s'\n", String::Handle(type.Name()).ToCString());
   }
 
@@ skipping 49 matching lines @@
       AbstractTypeArguments::Handle(parameterized_type.arguments());
   if (!arguments.IsNull()) {
     intptr_t num_arguments = arguments.Length();
     AbstractType& type_argument = AbstractType::Handle();
     for (intptr_t i = 0; i < num_arguments; i++) {
       type_argument = arguments.TypeAt(i);
       type_argument = FinalizeType(cls, type_argument, finalization);
       if (type_argument.IsMalformed()) {
         // In production mode, malformed type arguments are mapped to Dynamic.
         // In checked mode, a type with malformed type arguments is malformed.
-        if (FLAG_enable_type_checks) {
+        if (FLAG_enable_type_checks || generating_snapshot_) {
           const Error& error = Error::Handle(type_argument.malformed_error());
           const String& type_name =
               String::Handle(parameterized_type.UserVisibleName());
           FinalizeMalformedType(error, cls, parameterized_type, finalization,
                                 "type '%s' has malformed type argument",
                                 type_name.ToCString());
           return parameterized_type.raw();
         } else {
           type_argument = Type::DynamicType();
         }
@@ skipping 114 matching lines @@
     if (type_class.IsCanonicalSignatureClass()) {
       ASSERT(type_class.is_finalized());
       // Resolve and finalize the result and parameter types of the signature
       // function of this signature class.
       ASSERT(type_class.SignatureType() == type.raw());
       ResolveAndFinalizeSignature(
           type_class, Function::Handle(type_class.signature_function()));
     } else {
       // This type is a function type alias. Its class may need to be finalized
       // and checked for illegal self reference.
-      FinalizeClass(type_class, false);
+      FinalizeClass(type_class);
       // Finalizing the signature function here (as in the canonical case above)
       // would not mark the canonical signature type as finalized.
       const Type& signature_type = Type::Handle(type_class.SignatureType());
       FinalizeType(cls, signature_type, finalization);
     }
   }
 
   if (finalization >= kCanonicalize) {
     return parameterized_type.Canonicalize();
   } else {
     return parameterized_type.raw();
   }
 }
 
 
-void ClassFinalizer::ResolveAndFinalizeSignature(const Class& cls,
-                                                 const Function& function) {
+void ClassFinalizer::ResolveAndFinalizeSignature(
+    const Class& cls,
+    const Function& function) const {
   // Resolve result type.
   AbstractType& type = AbstractType::Handle(function.result_type());
   // In case of a factory, the parser sets the factory result type to a type
   // with an unresolved class whose name matches the factory name.
   // It is not a compile time error if this name does not resolve to a class or
   // interface.
   ResolveType(cls, type, kCanonicalize);
   type = FinalizeType(cls, type, kCanonicalize);
   // In production mode, a malformed result type is mapped to Dynamic.
   if (!FLAG_enable_type_checks && type.IsMalformed()) {
@@ skipping 48 matching lines @@
     if (!function.IsNull()) {
       return super_class.raw();
     }
     super_class = super_class.SuperClass();
   }
   return Class::null();
 }
 
 
 // Resolve and finalize the upper bounds of the type parameters of class cls.
-void ClassFinalizer::ResolveAndFinalizeUpperBounds(const Class& cls) {
+void ClassFinalizer::ResolveAndFinalizeUpperBounds(const Class& cls) const {
   const intptr_t num_type_params = cls.NumTypeParameters();
   TypeParameter& type_param = TypeParameter::Handle();
   AbstractType& bound = AbstractType::Handle();
   const AbstractTypeArguments& type_params =
       AbstractTypeArguments::Handle(cls.type_parameters());
   ASSERT((type_params.IsNull() && (num_type_params == 0)) ||
          (type_params.Length() == num_type_params));
   for (intptr_t i = 0; i < num_type_params; i++) {
     type_param ^= type_params.TypeAt(i);
     bound = type_param.bound();
     if (bound.IsFinalized()) {
       continue;
     }
     ResolveType(cls, bound, kCanonicalize);
     bound = FinalizeType(cls, bound, kCanonicalize);
     type_param.set_bound(bound);
   }
 }
 
 
-void ClassFinalizer::ResolveAndFinalizeMemberTypes(const Class& cls) {
+void ClassFinalizer::ResolveAndFinalizeMemberTypes(const Class& cls) const {
   // Note that getters and setters are explicitly listed as such in the list of
   // functions of a class, so we do not need to consider fields as implicitly
   // generating getters and setters.
   // The only compile errors we report are therefore:
   // - a getter having the same name as a method (but not a getter) in a super
   //   class or in a subclass.
   // - a setter having the same name as a method (but not a setter) in a super
   //   class or in a subclass.
   // - a static field, instance field, or static method (but not an instance
   //   method) having the same name as an instance member in a super class.
@@ skipping 138 matching lines @@
                     function_name.ToCString(),
                     class_name.ToCString(),
                     function_name.ToCString(),
                     super_class_name.ToCString());
       }
     }
   }
 }
 
 
-void ClassFinalizer::FinalizeClass(const Class& cls, bool generating_snapshot) {
+void ClassFinalizer::FinalizeClass(const Class& cls) const {
   if (cls.is_finalized()) {
     return;
   }
   if (FLAG_trace_class_finalization) {
     OS::Print("Finalize %s\n", cls.ToCString());
   }
   if (!IsSuperCycleFree(cls)) {
     const String& name = String::Handle(cls.Name());
     const Script& script = Script::Handle(cls.script());
     ReportError(script, cls.token_pos(),
                 "class '%s' has a cycle in its superclass relationship",
                 name.ToCString());
   }
   GrowableArray<intptr_t> visited_interfaces;
   ResolveInterfaces(cls, &visited_interfaces);
   // Finalize super class.
   const Class& super_class = Class::Handle(cls.SuperClass());
   if (!super_class.IsNull()) {
-    FinalizeClass(super_class, generating_snapshot);
+    FinalizeClass(super_class);
   }
   // Finalize type parameters before finalizing the super type.
   FinalizeTypeParameters(cls);
   // Finalize super type.
   Type& super_type = Type::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     super_type ^= FinalizeType(cls, super_type, kCanonicalizeWellFormed);
     cls.set_super_type(super_type);
   }
   // Signature classes are finalized upon creation, except function type
@@ skipping 13 matching lines @@
     // Signature classes extend Object. No need to add this class to the direct
     // subclasses of Object.
     ASSERT(super_type.IsNull() || super_type.IsObjectType());
     return;
   }
   // Finalize factory class, if any.
   if (cls.is_interface()) {
     if (cls.HasFactoryClass()) {
       const Class& factory_class = Class::Handle(cls.FactoryClass());
       if (!factory_class.is_finalized()) {
-        FinalizeClass(factory_class, generating_snapshot);
+        FinalizeClass(factory_class);
         // Finalizing the factory class may indirectly finalize this interface.
         if (cls.is_finalized()) {
           return;
         }
       }
     }
   }
   // Finalize interface types (but not necessarily interface classes).
   Array& interface_types = Array::Handle(cls.interfaces());
   AbstractType& interface_type = AbstractType::Handle();
   for (intptr_t i = 0; i < interface_types.Length(); i++) {
     interface_type ^= interface_types.At(i);
     interface_type = FinalizeType(cls, interface_type, kCanonicalizeWellFormed);
     interface_types.SetAt(i, interface_type);
   }
   // Mark as finalized before resolving type parameter upper bounds and member
   // types in order to break cycles.
   cls.Finalize();
   ResolveAndFinalizeUpperBounds(cls);
   ResolveAndFinalizeMemberTypes(cls);
   // Run additional checks after all types are finalized.
   if (cls.is_const()) {
     CheckForLegalConstClass(cls);
   }
   // Check to ensure we don't have classes with native fields in libraries
   // which do not have a native resolver.
-  if (!generating_snapshot && cls.num_native_fields() != 0) {
+  if (!generating_snapshot_ && cls.num_native_fields() != 0) {
     const Library& lib = Library::Handle(cls.library());
     if (lib.native_entry_resolver() == NULL) {
       const String& cls_name = String::Handle(cls.Name());
       const String& lib_name = String::Handle(lib.url());
       const Script& script = Script::Handle(cls.script());
       ReportError(script, cls.token_pos(),
                   "class '%s' is trying to extend a native fields class, "
                   "but library '%s' has no native resolvers",
                   cls_name.ToCString(), lib_name.ToCString());
     }
@@ skipping 24 matching lines @@
       test2 = test2.SuperClass();
     }
   }
   // No cycles.
   return true;
 }
 
 
 // Returns false if the function type alias illegally refers to itself.
 bool ClassFinalizer::IsAliasCycleFree(const Class& cls,
-                                      GrowableArray<intptr_t>* visited) {
+                                      GrowableArray<intptr_t>* visited) const {
   ASSERT(cls.IsSignatureClass());
   ASSERT(!cls.IsCanonicalSignatureClass());
   ASSERT(!cls.is_finalized());
   ASSERT(visited != NULL);
   const intptr_t cls_index = cls.id();
   for (int i = 0; i < visited->length(); i++) {
     if ((*visited)[i] == cls_index) {
       // We have already visited alias 'cls'. We found a cycle.
       return false;
     }
@@ skipping 29 matching lines @@
           return false;
         }
       }
     }
   }
   visited->RemoveLast();
   return true;
 }
 
 
-bool ClassFinalizer::AddInterfaceIfUnique(
-    const GrowableObjectArray& interface_list,
-    const AbstractType& interface,
-    AbstractType* conflicting) {
-  String& interface_class_name = String::Handle(interface.ClassName());
-  String& existing_interface_class_name = String::Handle();
-  String& interface_name = String::Handle();
-  String& existing_interface_name = String::Handle();
-  AbstractType& other_interface = AbstractType::Handle();
-  for (intptr_t i = 0; i < interface_list.Length(); i++) {
-    other_interface ^= interface_list.At(i);
-    existing_interface_class_name = other_interface.ClassName();
-    if (interface_class_name.Equals(existing_interface_class_name)) {
-      // Same interface class name, now check names of type arguments.
-      interface_name = interface.Name();
-      existing_interface_name = other_interface.Name();
-      // TODO(regis): Revisit depending on the outcome of issue 4905685.
-      if (!interface_name.Equals(existing_interface_name)) {
-        *conflicting = other_interface.raw();
-        return false;
-      } else {
-        return true;
-      }
-    }
-  }
-  interface_list.Add(interface);
-  return true;
-}
-
-
 // Walks the graph of explicitly declared interfaces of classes and
 // interfaces recursively. Resolves unresolved interfaces.
 // Returns false if there is an interface reference that cannot be
 // resolved, or if there is a cycle in the graph. We detect cycles by
 // remembering interfaces we've visited in each path through the
 // graph. If we visit an interface a second time on a given path,
 // we found a loop.
 void ClassFinalizer::ResolveInterfaces(const Class& cls,
-                                       GrowableArray<intptr_t>* visited) {
+                                       GrowableArray<intptr_t>* visited) const {
   ASSERT(visited != NULL);
   const intptr_t cls_index = cls.id();
   for (int i = 0; i < visited->length(); i++) {
     if ((*visited)[i] == cls_index) {
       // We have already visited interface class 'cls'. We found a cycle.
       const String& interface_name = String::Handle(cls.Name());
       const Script& script = Script::Handle(cls.script());
       ReportError(script, cls.token_pos(),
                   "cyclic reference found for interface '%s'",
                   interface_name.ToCString());
@@ skipping 135 matching lines @@
     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, ...) {
+                                           const char* format, ...) const {
   va_list args;
   va_start(args, format);
   LanguageError& error = LanguageError::Handle();
   if (FLAG_enable_type_checks ||
       !type.HasResolvedTypeClass() ||
-      (finalization == kCanonicalizeWellFormed)) {
+      (finalization == kCanonicalizeWellFormed) ||
+      generating_snapshot_) {
     const Script& script = Script::Handle(cls.script());
     if (prev_error.IsNull()) {
       error ^= Parser::FormatError(
           script, type.token_pos(), "Error", format, args);
     } else {
       error ^= Parser::FormatErrorWithAppend(
           prev_error, script, type.token_pos(), "Error", format, args);
     }
-    if (finalization == kCanonicalizeWellFormed) {
+    if ((finalization == kCanonicalizeWellFormed) || generating_snapshot_) {
       ReportError(error);
     }
   }
   if (FLAG_enable_type_checks || !type.HasResolvedTypeClass()) {
     // In check mode, always mark the type as malformed.
     // In production mode, mark the type as malformed only if its type class is
     // not resolved.
     type.set_malformed_error(error);
   } else {
      // In production mode, do not mark the type with a resolved type class as
@@ skipping 32 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