Include super type in interface list for cycle detection (issue 4318).

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 120 matching lines @@
     // Collect superclasses that were already finalized before this run of
     // finalization.
     CollectFinalizedSuperClasses(class_array, &added_subclasses_to_cids);
     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 interfaces: %s\n", cls.ToCString());
       }
-      ResolveSuperType(cls);
       GrowableArray<intptr_t> visited_interfaces;
-      ResolveInterfaces(cls, &visited_interfaces);
+      ResolveSuperTypeAndInterfaces(cls, &visited_interfaces);
     }
     // Finalize all classes.
     for (intptr_t i = 0; i < class_array.Length(); i++) {
       cls ^= class_array.At(i);
       FinalizeClass(cls);
     }
     if (FLAG_print_classes) {
       for (intptr_t i = 0; i < class_array.Length(); i++) {
         cls ^= class_array.At(i);
         PrintClassInformation(cls);
@@ skipping 148 matching lines @@
   } else {
     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) {
-  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());
-  // If cls belongs to core lib or to core lib's implementation, restrictions
-  // about allowed interfaces are lifted.
-  if (cls.library() != Library::CoreLibrary()) {
-    // Prevent extending core implementation classes.
-    bool is_error = false;
-    switch (super_class.id()) {
-      case kNumberCid:
-      case kIntegerCid:
-      case kSmiCid:
-      case kMintCid:
-      case kBigintCid:
-      case kDoubleCid:
-      case kOneByteStringCid:
-      case kTwoByteStringCid:
-      case kExternalOneByteStringCid:
-      case kExternalTwoByteStringCid:
-      case kBoolCid:
-      case kArrayCid:
-      case kImmutableArrayCid:
-      case kGrowableObjectArrayCid:
-      case kInt8ArrayCid:
-      case kExternalInt8ArrayCid:
-      case kUint8ArrayCid:
-      case kUint8ClampedArrayCid:
-      case kExternalUint8ArrayCid:
-      case kExternalUint8ClampedArrayCid:
-      case kInt16ArrayCid:
-      case kExternalInt16ArrayCid:
-      case kUint16ArrayCid:
-      case kExternalUint16ArrayCid:
-      case kInt32ArrayCid:
-      case kExternalInt32ArrayCid:
-      case kUint32ArrayCid:
-      case kExternalUint32ArrayCid:
-      case kInt64ArrayCid:
-      case kExternalInt64ArrayCid:
-      case kUint64ArrayCid:
-      case kExternalUint64ArrayCid:
-      case kFloat32ArrayCid:
-      case kExternalFloat32ArrayCid:
-      case kFloat64ArrayCid:
-      case kExternalFloat64ArrayCid:
-      case kDartFunctionCid:
-      case kWeakPropertyCid:
-        is_error = true;
-        break;
-      default: {
-        // Special case: classes for which we don't have a known class id.
-        // TODO(regis): Why isn't comparing to kIntegerCid enough?
-        if (Type::Handle(Type::Double()).type_class() == super_class.raw() ||
-            Type::Handle(Type::IntType()).type_class() == super_class.raw() ||
-            Type::Handle(
-                Type::StringType()).type_class() == super_class.raw()) {
-          is_error = true;
-        }
-        break;
-      }
-    }
-    if (is_error) {
-      const Script& script = Script::Handle(cls.script());
-      ReportError(script, cls.token_pos(),
-                  "'%s' is not allowed to extend '%s'",
-                  String::Handle(cls.Name()).ToCString(),
-                  String::Handle(super_class.Name()).ToCString());
-    }
-  }
-  return;
-}
-
-
 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()) {
       // A redirection cycle is reported as a compile-time error.
@@ skipping 915 matching lines @@
           return false;
         }
       }
     }
   }
   visited->RemoveLast();
   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
+// Recursively walks the graph of explicitly declared super type and
+// interfaces, resolving unresolved super types and interfaces.
+// Reports an error 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) {
+void ClassFinalizer::ResolveSuperTypeAndInterfaces(
+    const Class& cls, GrowableArray<intptr_t>* visited) {
   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());
+      // We have already visited class 'cls'. We found a cycle.
+      const String& class_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());
+                  "cyclic reference found for class '%s'",
+                  class_name.ToCString());
     }
   }
 
-  // If the class/interface has no explicit interfaces, we are done.
+  // If the class/interface has no explicit super class/interfaces, we are done.
+  Type& super_type = Type::Handle(cls.super_type());
   Array& super_interfaces = Array::Handle(cls.interfaces());
-  if (super_interfaces.Length() == 0) {
+  if ((super_type.IsNull() || super_type.IsObjectType()) &&
+      (super_interfaces.Length() == 0)) {
     return;
   }
 
   // If cls belongs to core lib or to core lib's implementation, restrictions
   // about allowed interfaces are lifted.
   const bool cls_belongs_to_core_lib = cls.library() == Library::CoreLibrary();
 
-  // Resolve and check the interfaces of cls.
+  // Resolve and check the super type and interfaces of cls.
   visited->Add(cls_index);
   AbstractType& interface = AbstractType::Handle();
   Class& interface_class = Class::Handle();
+
+  // Resolve super type. Failures lead to a longjmp.
+  ResolveType(cls, super_type, kCanonicalizeWellFormed);
+
+  // If cls belongs to core lib or to core lib's implementation, restrictions
+  interface_class = super_type.type_class();
+  // If cls belongs to core lib or to core lib's implementation, restrictions
+  // about allowed interfaces are lifted.
+  if (!cls_belongs_to_core_lib) {
+    // Prevent extending core implementation classes.
+    bool is_error = false;
+    switch (interface_class.id()) {
+      case kNumberCid:
+      case kIntegerCid:  // Class Integer, not int.
+      case kSmiCid:
+      case kMintCid:
+      case kBigintCid:
+      case kDoubleCid:  // Class Double, not double.
+      case kOneByteStringCid:
+      case kTwoByteStringCid:
+      case kExternalOneByteStringCid:
+      case kExternalTwoByteStringCid:
+      case kBoolCid:
+      case kArrayCid:
+      case kImmutableArrayCid:
+      case kGrowableObjectArrayCid:
+      case kInt8ArrayCid:
+      case kExternalInt8ArrayCid:
+      case kUint8ArrayCid:
+      case kUint8ClampedArrayCid:
+      case kExternalUint8ArrayCid:
+      case kExternalUint8ClampedArrayCid:
+      case kInt16ArrayCid:
+      case kExternalInt16ArrayCid:
+      case kUint16ArrayCid:
+      case kExternalUint16ArrayCid:
+      case kInt32ArrayCid:
+      case kExternalInt32ArrayCid:
+      case kUint32ArrayCid:
+      case kExternalUint32ArrayCid:
+      case kInt64ArrayCid:
+      case kExternalInt64ArrayCid:
+      case kUint64ArrayCid:
+      case kExternalUint64ArrayCid:
+      case kFloat32ArrayCid:
+      case kExternalFloat32ArrayCid:
+      case kFloat64ArrayCid:
+      case kExternalFloat64ArrayCid:
+      case kDartFunctionCid:
+      case kWeakPropertyCid:
+        is_error = true;
+        break;
+      default: {
+        // Special case: classes for which we don't have a known class id.
+        if (super_type.IsDoubleType() ||
+            super_type.IsIntType() ||
+            super_type.IsStringType()) {
+          is_error = true;
+        }
+        break;
+      }
+    }
+    if (is_error) {
+      const Script& script = Script::Handle(cls.script());
+      ReportError(script, cls.token_pos(),
+                  "'%s' is not allowed to extend '%s'",
+                  String::Handle(cls.Name()).ToCString(),
+                  String::Handle(interface_class.Name()).ToCString());
+    }
+  }
+  // Now resolve the super interfaces of the super type.
+  ResolveSuperTypeAndInterfaces(interface_class, visited);
+
+  // Resolve interfaces. Failures lead to a longjmp.
   for (intptr_t i = 0; i < super_interfaces.Length(); i++) {
     interface ^= super_interfaces.At(i);
     ResolveType(cls, interface, kCanonicalizeWellFormed);
     if (interface.IsTypeParameter()) {
       const Script& script = Script::Handle(cls.script());
       ReportError(script, cls.token_pos(),
                   "type parameter '%s' cannot be used as interface",
                   String::Handle(interface.Name()).ToCString());
     }
     interface_class = interface.type_class();
@@ skipping 17 matching lines @@
           interface.IsDynamicType()) {
         const Script& script = Script::Handle(cls.script());
         ReportError(script, cls.token_pos(),
                     "'%s' is not allowed to extend or implement '%s'",
                     String::Handle(cls.Name()).ToCString(),
                     String::Handle(interface_class.Name()).ToCString());
       }
     }
     interface_class.set_is_implemented();
     // Now resolve the super interfaces.
-    ResolveInterfaces(interface_class, visited);
+    ResolveSuperTypeAndInterfaces(interface_class, visited);
   }
   visited->RemoveLast();
 }
 
 
 // A class is marked as constant if it has one constant constructor.
 // A constant class:
 // - may extend only const classes.
 // - has only const instance fields.
 // Note: we must check for cycles before checking for const properties.
@@ skipping 169 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