Always finalize the super class of a class before cloning the super class

runtime/vm/class_finalizer.cc

 // Copyright (c) 2013, 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/code_generator.h"
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
@@ skipping 1480 matching lines @@
                         /* is_native = */ false, cls, field.token_pos()));
           getter.set_result_type(type);
           getter.set_is_debuggable(false);
           getter.set_kernel_function(field.kernel_field());
           cls.AddFunction(getter);
           field.SetStaticValue(Object::sentinel(), true);
         }
       }
     }
   }
-  // Collect interfaces, super interfaces, and super classes of this class.
+  // If we check for bad overrides, collect interfaces, super interfaces, and
+  // super classes of this class.
   GrowableArray<const Class*> interfaces(zone, 4);
-  CollectInterfaces(cls, &interfaces);
-  // Include superclasses in list of interfaces and super interfaces.
-  super_class = cls.SuperClass();
-  while (!super_class.IsNull()) {
-    interfaces.Add(&Class::ZoneHandle(zone, super_class.raw()));
-    CollectInterfaces(super_class, &interfaces);
-    super_class = super_class.SuperClass();
+  if (Isolate::Current()->error_on_bad_override()) {
+    CollectInterfaces(cls, &interfaces);
+    // Include superclasses in list of interfaces and super interfaces.
+    super_class = cls.SuperClass();
+    while (!super_class.IsNull()) {
+      interfaces.Add(&Class::ZoneHandle(zone, super_class.raw()));
+      CollectInterfaces(super_class, &interfaces);
+      super_class = super_class.SuperClass();
+    }
   }
   // Resolve function signatures and check for conflicts in super classes and
   // interfaces.
   array = cls.functions();
   Function& function = Function::Handle(zone);
   Function& overridden_function = Function::Handle(zone);
   const intptr_t num_functions = array.Length();
   Error& error = Error::Handle(zone);
   for (intptr_t i = 0; i < num_functions; i++) {
     function ^= array.At(i);
     FinalizeSignature(cls, function);
     name = function.name();
     // Report signature conflicts only.
     if (Isolate::Current()->error_on_bad_override() && !function.is_static() &&
         !function.IsGenerativeConstructor()) {
       // A constructor cannot override anything.
       for (intptr_t i = 0; i < interfaces.length(); i++) {
-        const Class* super_class = interfaces.At(i);
-        // Finalize superclass since overrides check relies on all members
-        // of the superclass to be finalized.
-        FinalizeClass(*super_class);
-        overridden_function = super_class->LookupDynamicFunction(name);
+        const Class* interface = interfaces.At(i);
+        // All interfaces should have been finalized since override checks
+        // rely on all interface members to be finalized.
+        ASSERT(interface->is_finalized());
+        overridden_function = interface->LookupDynamicFunction(name);
         if (!overridden_function.IsNull() &&
             !function.HasCompatibleParametersWith(overridden_function,
                                                   &error)) {
           const String& class_name = String::Handle(zone, cls.Name());
-          const String& super_cls_name =
-              String::Handle(zone, super_class->Name());
+          const String& interface_name =
+              String::Handle(zone, interface->Name());
           ReportErrors(error, cls, function.token_pos(),
-                       "class '%s' overrides method '%s' of super "
-                       "class '%s' with incompatible parameters",
+                       "class '%s' overrides method '%s' of super class or "
+                       "interface '%s' with incompatible parameters",
                        class_name.ToCString(), name.ToCString(),
-                       super_cls_name.ToCString());
+                       interface_name.ToCString());
         }
       }
     }
     if (function.IsSetterFunction() || function.IsImplicitSetterFunction()) {
       if (function.is_static()) {
         super_class = FindSuperOwnerOfFunction(cls, name);
         if (!super_class.IsNull()) {
           const String& class_name = String::Handle(zone, cls.Name());
           const String& super_cls_name =
               String::Handle(zone, super_class.Name());
@@ skipping 919 matching lines @@
     THR_Print("Finalize %s\n", cls.ToCString());
   }
   if (cls.is_patch()) {
     // The fields and functions of a patch class are copied to the
     // patched class after parsing. There is nothing to finalize.
     ASSERT(Array::Handle(cls.functions()).Length() == 0);
     ASSERT(Array::Handle(cls.fields()).Length() == 0);
     cls.set_is_finalized();
     return;
   }
+  // Ensure super class is finalized.
+  const Class& super = Class::Handle(cls.SuperClass());
+  if (!super.IsNull()) {
+    FinalizeClass(super);
+  }
+  // Ensure interfaces are finalized in case we check for bad overrides.
+  if (Isolate::Current()->error_on_bad_override()) {
+    GrowableArray<const Class*> interfaces(4);
+    CollectInterfaces(cls, &interfaces);
+    for (intptr_t i = 0; i < interfaces.length(); i++) {
+      FinalizeClass(*interfaces.At(i));
+    }
+  }
   if (cls.IsMixinApplication()) {
     // Copy instance methods and fields from the mixin class.
     // This has to happen before the check whether the methods of
     // the class conflict with inherited methods.
     ApplyMixinMembers(cls);
   }
-  // Ensure super class is finalized.
-  const Class& super = Class::Handle(cls.SuperClass());
-  if (!super.IsNull()) {
-    FinalizeClass(super);
-  }
   // Mark as parsed and finalized.
   cls.Finalize();
   // Mixin app alias classes may still lack their forwarding constructor.
   if (cls.is_mixin_app_alias() &&
       (cls.functions() == Object::empty_array().raw())) {
     const GrowableObjectArray& cloned_funcs =
         GrowableObjectArray::Handle(GrowableObjectArray::New());
 
     const Class& mixin_app_class = Class::Handle(cls.SuperClass());
     const Type& mixin_type = Type::Handle(mixin_app_class.mixin());
@@ skipping 876 matching lines @@
   ASSERT(fields_array.Length() == ByteBuffer::NumberOfFields());
   field ^= fields_array.At(0);
   ASSERT(field.Offset() == ByteBuffer::data_offset());
   name ^= field.name();
   expected_name ^= String::New("_data");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
 #endif
 }
 
 }  // namespace dart