MandatoryInlining: look through sendable function conversions

Allows inlining of sendable transparent functions

rdar://124401627

Author: eeckstein

include/swift/SIL/SILInstruction.h

@@ -5740,6 +5740,9 @@ class ConvertFunctionInst final
   /// argument and return types, as well as all other attributes, after substitution,
   /// such as converting `$<A, B> in (A) -> B for <Int, String>` to `(Int) -> String`.
   bool onlyConvertsSubstitutions() const;
+
+  /// Returns true if the source and destination types only differ by `@Sendable`.
+  bool onlyConvertsSendable() const;
 };
 
 /// ConvertEscapeToNoEscapeInst - Change the type of a escaping function value

lib/SIL/IR/SILInstructions.cpp

@@ -2744,6 +2744,16 @@ bool ConvertFunctionInst::onlyConvertsSubstitutions() const {
   return fromType->getUnsubstitutedType(M) == toType->getUnsubstitutedType(M);
 }
 
+static SILFunctionType *getNonSendableFuncType(SILType ty) {
+  auto fnTy = ty.castTo<SILFunctionType>();
+  return fnTy->getWithExtInfo(fnTy->getExtInfo().withConcurrent(false));
+}
+
+bool ConvertFunctionInst::onlyConvertsSendable() const {
+  return getNonSendableFuncType(getOperand()->getType()) ==
+         getNonSendableFuncType(getType());
+}
+
 ConvertEscapeToNoEscapeInst *ConvertEscapeToNoEscapeInst::create(
     SILDebugLocation DebugLoc, SILValue Operand, SILType Ty, SILFunction &F,
     bool isLifetimeGuaranteed) {

lib/SILOptimizer/Mandatory/MandatoryInlining.cpp

@@ -592,6 +592,20 @@ static SILValue getLoadedCalleeValue(LoadInst *li) {
   return si->getSrc();
 }
 
+static bool convertsThinEscapeToNoescape(ConvertFunctionInst *cv) {
+  // Example:
+  //   %1 = function_ref @thin_closure_impl : $() -> ()
+  //   %2 = convert_function %1 : $() -> () to $@noescape () -> ()
+  //
+  auto fromTy = cv->getOperand()->getType().castTo<SILFunctionType>();
+  if (fromTy->getExtInfo().hasContext())
+    return false;
+
+  auto toTy = cv->getType().castTo<SILFunctionType>();
+  auto escapeToTy = toTy->getWithExtInfo(toTy->getExtInfo().withNoEscape(false));
+  return fromTy == escapeToTy;
+}
+
 // PartialApply/ThinToThick -> ConvertFunction patterns are generated
 // by @noescape closures.
 //
@@ -602,32 +616,13 @@ static SILValue stripFunctionConversions(SILValue CalleeValue) {
   // Skip any copies that we see.
   CalleeValue = lookThroughOwnershipInsts(CalleeValue);
 
-  // We can also allow a thin @escape to noescape conversion as such:
-  // %1 = function_ref @thin_closure_impl : $@convention(thin) () -> ()
-  // %2 = convert_function %1 :
-  //      $@convention(thin) () -> () to $@convention(thin) @noescape () -> ()
-  // %3 = thin_to_thick_function %2 :
-  //  $@convention(thin) @noescape () -> () to
-  //            $@noescape @callee_guaranteed () -> ()
-  // %4 = apply %3() : $@noescape @callee_guaranteed () -> ()
   if (auto *ConvertFn = dyn_cast<ConvertFunctionInst>(CalleeValue)) {
-    // If the conversion only changes the substitution level of the function,
-    // we can also look through it.
-    if (ConvertFn->onlyConvertsSubstitutions())
+    if (ConvertFn->onlyConvertsSubstitutions() ||
+        ConvertFn->onlyConvertsSendable() ||
+        convertsThinEscapeToNoescape(ConvertFn)) {
       return stripFunctionConversions(ConvertFn->getOperand());
-
-    auto FromCalleeTy =
-        ConvertFn->getOperand()->getType().castTo<SILFunctionType>();
-    if (FromCalleeTy->getExtInfo().hasContext())
-      return CalleeValue;
-
-    auto ToCalleeTy = ConvertFn->getType().castTo<SILFunctionType>();
-    auto EscapingCalleeTy = ToCalleeTy->getWithExtInfo(
-        ToCalleeTy->getExtInfo().withNoEscape(false));
-    if (FromCalleeTy != EscapingCalleeTy)
-      return CalleeValue;
-
-    return lookThroughOwnershipInsts(ConvertFn->getOperand());
+    }
+    return CalleeValue;
   }
 
   // Ignore mark_dependence users. A partial_apply [stack] uses them to mark

test/SILOptimizer/diagnostic_constant_propagation.swift

@@ -347,6 +347,12 @@ func add<T : SignedInteger>(_ left: T, _ right: T) -> T {
   return left + right
 }
 
+@Sendable
+@_transparent
+func sendableAdd<T : SignedInteger>(_ left: T, _ right: T) -> T {
+  return left + right
+}
+
 @_transparent
 func applyBinary<T : SignedInteger>(_ fn: (T, T) -> (T), _ left: T, _ right: T) -> T {
   return fn(left, right)
@@ -356,6 +362,10 @@ func testTransparentApply() -> Int8 {
   return applyBinary(add, Int8.max, Int8.max) // expected-error {{arithmetic operation '127 + 127' (on signed 8-bit integer type) results in an overflow}}
 }
 
+func testTransparentApplySendable() -> Int8 {
+  return applyBinary(sendableAdd, Int8.max, Int8.max) // expected-error {{arithmetic operation '127 + 127' (on signed 8-bit integer type) results in an overflow}}
+}
+
 func testBuiltinGlobalStringTablePointerNoError() -> UnsafePointer<CChar> {
   return _getGlobalStringTablePointer("A literal")
 }