Teach static exclusivity verification about withoutActuallyEscaping.

DiagnoseStaticExclusivity no longer asserts as follows when
non-escaping closures are passed to withoutActuallyEscaping:

Applied argument must be @NoEscape function type: ...
A partial_apply with @inout_aliasable may only be used as a @NoEscape
function type argument.

Subsequent commits will improve diagnostics to detect actual conflicts
in these situations.

Fixes <rdar://problem/43059088> Assertion in DiagnoseStaticExclusivity.

Author: atrick

include/swift/SIL/InstructionUtils.h

@@ -86,6 +86,9 @@ SILValue stripBorrow(SILValue V);
 /// copies the value of its first operand, possibly changing its type or
 /// ownership state, but otherwise having no effect.
 ///
+/// The returned instruction may have additional "incidental" operands;
+/// mark_dependence for example.
+///
 /// This is useful for checking all users of a value to verify that the value is
 /// only used in recognizable patterns without otherwise "escaping". These are
 /// instructions that the use-visitor can recurse into. Note that the value's

lib/SILOptimizer/Mandatory/DiagnoseStaticExclusivity.cpp

@@ -967,12 +967,24 @@ static void checkNoEscapePartialApplyUse(Operand *oper, FollowUse followUses) {
   if (isIncidentalUse(user) || onlyAffectsRefCount(user))
     return;
 
+  // Before checking conversions in general below (getSingleValueCopyOrCast),
+  // check for convert_function to [without_actually_escaping]. Assume such
+  // conversion are not actually escaping without following their uses.
+  if (auto *CFI = dyn_cast<ConvertFunctionInst>(user)) {
+    if (CFI->withoutActuallyEscaping())
+      return;
+  }
+
   // Look through copies, borrows, and conversions.
   //
   // Note: This handles ConversionInst, which already includes everything in
   // swift::stripConvertFunctions.
   if (SingleValueInstruction *copy = getSingleValueCopyOrCast(user)) {
-    followUses(copy);
+    // Only follow the copied operand. Other operands are incidental,
+    // as in the second operand of mark_dependence.
+    if (oper->getOperandNumber() == 0)
+      followUses(copy);
+
     return;
   }
 
@@ -1017,6 +1029,10 @@ static void checkNoEscapePartialApplyUse(Operand *oper, FollowUse followUses) {
     }
     break;
 
+  case SILInstructionKind::IsEscapingClosureInst:
+    // May be generated by withoutActuallyEscaping.
+    return;
+
   case SILInstructionKind::PartialApplyInst: {
     // Recurse through partial_apply to handle special cases before handling
     // ApplySites in general below.
@@ -1036,7 +1052,10 @@ static void checkNoEscapePartialApplyUse(Operand *oper, FollowUse followUses) {
     // thunk as "escaping", but as long as the thunk is only used as a
     // '@noescape" type then it is safe.
     if (isPartialApplyOfReabstractionThunk(PAI)) {
-      followUses(PAI);
+      // Don't follow thunks that were generated by withoutActuallyEscaping.
+      SILFunction *thunkDef = PAI->getReferencedFunction();
+      if (!thunkDef->isWithoutActuallyEscapingThunk())
+        followUses(PAI);
       return;
     }
     // Handle this use like a normal applied argument.

test/SILOptimizer/exclusivity_static_diagnostics.sil

@@ -1285,3 +1285,116 @@ bb3(%pa3 : @owned $@callee_guaranteed (@inout Int) -> ()):
   %v = tuple ()
   return %v : $()
 }
+
+// -----------------------------------------------------------------------------
+// Test withoutActuallyEscaping thunk.
+// <rdar://problem/43059088> Assertion in DiagnoseStaticExclusivity
+// Noescape closure verification should not assert.
+
+sil @takeEscapingClosure : $@convention(thin) (@guaranteed @callee_guaranteed () -> ()) -> ()
+
+sil private @nestedInWithoutActuallyEscapingVerify : $@convention(thin) (@inout_aliasable Int) -> () {
+bb0(%0 : @trivial $*Int):
+  %a = begin_access [modify] [unknown] %0 : $*Int
+  end_access %a : $*Int
+  %v = tuple ()
+  return %v : $()
+}
+
+// CHECK-LABEL: sil hidden @testWithoutActuallyEscapingVerify : $@convention(thin) (@inout Int) -> () {
+sil hidden @testWithoutActuallyEscapingVerify : $@convention(thin) (@inout Int) -> () {
+bb0(%0 : @trivial $*Int):
+  %2 = function_ref @nestedInWithoutActuallyEscapingVerify : $@convention(thin) (@inout_aliasable Int) -> ()
+  %3 = partial_apply [callee_guaranteed] %2(%0) : $@convention(thin) (@inout_aliasable Int) -> ()
+
+  %4 = function_ref @thunkForWithoutActuallyEscapingVerify : $@convention(thin) (@guaranteed @callee_guaranteed () -> ()) -> ()
+  %5 = partial_apply [callee_guaranteed] %4(%3) : $@convention(thin) (@guaranteed @callee_guaranteed () -> ()) -> ()
+  %6 = mark_dependence %5 : $@callee_guaranteed () -> () on %3 : $@callee_guaranteed () -> ()
+
+  %8 = function_ref @closureForWithoutActuallyEscapingVerify : $@convention(thin) (@guaranteed @callee_guaranteed () -> ()) -> ()
+  %9 = apply %8(%6) : $@convention(thin) (@guaranteed @callee_guaranteed () -> ()) -> ()
+  %10 = is_escaping_closure %6 : $@callee_guaranteed () -> ()
+  cond_fail %10 : $Builtin.Int1
+  destroy_value %6 : $@callee_guaranteed () -> ()
+  %14 = tuple ()
+  return %14 : $()
+}
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] [without_actually_escaping] @thunkForWithoutActuallyEscapingVerify : $@convention(thin) (@guaranteed @callee_guaranteed () -> ()) -> () {
+sil shared [transparent] [serializable] [reabstraction_thunk] [without_actually_escaping] @thunkForWithoutActuallyEscapingVerify : $@convention(thin) (@guaranteed @callee_guaranteed () -> ()) -> () {
+bb0(%0 : @guaranteed $@callee_guaranteed () -> ()):
+  %1 = apply %0() : $@callee_guaranteed () -> ()
+  return %1 : $()
+}
+
+sil private @closureForWithoutActuallyEscapingVerify : $@convention(thin) (@guaranteed @callee_guaranteed () -> ()) -> () {
+bb0(%0 : @guaranteed $@callee_guaranteed () -> ()):
+  %2 = function_ref @takeEscapingClosure : $@convention(thin) (@guaranteed @callee_guaranteed () -> ()) -> ()
+  %3 = apply %2(%0) : $@convention(thin) (@guaranteed @callee_guaranteed () -> ()) -> ()
+  %4 = tuple ()
+  return %4 : $()
+}
+
+// -----------------------------------------------------------------------------
+// Test withoutActuallyEscaping convert_function.
+// <rdar://problem/43059088> Assertion in DiagnoseStaticExclusivity
+// Noescape closure verification should not assert.
+
+// CHECK-LABEL: sil hidden @testWithoutActuallyEscapingBlockVerify : $@convention(thin) (Int) -> () {
+// CHECK: convert_function %{{.*}} : $@convention(block) () -> () to [without_actually_escaping] $@convention(block) () -> ()
+sil hidden @testWithoutActuallyEscapingBlockVerify : $@convention(thin) (Int) -> () {
+bb0(%0 : @trivial $Int):
+  %box = alloc_box ${ var Int }, var, name "localVal"
+  %projbox = project_box %box : ${ var Int }, 0
+  store %0 to [trivial] %projbox : $*Int
+  %closureF = function_ref @testWithoutActuallyEscapingBlockVerifyClosure : $@convention(thin) (@inout_aliasable Int) -> ()
+  %closure = partial_apply [callee_guaranteed] %closureF(%projbox) : $@convention(thin) (@inout_aliasable Int) -> ()
+  %block = alloc_stack $@block_storage @callee_guaranteed () -> ()
+  %blockproj = project_block_storage %block : $*@block_storage @callee_guaranteed () -> ()
+  store %closure to [init] %blockproj : $*@callee_guaranteed () -> ()
+  // function_ref thunk for @escaping @callee_guaranteed () -> ()
+  %thunkF = function_ref @$SIeg_IeyB_TR : $@convention(c) (@inout_aliasable @block_storage @callee_guaranteed () -> ()) -> ()
+  %initblock = init_block_storage_header %block : $*@block_storage @callee_guaranteed () -> (), invoke %thunkF : $@convention(c) (@inout_aliasable @block_storage @callee_guaranteed () -> ()) -> (), type $@convention(block) () -> ()
+  destroy_addr %blockproj : $*@callee_guaranteed () -> ()
+  dealloc_stack %block : $*@block_storage @callee_guaranteed () -> ()
+  %borrow = begin_borrow %initblock : $@convention(block) () -> ()
+  %copy = copy_value %borrow : $@convention(block) () -> ()
+  %escapingF = convert_function %copy : $@convention(block) () -> () to [without_actually_escaping] $@convention(block) () -> ()
+  %clauseF = function_ref @testWithoutActuallyEscapingBlockVerifyClause : $@convention(thin) (@guaranteed @convention(block) () -> ()) -> ()
+  %call = apply %clauseF(%escapingF) : $@convention(thin) (@guaranteed @convention(block) () -> ()) -> ()
+  destroy_value %escapingF : $@convention(block) () -> ()
+  end_borrow %borrow from %initblock : $@convention(block) () -> (), $@convention(block) () -> ()
+  destroy_value %initblock : $@convention(block) () -> ()
+  destroy_value %box : ${ var Int }
+  %v = tuple ()
+  return %v : $()
+}
+
+sil @testWithoutActuallyEscapingBlockVerifyClosure : $@convention(thin) (@inout_aliasable Int) -> ()
+
+// thunk for @escaping @callee_guaranteed () -> ()
+sil shared [transparent] [serializable] [reabstraction_thunk] @$SIeg_IeyB_TR : $@convention(c) (@inout_aliasable @block_storage @callee_guaranteed () -> ()) -> () {
+// %0
+bb0(%0 : @trivial $*@block_storage @callee_guaranteed () -> ()):
+  %1 = project_block_storage %0 : $*@block_storage @callee_guaranteed () -> ()
+  %2 = load [copy] %1 : $*@callee_guaranteed () -> ()
+  %3 = begin_borrow %2 : $@callee_guaranteed () -> ()
+  %4 = apply %3() : $@callee_guaranteed () -> ()
+  end_borrow %3 from %2 : $@callee_guaranteed () -> (), $@callee_guaranteed () -> ()
+  %6 = tuple ()
+  destroy_value %2 : $@callee_guaranteed () -> ()
+  return %6 : $()
+} // end sil function '$SIeg_IeyB_TR'
+
+sil private @testWithoutActuallyEscapingBlockVerifyClause : $@convention(thin) (@guaranteed @convention(block) () -> ()) -> () {
+bb0(%0 : @guaranteed $@convention(block) () -> ()):
+  %1 = copy_block %0 : $@convention(block) () -> ()
+  %3 = begin_borrow %1 : $@convention(block) () -> ()
+  %4 = copy_value %3 : $@convention(block) () -> ()
+  %5 = apply %4() : $@convention(block) () -> ()
+  destroy_value %4 : $@convention(block) () -> ()
+  end_borrow %3 from %1 : $@convention(block) () -> (), $@convention(block) () -> ()
+  destroy_value %1 : $@convention(block) () -> ()
+  %v = tuple ()
+  return %v : $()
+}