[Concurrency] Return getCurrentAsyncTask() as owned.

Rather than produce an "unowned" result from `getCurrentAsyncTask()`,
take advantage of the fact that the task is effectively guaranteed in
the scope. Do so be returning it as "unowned", and push an
end_lifetime cleanup to end the lifetime. This eliminates unnecessary
ref-count traffic as well as introducing another use of unowned.

Approach is thanks to Michael Gottesman, bugs are mine.

Author: DougGregor

include/swift/AST/Builtins.def

@@ -492,12 +492,6 @@ BUILTIN_SIL_OPERATION(ConvertStrongToUnownedUnsafe, "convertStrongToUnownedUnsaf
 /// now.
 BUILTIN_SIL_OPERATION(ConvertUnownedUnsafeToGuaranteed, "convertUnownedUnsafeToGuaranteed", Special)
 
-// getCurrentAsyncTask: () -> Builtin.NativeObject
-//
-// Retrieve the pointer to the task in which the current asynchronous
-// function is executing.
-BUILTIN_SIL_OPERATION(GetCurrentAsyncTask, "getCurrentAsyncTask", Special)
-
 /// applyDerivative
 BUILTIN_SIL_OPERATION(ApplyDerivative, "applyDerivative", Special)
 
@@ -723,6 +717,12 @@ BUILTIN_MISC_OPERATION(IntInstrprofIncrement, "int_instrprof_increment", "", Spe
   BUILTIN_MISC_OPERATION(Id, Name, Attrs, Overload)
 #endif
 
+// getCurrentAsyncTask: () -> Builtin.NativeObject
+//
+// Retrieve the pointer to the task in which the current asynchronous
+// function is executing.
+BUILTIN_MISC_OPERATION_WITH_SILGEN(GetCurrentAsyncTask, "getCurrentAsyncTask", "n", Special)
+
 /// globalStringTablePointer has type String -> Builtin.RawPointer.
 /// It returns an immortal, global string table pointer for strings constructed
 /// from string literals. We consider it effects as readnone meaning that it

lib/SIL/IR/OperandOwnership.cpp

@@ -1033,6 +1033,7 @@ ANY_OWNERSHIP_BUILTIN(IntInstrprofIncrement)
   }
 CONSTANT_OWNERSHIP_BUILTIN(Owned, MustBeInvalidated, COWBufferForReading)
 CONSTANT_OWNERSHIP_BUILTIN(Owned, MustBeInvalidated, UnsafeGuaranteed)
+CONSTANT_OWNERSHIP_BUILTIN(Owned, MustBeInvalidated, GetCurrentAsyncTask)
 #undef CONSTANT_OWNERSHIP_BUILTIN
 
 // Builtins that should be lowered to SIL instructions so we should never see

lib/SIL/IR/ValueOwnership.cpp

@@ -541,6 +541,7 @@ CONSTANT_OWNERSHIP_BUILTIN(None, PoundAssert)
 CONSTANT_OWNERSHIP_BUILTIN(None, TypePtrAuthDiscriminator)
 CONSTANT_OWNERSHIP_BUILTIN(None, IntInstrprofIncrement)
 CONSTANT_OWNERSHIP_BUILTIN(None, GlobalStringTablePointer)
+CONSTANT_OWNERSHIP_BUILTIN(Owned, GetCurrentAsyncTask)
 
 #undef CONSTANT_OWNERSHIP_BUILTIN
 
@@ -570,12 +571,6 @@ UNOWNED_OR_NONE_DEPENDING_ON_RESULT(ZeroInitializer)
 
 ValueOwnershipKind
 ValueOwnershipKindClassifier::visitBuiltinInst(BuiltinInst *BI) {
-  if (auto kind = BI->getBuiltinKind()) {
-    // The current async task is kept alive by the caller.
-    if (*kind == BuiltinValueKind::GetCurrentAsyncTask)
-      return ValueOwnershipKind::Unowned;
-  }
-
   // For now, just conservatively say builtins are None. We need to use a
   // builtin in here to guarantee correctness.
   return ValueOwnershipKindBuiltinVisitor().visit(BI);

lib/SILGen/SILGenBuiltin.cpp

@@ -1402,6 +1402,7 @@ static ManagedValue emitBuiltinGetCurrentAsyncTask(
       loc,
       ctx.getIdentifier(getBuiltinName(BuiltinValueKind::GetCurrentAsyncTask)),
       SGF.getLoweredType(ctx.TheNativeObjectType), SubstitutionMap(), { });
+  SGF.enterEndLifetimeCleanup(apply);
   return ManagedValue::forUnmanaged(apply);
 }
 

lib/SILGen/SILGenDecl.cpp

@@ -1326,6 +1326,32 @@ CleanupHandle SILGenFunction::enterDestroyCleanup(SILValue valueOrAddr) {
   return Cleanups.getTopCleanup();
 }
 
+namespace {
+class EndLifetimeCleanup : public Cleanup {
+  SILValue v;
+public:
+  EndLifetimeCleanup(SILValue v) : v(v) {}
+
+  void emit(SILGenFunction &SGF, CleanupLocation l,
+            ForUnwind_t forUnwind) override {
+    SGF.B.createEndLifetime(l, v);
+  }
+
+  void dump(SILGenFunction &) const override {
+#ifndef NDEBUG
+    llvm::errs() << "EndLifetimeCleanup\n"
+                 << "State:" << getState() << "\n"
+                 << "Value:" << v << "\n";
+#endif
+  }
+};
+} // end anonymous namespace
+
+CleanupHandle SILGenFunction::enterEndLifetimeCleanup(SILValue value) {
+  Cleanups.pushCleanup<EndLifetimeCleanup>(value);
+  return Cleanups.getTopCleanup();
+}
+
 namespace {
   /// A cleanup that deinitializes an opaque existential container
   /// before a value has been stored into it, or after its value was taken.

lib/SILGen/SILGenFunction.h

@@ -2000,7 +2000,10 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
 
   /// Enter a cleanup to emit a ReleaseValue/DestroyAddr of the specified value.
   CleanupHandle enterDestroyCleanup(SILValue valueOrAddr);
-  
+
+  /// Enter cleanup to emit an EndLifetime operation for the given value.
+  CleanupHandle enterEndLifetimeCleanup(SILValue value);
+
   /// Enter a cleanup to emit a DeinitExistentialAddr or DeinitExistentialBox
   /// of the specified value.
   CleanupHandle enterDeinitExistentialCleanup(CleanupState state,

lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp

@@ -140,6 +140,7 @@ static bool isBarrier(SILInstruction *inst) {
     case BuiltinValueKind::GlobalStringTablePointer:
     case BuiltinValueKind::COWBufferForReading:
     case BuiltinValueKind::IntInstrprofIncrement:
+    case BuiltinValueKind::GetCurrentAsyncTask:
       return false;
 
     // Handle some rare builtins that may be sensitive to object lifetime

test/IRGen/async/builtins.sil

@@ -14,5 +14,6 @@ bb0:
   %0 = builtin "getCurrentAsyncTask"() : $Builtin.NativeObject
   // CHECK-NEXT: [[TASK_COPY:%.*]] = call %swift.refcounted* @swift_retain(%swift.refcounted* returned [[TASK]])
   %1 = copy_value %0 : $Builtin.NativeObject
+  end_lifetime %0 : $Builtin.NativeObject
   return %1 : $Builtin.NativeObject
 }