[sil-perf-inliner] Allow for inlining of functions using dynamic Self if it is the same Self as used by the caller

It is safe to inline in such cases, because both dynamic Self types refer to the same type.

Author: swiftix

lib/SILOptimizer/Transforms/PerformanceInliner.cpp

@@ -1124,14 +1124,23 @@ SILFunction *SILPerformanceInliner::getEligibleFunction(FullApplySite AI) {
     return nullptr;
   }
 
+  SILFunction *Caller = AI.getFunction();
+
   // We don't support inlining a function that binds dynamic self because we
   // have no mechanism to preserve the original function's local self metadata.
   if (computeMayBindDynamicSelf(Callee)) {
-    return nullptr;
+    // Check if passed Self is the same as the Self of the caller.
+    // In this case, it is safe to inline because both functions
+    // use the same Self.
+    if (AI.hasSelfArgument() && Caller->hasSelfParam()) {
+      auto CalleeSelf = stripCasts(AI.getSelfArgument());
+      auto CallerSelf = Caller->getSelfArgument();
+      if (CalleeSelf != SILValue(CallerSelf))
+        return nullptr;
+    } else
+      return nullptr;
   }
 
-  SILFunction *Caller = AI.getFunction();
-
   // Detect self-recursive calls.
   if (Caller == Callee) {
     return nullptr;

test/SILOptimizer/inline_self.swift

@@ -33,13 +33,31 @@ func callIt(fn: () -> ()) {
   fn()
 }
 
+class BaseZ {
+  final func baseCapturesSelf() -> Self {
+    let fn = { [weak self] in _ = self }
+    callIt(fn: fn)
+    return self
+  }
+}
+
 // Do not inline C.capturesSelf() into main either.
-class Z {
-  func capturesSelf() -> Self {
+class Z : BaseZ {
+  final func capturesSelf() -> Self {
     let fn = { [weak self] in _ = self }
     callIt(fn: fn)
     return self
   }
+
+  // Inline captureSelf into callCaptureSelf,
+  // because their respective Self types refer to the same type.
+  final func callCapturesSelf() -> Self {
+    return capturesSelf()
+  }
+
+  final func callBaseCapturesSelf() -> Self {
+    return baseCapturesSelf()
+  }
 }
 
 _ = Z().capturesSelf()
@@ -49,7 +67,16 @@ _ = Z().capturesSelf()
 // CHECK: [[F:%[0-9]+]] = function_ref @_TZFC11inline_self1C7factory{{.*}} : $@convention(method) (Int, @thick C.Type) -> @owned C
 // CHECK: apply [[F]](%{{.+}}, %{{.+}}) : $@convention(method) (Int, @thick C.Type) -> @owned C
 
-// CHECK: [[Z:%.*]] = alloc_ref $Z
 // CHECK: function_ref inline_self.Z.capturesSelf () -> Self
 // CHECK: [[F:%[0-9]+]] = function_ref @_TFC11inline_self1Z12capturesSelffT_DS0_ : $@convention(method) (@guaranteed Z) -> @owned Z
-// CHECK: apply [[F]]([[Z]]) : $@convention(method) (@guaranteed Z) -> @owned Z
+// CHECK: [[Z:%.*]] = alloc_ref $Z
+// CHECK: apply [[F]]([[Z]]) : $@convention(method) (@guaranteed Z) -> @owned
+// CHECK: return
+
+// CHECK-LABEL: sil hidden @_TFC11inline_self1Z16callCapturesSelffT_DS0_ : $@convention(method)
+// CHECK-NOT: function_ref @_TFC11inline_self1Z12capturesSelffT_DS0_
+// CHECK: }
+
+// CHECK-LABEL: sil hidden @_TFC11inline_self1Z20callBaseCapturesSelffT_DS0_
+// CHECK-NOT: function_ref @_TFC11inline_self5BaseZ16baseCapturesSelffT_DS0_
+// CHECK: }