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, error_on_malformed_type, false,
+            "Report error for malformed types.");
 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;
 }
 
 
 // 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() {
   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;
   }
+  GrowableObjectArray& class_array = GrowableObjectArray::Handle();
+  class_array = object_store->pending_classes();
+  ASSERT(!class_array.IsNull());
+  if (class_array.Length() == 0) {
+    return true;
+  }
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
-    GrowableObjectArray& class_array = GrowableObjectArray::Handle();
-    class_array = object_store->pending_classes();
-    ASSERT(!class_array.IsNull());
     Class& cls = Class::Handle();
     // First resolve all superclasses.
     for (intptr_t i = 0; i < class_array.Length(); i++) {
       cls ^= class_array.At(i);
       if (FLAG_trace_class_finalization) {
         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 479 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 || FLAG_error_on_malformed_type) {
           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 {
@@ skipping 245 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) {
   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 (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 74 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) {
   ASSERT(visited != NULL);
@@ skipping 150 matching lines @@
 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 (FLAG_enable_type_checks ||
       !type.HasResolvedTypeClass() ||
-      (finalization == kCanonicalizeWellFormed)) {
+      (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 {
       error ^= Parser::FormatErrorWithAppend(
           prev_error, script, type.token_pos(), "Error", format, args);
     }
-    if (finalization == kCanonicalizeWellFormed) {
+    if ((finalization == kCanonicalizeWellFormed) ||
+        FLAG_error_on_malformed_type) {
       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