Merge pull request #3278 from swiftix/optimize-dynamic-self

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

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: }