[SILInliner] Only lifetime args with ownership.

Previously, after swiftlang#39712, lexical
lifetimes were added for arguments whose parameter convention was
guaranteed.  Those lexical borrow scopes were added regardless of the
ownership of the values which were passed as those arguments.  Here, the
lifetimes are only added for argument values which have ownership.

Author: nate-chandler

lib/SILOptimizer/Utils/SILInliner.cpp

@@ -601,9 +601,18 @@ SILValue SILInlineCloner::borrowFunctionArgument(SILValue callArg,
                                     ->getModule()
                                     .getASTContext()
                                     .SILOpts.EnableExperimentalLexicalLifetimes;
-  if (!AI.getFunction()->hasOwnership() ||
-      (callArg.getOwnershipKind() != OwnershipKind::Owned &&
-       !enableLexicalLifetimes)) {
+  auto argOwnershipRequiresBorrow = [&]() {
+    auto kind = callArg.getOwnershipKind();
+    if (enableLexicalLifetimes) {
+      // At this point, we know that the function argument is @guaranteed.
+      // If the value passed as that parameter has ownership, always add a
+      // lexical borrow scope to ensure that the value stays alive for the
+      // duration of the inlined callee.
+      return kind != OwnershipKind::None;
+    }
+    return kind == OwnershipKind::Owned;
+  };
+  if (!AI.getFunction()->hasOwnership() || !argOwnershipRequiresBorrow()) {
     return SILValue();
   }
 

test/SILOptimizer/inline_lifetime.sil

@@ -37,6 +37,12 @@ entry(%instance : $*S):
     return %retval : $()
 }
 
+sil [always_inline] [ossa] @callee_inguaranteed : $@convention(thin) <T> (@in_guaranteed T) -> () {
+entry(%arg : $*T):
+  %retval = tuple ()
+  return %retval : $()
+}
+
 // tests
 
 // CHECK-LABEL: sil [ossa] @caller_owned_callee_owned : $@convention(thin) (@owned C) -> () {
@@ -114,6 +120,16 @@ entry(%instance : $*S):
     return %result : $()
 }
 
+// CHECK-LABEL: sil [ossa] @caller_inguaranteed_callee_inguaranteed : $@convention(thin) <T> (@in_guaranteed T) -> () {
+// CHECK-NOT:     begin_borrow [lexical]
+// CHECK-LABEL: } // end sil function 'caller_inguaranteed_callee_inguaranteed'
+sil [ossa] @caller_inguaranteed_callee_inguaranteed : $@convention(thin) <T> (@in_guaranteed T) -> () {
+bb0(%instance : $*T):
+  %callee_inguaranteed = function_ref @callee_inguaranteed : $@convention(thin) <T> (@in_guaranteed T) -> ()
+  %retval = apply %callee_inguaranteed<T>(%instance) : $@convention(thin) <T> (@in_guaranteed T) -> ()
+  return %retval : $()
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // begin_apply
 ////////////////////////////////////////////////////////////////////////////////
@@ -177,6 +193,22 @@ bb2:
   unwind
 }
 
+sil hidden [ossa] [always_inline] @callee_coro_inguaranteed : $@yield_once @convention(thin) <T> (@in_guaranteed T) -> @yields @inout T {
+bb0(%instance : $*T):
+  %addr = alloc_stack $T
+  copy_addr %instance to [initialization] %addr : $*T
+  yield %addr : $*T, resume bb1, unwind bb2
+bb1:
+  destroy_addr %addr : $*T
+  dealloc_stack %addr : $*T
+  %result = tuple ()
+  return %result : $()
+bb2:
+  destroy_addr %addr : $*T
+  dealloc_stack %addr : $*T
+  unwind
+}
+
 // tests
 
 // CHECK-LABEL: sil [ossa] @caller_owned_callee_coro_owned : $@convention(thin) (@owned C) -> () {
@@ -296,6 +328,18 @@ bb0(%instance : $*S):
   return %retval : $()
 }
 
+// CHECK-LABEL: sil hidden [ossa] @caller_inguaranteed_callee_coro_inguaranteed : $@convention(thin) <T> (@in_guaranteed T) -> () {
+// CHECK-NOTE:    begin_borrow [lexical]
+// CHECK-LABEL: } // end sil function 'caller_inguaranteed_callee_coro_inguaranteed'
+sil hidden [ossa] @caller_inguaranteed_callee_coro_inguaranteed : $@convention(thin) <T> (@in_guaranteed T) -> () {
+bb0(%instance : $*T):
+  %callee_coro_inguaranteed = function_ref @callee_coro_inguaranteed : $@yield_once @convention(thin) <T> (@in_guaranteed T) -> @yields @inout T
+  (%addr_out, %continuation) = begin_apply %callee_coro_inguaranteed<T>(%instance) : $@yield_once @convention(thin) <T> (@in_guaranteed T) -> @yields @inout T
+  end_apply %continuation
+  %retval = tuple ()
+  return %retval : $()
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // try_apply
 ////////////////////////////////////////////////////////////////////////////////
@@ -344,6 +388,16 @@ bb2:
   return %18 : $()
 }
 
+sil [ossa] @callee_error_inguaranteed : $@convention(thin) <T> (@in_guaranteed T) -> @error Error {
+bb0(%0 : $*T):
+  cond_br undef, bb1, bb2
+bb1:
+  throw undef : $Error
+bb2:
+  %18 = tuple ()
+  return %18 : $()
+}
+
 // tests
 
 // CHECK-LABEL: sil [ossa] @caller_owned_callee_error_owned : $@convention(thin) (@owned C) -> @error Error {
@@ -469,3 +523,17 @@ bb1(%9 : $()):
 bb2(%12 : @owned $Error):
   throw %12 : $Error
 }
+
+// CHECK-LABEL: sil hidden [ossa] @caller_inguaranteed_callee_error_inguaranteed : $@convention(thin) <T> (@in_guaranteed T) -> @error Error {
+// CHECK-NOT:     begin_borrow [lexical]
+// CHECK-LABEL: // end sil function 'caller_inguaranteed_callee_error_inguaranteed'
+sil hidden [ossa] @caller_inguaranteed_callee_error_inguaranteed : $@convention(thin) <T> (@in_guaranteed T) -> @error Error {
+bb0(%instance : $*T):
+  %callee_error_inguaranteed = function_ref @callee_error_inguaranteed : $@convention(thin) <T> (@in_guaranteed T) -> @error Error
+  try_apply %callee_error_inguaranteed<T>(%instance) : $@convention(thin) <T> (@in_guaranteed T) -> @error Error, normal bb1, error bb2
+bb1(%9 : $()):
+  %10 = tuple ()
+  return %10 : $()
+bb2(%12 : @owned $Error):
+  throw %12 : $Error
+}