AST: Introduce ClassDecl::isSuperclassOf()

Author: slavapestov

include/swift/AST/Decl.h

@@ -3631,6 +3631,9 @@ class ClassDecl final : public NominalTypeDecl {
   /// is no superclass.
   ClassDecl *getSuperclassDecl() const;
 
+  /// Check if this class is a superclass or equal to the given class.
+  bool isSuperclassOf(ClassDecl *other) const;
+
   /// Set the superclass of this class.
   void setSuperclass(Type superclass);
 

lib/AST/Decl.cpp

@@ -3680,6 +3680,22 @@ AncestryOptions ClassDecl::checkAncestry() const {
   return result;
 }
 
+bool ClassDecl::isSuperclassOf(ClassDecl *other) const {
+  llvm::SmallPtrSet<const ClassDecl *, 8> visited;
+
+  do {
+    if (!visited.insert(other).second)
+      break;
+
+    if (this == other)
+      return true;
+
+    other = other->getSuperclassDecl();
+  } while (other != nullptr);
+
+  return false;
+}
+
 ClassDecl::MetaclassKind ClassDecl::getMetaclassKind() const {
   assert(getASTContext().LangOpts.EnableObjCInterop &&
          "querying metaclass kind without objc interop");
@@ -3773,8 +3789,6 @@ ClassDecl::findImplementingMethod(const AbstractFunctionDecl *Method) const {
       }
     }
     // Check the superclass
-    if (!C->hasSuperclass())
-      break;
     C = C->getSuperclassDecl();
   }
   return nullptr;

lib/AST/Type.cpp

@@ -3110,9 +3110,7 @@ Type TypeBase::getSuperclassForDecl(const ClassDecl *baseClass,
 #ifndef NDEBUG
   auto *currentClass = getConcreteTypeForSuperclassTraversing(this)
       ->getClassOrBoundGenericClass();
-  while (currentClass && currentClass != baseClass)
-    currentClass = currentClass->getSuperclassDecl();
-  assert(currentClass == baseClass &&
+  assert(baseClass->isSuperclassOf(currentClass) &&
          "no inheritance relationship between given classes");
 #endif
 

lib/SIL/DynamicCasts.cpp

@@ -56,14 +56,14 @@ mustBridgeToSwiftValueBox(ModuleDecl *M, CanType T) {
   return !M->getASTContext().getBridgedToObjC(M, T);
 }
 
-static bool canClassOrSuperclassesHaveExtensions(ClassDecl *CD,
-                                                 bool isWholeModuleOpts) {
+static bool canClassOrSuperclassesHaveUnknownSubclasses(ClassDecl *CD,
+                                                      bool isWholeModuleOpts) {
   while (CD) {
-    // Open classes can always be extended
+    // Open classes can always have unknown subclasses.
     if (CD->getEffectiveAccess() == AccessLevel::Open)
       return true;
 
-    // Internal and public classes can be extended, if we are not in
+    // Internal and public classes may have unknown subclasses if we are not in
     // whole-module-optimization mode.
     if (CD->getEffectiveAccess() >= AccessLevel::Internal &&
         !isWholeModuleOpts)
@@ -110,11 +110,9 @@ classifyDynamicCastToProtocol(ModuleDecl *M, CanType source, CanType target,
   }
 
   // If it is a class and it can be proven that this class and its
-  // superclasses cannot be extended, then it is safe to proceed.
-  // No need to check this for structs, as they do not have any
-  // superclasses.
+  // superclasses cannot have unknown subclasses, then it is safe to proceed.
   if (auto *CD = source.getClassOrBoundGenericClass()) {
-    if (canClassOrSuperclassesHaveExtensions(CD, isWholeModuleOpts))
+    if (canClassOrSuperclassesHaveUnknownSubclasses(CD, isWholeModuleOpts))
       return DynamicCastFeasibility::MaySucceed;
     // Derived types may conform to the protocol.
     if (!CD->isFinal()) {
@@ -555,22 +553,13 @@ swift::classifyDynamicCast(ModuleDecl *M,
         if (targetClass->usesObjCGenericsModel()) {
           // If both classes are ObjC generics, the cast may succeed if the
           // classes are related, irrespective of their generic parameters.
-          auto isDeclSuperclass = [&](ClassDecl *proposedSuper,
-                                      ClassDecl *proposedSub) -> bool {
-            do {
-              if (proposedSuper == proposedSub)
-                return true;
-            } while ((proposedSub = proposedSub->getSuperclassDecl()));
-            
-            return false;
-          };
-          
-          if (isDeclSuperclass(sourceClass, targetClass))
+
+          if (sourceClass->isSuperclassOf(targetClass))
             return DynamicCastFeasibility::MaySucceed;
 
-          if (isDeclSuperclass(targetClass, sourceClass)) {
+          if (targetClass->isSuperclassOf(sourceClass))
             return DynamicCastFeasibility::WillSucceed;
-          }          
+
           return DynamicCastFeasibility::WillFail;
         }
       }

lib/SIL/SILVerifier.cpp

@@ -2291,10 +2291,8 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
         ->getInstanceType()->getClassOrBoundGenericClass();
     require(class2,
             "Second operand of dealloc_partial_ref must be a class metatype");
-    while (class1 != class2) {
-      class1 = class1->getSuperclassDecl();
-      require(class1, "First operand not superclass of second instance type");
-    }
+    require(class2->isSuperclassOf(class1),
+            "First operand not superclass of second instance type");
   }
 
   void checkAllocBoxInst(AllocBoxInst *AI) {
@@ -4981,13 +4979,8 @@ void SILVTable::verify(const SILModule &M) const {
     assert(theClass && "vtable entry must refer to a class member");
 
     // The class context must be the vtable's class, or a superclass thereof.
-    auto c = getClass();
-    do {
-      if (c == theClass)
-        break;
-      c = c->getSuperclassDecl();
-    } while (c);
-    assert(c && "vtable entry must refer to a member of the vtable's class");
+    assert(theClass->isSuperclassOf(getClass()) &&
+           "vtable entry must refer to a member of the vtable's class");
 
     // All function vtable entries must be at their natural uncurry level.
     assert(!entry.Method.isCurried && "vtable entry must not be curried");

lib/SILOptimizer/IPO/DeadFunctionElimination.cpp

@@ -255,18 +255,6 @@ class FunctionLivenessComputation {
     makeAlive(WT);
   }
 
-  /// Returns true if \a Derived is the same as \p Base or derived from it.
-  static bool isDerivedOrEqual(ClassDecl *Derived, ClassDecl *Base) {
-    for (;;) {
-      if (Derived == Base)
-        return true;
-      if (!Derived->hasSuperclass())
-        break;
-      Derived = Derived->getSuperclassDecl();
-    }
-    return false;
-  }
-
   /// Returns true if the implementation of method \p FD in class \p ImplCl
   /// may be called when the type of the class_method's operand is \p MethodCl.
   /// Both, \p MethodCl and \p ImplCl, may by null if not known or if it's a
@@ -277,7 +265,7 @@ class FunctionLivenessComputation {
       return true;
 
     // All implementations of derived classes may be called.
-    if (isDerivedOrEqual(ImplCl, MethodCl))
+    if (MethodCl->isSuperclassOf(ImplCl))
       return true;
 
     // Check if the method implementation is the same in a super class, i.e.

lib/Sema/MiscDiagnostics.cpp

@@ -3335,13 +3335,8 @@ class ObjCSelectorWalker : public ASTWalker {
 
       // If the best method was from a subclass of the place where
       // this method was declared, we have a new best.
-      while (auto superclassDecl = bestClassDecl->getSuperclassDecl()) {
-        if (classDecl == superclassDecl) {
-          bestMethod = method;
-          break;
-        }
-
-        bestClassDecl = superclassDecl;
+      if (classDecl->isSuperclassOf(bestClassDecl)) {
+        bestMethod = method;
       }
     }