SILGen: Implement withoutActuallyEscaping verification

Check that an ``withoutActuallyEscaping(noescape_closure) { // scope}`` closure
has not escaped in the scope using the ``is_escaping_closure %closure``
instruction.

rdar://35525730

Author: aschwaighofer

include/swift/Runtime/HeapObject.h

@@ -280,13 +280,6 @@ SWIFT_RUNTIME_EXPORT
 bool swift_isUniquelyReferencedOrPinned_nonNull_native(
   const struct HeapObject *);
 
-/// Is this native Swift pointer non-null and has a reference count greater than
-/// one.
-/// This runtime call will print an error message if the closure is escaping but
-/// it will not abort.
-SWIFT_RUNTIME_EXPORT
-bool swift_isEscapingClosure(const struct HeapObject *object);
-
 /// Is this native Swift pointer non-null and has a reference count greater than
 /// one.
 /// This runtime call will print an error message with file name and location if

include/swift/Runtime/RuntimeFunctions.def

@@ -677,13 +677,6 @@ FUNCTION(IsUniquelyReferencedOrPinned_nonNull_native,
          ARGS(RefCountedPtrTy),
          ATTRS(NoUnwind, ZExt))
 
-// bool swift_isEscapingClosure(const struct HeapObject *object);
-FUNCTION(IsEscapingClosure, swift_isEscapingClosure,
-         C_CC,
-         RETURNS(Int1Ty),
-         ARGS(RefCountedPtrTy),
-         ATTRS(NoUnwind, ZExt))
-
 // bool swift_isEscapingClosureAtFileLocation(const struct HeapObject *object,
 //                                            const unsigned char *filename,
 //                                            int32_t filenameLength,

include/swift/SIL/SILBuilder.h

@@ -1621,7 +1621,14 @@ class SILBuilder {
   // Runtime failure
   //===--------------------------------------------------------------------===//
 
-  CondFailInst *createCondFail(SILLocation Loc, SILValue Operand) {
+  CondFailInst *createCondFail(SILLocation Loc, SILValue Operand,
+                               bool Inverted = false) {
+    if (Inverted) {
+      SILType Ty = Operand->getType();
+      SILValue True(createIntegerLiteral(Loc, Ty, 1));
+      Operand =
+          createBuiltinBinaryFunction(Loc, "xor", Ty, Ty, {Operand, True});
+    }
     return insert(new (getModule())
                       CondFailInst(getSILDebugLocation(Loc), Operand));
   }

lib/SILGen/SILGenExpr.cpp

@@ -5310,29 +5310,41 @@ RValue RValueEmitter::visitOpenExistentialExpr(OpenExistentialExpr *E,
 }
 
 RValue RValueEmitter::visitMakeTemporarilyEscapableExpr(
-    MakeTemporarilyEscapableExpr *E,
-    SGFContext C) {
+    MakeTemporarilyEscapableExpr *E, SGFContext C) {
   // Emit the non-escaping function value.
   auto functionValue =
     visit(E->getNonescapingClosureValue()).getAsSingleValue(SGF, E);
 
   auto escapingFnTy = SGF.getLoweredType(E->getOpaqueValue()->getType());
 
   // Convert it to an escaping function value.
-  functionValue =
+  auto escapingClosure =
       SGF.createWithoutActuallyEscapingClosure(E, functionValue, escapingFnTy);
 
-  // Bind the opaque value to the escaping function.
-  SILGenFunction::OpaqueValueState opaqueValue{
-    functionValue,
-    /*consumable*/ true,
-    /*hasBeenConsumed*/ false,
-  };
-  SILGenFunction::OpaqueValueRAII pushOpaqueValue(SGF, E->getOpaqueValue(),
-                                                  opaqueValue);
+  RValue rvalue;
+  auto loc = SILLocation(E);
+  auto borrowedClosure = escapingClosure.borrow(SGF, loc);
+  {
+    // Bind the opaque value to the escaping function.
+    SILGenFunction::OpaqueValueState opaqueValue{
+        borrowedClosure,
+        /*consumable*/ false,
+        /*hasBeenConsumed*/ false,
+    };
+    SILGenFunction::OpaqueValueRAII pushOpaqueValue(SGF, E->getOpaqueValue(),
+                                                    opaqueValue);
 
-  // Emit the guarded expression.
-  return visit(E->getSubExpr(), C);
+    // Emit the guarded expression.
+    rvalue = visit(E->getSubExpr(), C);
+  }
+
+  // Now create the verification of the withoutActuallyEscaping operand.
+  // Either we fail the uniquenes check (which means the closure has escaped)
+  // and abort or we continue and destroy the ultimate reference.
+  auto isEscaping =
+      SGF.B.createIsEscapingClosure(loc, borrowedClosure.getValue());
+  SGF.B.createCondFail(loc, isEscaping);
+  return rvalue;
 }
 
 RValue RValueEmitter::visitOpaqueValueExpr(OpaqueValueExpr *E, SGFContext C) {

lib/SILGen/SILGenPoly.cpp

@@ -82,6 +82,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "SILGen.h"
+#include "SILGenFunction.h"
 #include "Scope.h"
 #include "swift/AST/GenericSignatureBuilder.h"
 #include "swift/AST/Decl.h"
@@ -3147,7 +3148,8 @@ static void buildWithoutActuallyEscapingThunkBody(SILGenFunction &SGF) {
   SGF.B.createReturn(loc, result);
 }
 
-ManagedValue SILGenFunction::createWithoutActuallyEscapingClosure(
+ManagedValue
+SILGenFunction::createWithoutActuallyEscapingClosure(
     SILLocation loc, ManagedValue noEscapingFunctionValue, SILType escapingTy) {
 
   auto escapingFnTy = escapingTy.castTo<SILFunctionType>();
@@ -3189,7 +3191,6 @@ ManagedValue SILGenFunction::createWithoutActuallyEscapingClosure(
       loc, thunkValue, SILType::getPrimitiveObjectType(substFnType), subs,
       noEscapeValue,
       SILType::getPrimitiveObjectType(escapingFnTy));
-
   // We need to ensure the 'lifetime' of the trivial values context captures. As
   // long as we rerpresent these captures by the same value the following works.
   thunkedFn = B.createMarkDependence(loc, thunkedFn, noEscapeValue);

lib/SILOptimizer/Transforms/SimplifyCFG.cpp

@@ -1412,13 +1412,7 @@ static CondFailInst *getUnConditionalFail(SILBasicBlock *BB, SILValue Cond,
 /// condition.
 static void createCondFail(CondFailInst *Orig, SILValue Cond, bool inverted,
                            SILBuilder &Builder) {
-  if (inverted) {
-    auto *True = Builder.createIntegerLiteral(Orig->getLoc(), Cond->getType(), 1);
-    Cond = Builder.createBuiltinBinaryFunction(Orig->getLoc(), "xor",
-                                               Cond->getType(), Cond->getType(),
-                                               {Cond, True});
-  }
-  Builder.createCondFail(Orig->getLoc(), Cond);
+  Builder.createCondFail(Orig->getLoc(), Cond, inverted);
 }
 
 /// Inverts the expected value of 'PotentialExpect' (if it is an expect

stdlib/public/runtime/SwiftObject.mm

@@ -1383,20 +1383,6 @@ static bool usesNativeSwiftReferenceCounting_nonNull(
          swift_isUniquelyReferencedOrPinned_nonNull_native(object);
 }
 
-// Given a non-@objc object reference, return true iff the
-// object is non-nil and has a strong reference count greather than 1
-bool swift::swift_isEscapingClosure(const HeapObject *object) {
-  bool isEscaping =
-      object != nullptr && !object->refCounts.isUniquelyReferenced();
-  if (isEscaping) {
-    auto *fatalErr = reinterpret_cast<const unsigned char *>("Fatal error");
-    auto *message = reinterpret_cast<const unsigned char *>(
-        "closure argument was escaped in withoutActuallyEscaping block");
-    _swift_stdlib_reportFatalError(fatalErr, 11, message, 62, 0 /* flags */);
-  }
-  return isEscaping;
-}
-
 // Given a non-@objc object reference, return true iff the
 // object is non-nil and has a strong reference count greather than 1
 bool swift::swift_isEscapingClosureAtFileLocation(const HeapObject *object,

test/Interpreter/withoutActuallyEscaping.swift

@@ -0,0 +1,81 @@
+// RUN: %target-run-simple-swift
+// REQUIRES: executable_test
+
+import StdlibUnittest
+
+var WithoutEscapingSuite = TestSuite("WithoutActuallyEscaping")
+
+var sink: Any = ()
+
+func dontEscape(f: () -> ()) {
+  withoutActuallyEscaping(f) {
+    $0()
+  }
+}
+
+func letEscape(f: () -> ()) -> () -> () {
+  return withoutActuallyEscaping(f) { return $0 }
+}
+
+var testShouldThrow = false
+
+struct MyError : Error {}
+
+func letEscapeThrowing(f: () -> ()) throws -> () -> () {
+  return try withoutActuallyEscaping(f) {
+    if testShouldThrow {
+      throw MyError()
+    }
+    return $0
+  }
+}
+
+WithoutEscapingSuite.test("ExpectNoCrash") {
+  dontEscape(f: { print("foo") })
+}
+
+WithoutEscapingSuite.test("ExpectDebugCrash") {
+  // Optimize versions pass a nil closure context.
+  if _isDebugAssertConfiguration() {
+    expectCrashLater()
+  }
+  sink = letEscape(f: { print("foo") })
+}
+
+struct Context {
+  var a = 0
+  var b = 1
+}
+
+WithoutEscapingSuite.test("ExpectCrash") {
+  expectCrashLater()
+  let context = Context()
+  sink = letEscape(f: { print("Context: \(context.a) \(context.b)") })
+}
+
+WithoutEscapingSuite.test("ExpectThrowingCrash") {
+  expectCrashLater()
+  let context = Context()
+  var testDidThrow = false
+  testShouldThrow = false
+  do {
+    sink = try letEscapeThrowing(f: { print("Context: \(context.a) \(context.b)") })
+  } catch {
+    testDidThrow = true
+  }
+  expectFalse(testDidThrow)
+}
+
+WithoutEscapingSuite.test("ExpectThrowingNoCrash") {
+  let context = Context()
+  var testDidThrow = false
+  testShouldThrow = true
+  do {
+    sink = try letEscapeThrowing(f: { print("Context: \(context.a) \(context.b)") })
+  } catch {
+    testDidThrow = true
+  }
+  expectTrue(testDidThrow)
+}
+
+runAllTests()

test/SILGen/without_actually_escaping.swift

@@ -9,8 +9,42 @@ func letEscape(f: () -> ()) -> () -> () {
 // TODO: verify that the partial_apply's reference count is one at the end of the scope.
 // CHECK:  [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[CVT]]([[ARG]]) : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
 // CHECK:  [[MD:%.*]] = mark_dependence  [[CLOSURE]] : $@callee_guaranteed () -> () on [[ARG]] : $@noescape @callee_guaranteed () -> ()
+// CHECK:  [[BORROW:%.*]] = begin_borrow [[MD]] : $@callee_guaranteed () -> ()
+// CHECK:  [[COPY:%.*]] = copy_value [[BORROW]] : $@callee_guaranteed () -> ()
 // CHECK:  [[USER:%.*]] = function_ref @$S25without_actually_escaping9letEscape1fyycyyXE_tFyycyycXEfU_ : $@convention(thin) (@owned @callee_guaranteed () -> ()) -> @owned @callee_guaranteed () -> ()
-// CHECK:  [[RES:%.*]] = apply %5([[MD]]) : $@convention(thin) (@owned @callee_guaranteed () -> ()) -> @owned @callee_guaranteed () -> ()
+// CHECK:  [[RES:%.*]] = apply [[USER]]([[COPY]]) : $@convention(thin) (@owned @callee_guaranteed () -> ()) -> @owned @callee_guaranteed () -> ()
+// CHECK:  [[ESCAPED:%.*]] = is_escaping_closure [[BORROW]] : $@callee_guaranteed () -> ()
+// CHECK:  cond_fail [[ESCAPED]] : $Builtin.Int1
+// CHECK:  end_borrow [[BORROW]] from [[MD]] : $@callee_guaranteed () -> (), $@callee_guaranteed () -> ()
+// CHECK:  destroy_value [[MD]]
 // CHECK:  return [[RES]] : $@callee_guaranteed () -> ()
   return withoutActuallyEscaping(f) { return $0 }
 }
+
+
+// CHECK-LABEL: sil hidden @$S25without_actually_escaping14letEscapeThrow1fyycyycyKXE_tKF
+// CHECK: bb0([[ARG:%.*]] : @trivial $@noescape @callee_guaranteed () -> (@owned @callee_guaranteed () -> (), @error Error)):
+// CHECK: [[CVT:%.*]] = function_ref @$SIeg_s5Error_pIgozo_Ieg_sAA_pIegozo_TR
+// CHECK: [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[CVT]]([[ARG]])
+// CHECK:  [[MD:%.*]] = mark_dependence [[CLOSURE]] : {{.*}} on [[ARG]]
+// CHECK:  [[BORROW:%.*]] = begin_borrow [[MD]]
+// CHECK:  [[COPY:%.*]] = copy_value [[BORROW]]
+// CHECK:  [[USER:%.*]] = function_ref @$S25without_actually_escaping14letEscapeThrow1fyycyycyKXE_tKFyycyycyKcKXEfU_
+// CHECK:  try_apply [[USER]]([[COPY]]) : {{.*}}, normal bb1, error bb2
+//
+// CHECK: bb1([[RES:%.*]] : @owned $@callee_guaranteed () -> ()):
+// CHECK:   [[ESCAPED:%.*]] = is_escaping_closure [[BORROW]]
+// CHECK:   cond_fail [[ESCAPED]] : $Builtin.Int1
+// CHECK:   end_borrow [[BORROW]] from [[MD]]
+// CHECK:   destroy_value [[MD]]
+// CHECK:   return [[RES]]
+//
+// CHECK: bb2([[ERR:%.*]] : @owned $Error):
+// CHECK:   end_borrow [[BORROW]] from [[MD]]
+// CHECK:   destroy_value [[MD]]
+// CHECK:   throw [[ERR]] : $Error
+// CHECK: }
+
+func letEscapeThrow(f: () throws -> () -> ()) throws -> () -> () {
+  return try withoutActuallyEscaping(f) { return try $0() }
+}