Disregard Overridden Candidates in Infinite Recursion Check

Disregard candidates that have known override points because those
points are possible targets for dynamic dispatch. This removes a class
of false positives involving classes with known override points in
the module, as is this case in many node-based data structures.

rdar://70410948

Author: CodaFi

lib/SILOptimizer/Mandatory/DiagnoseInfiniteRecursion.cpp

@@ -52,8 +52,11 @@ static bool hasRecursiveCallInPath(SILBasicBlock &Block,
 
     if (FullApplySite FAI = FullApplySite::isa(&I)) {
       // Don't touch dynamic dispatch.
-      if (isa<ObjCMethodInst>(FAI.getCallee()))
+      if (isa<SuperMethodInst>(FAI.getCallee()) ||
+          isa<ObjCSuperMethodInst>(FAI.getCallee()) ||
+          isa<ObjCMethodInst>(FAI.getCallee())) {
         continue;
+      }
 
       auto &M = FAI.getModule();
       if (auto *CMI = dyn_cast<ClassMethodInst>(FAI.getCallee())) {
@@ -71,6 +74,18 @@ static bool hasRecursiveCallInPath(SILBasicBlock &Block,
           continue;
         }
 
+        if (!calleesAreStaticallyKnowable(FAI.getModule(), CMI->getMember())) {
+          continue;
+        }
+
+        // The "statically knowable" check just means that we have all the
+        // callee candidates available for analysis. We still need to check
+        // if the current function has a known override point.
+        auto *method = CMI->getMember().getAbstractFunctionDecl();
+        if (method->isOverridden()) {
+          continue;
+        }
+
         auto *F = getTargetClassMethod(M, CD, CMI);
         if (F == Target)
           return true;

test/SILOptimizer/infinite_recursion.swift

@@ -1,5 +1,5 @@
-// RUN: %target-swift-frontend -emit-sil -primary-file %s -o /dev/null -verify
-// RUN: %target-swift-frontend -emit-sil -primary-file %s -o /dev/null -verify
+// RUN: %target-swift-frontend -emit-sil %s -o /dev/null -verify
+// RUN: %target-swift-frontend -emit-sil %s -o /dev/null -verify
 
 func a() {  // expected-warning {{all paths through this function will call itself}}
   a()
@@ -123,7 +123,7 @@ class S {
     return a()
   }
 
-  func b() { // expected-warning {{all paths through this function will call itself}}
+  func b() { // No warning - has a known override.
     var i = 0
     repeat {
       i += 1
@@ -171,3 +171,14 @@ func factorial(_ n : UInt) -> UInt { // expected-warning {{all paths through thi
 func tr(_ key: String) -> String { // expected-warning {{all paths through this function will call itself}}
   return tr(key) ?? key // expected-warning {{left side of nil coalescing operator '??' has non-optional type}}
 }
+
+class Node {
+  var parent: Node?
+  var rootNode: RootNode {
+    return parent!.rootNode // No warning - has an override.
+  }
+}
+
+class RootNode: Node {
+  override var rootNode: RootNode { return self }
+}