[CoroutineAccessors] Add new SILFnTy CoroKind.

For `modify` and `read` coroutines, produce SILFunctionType's whose
coroutineKind is ::YieldOnce2.

Author: nate-chandler

docs/ABI/Mangling.rst

@@ -856,6 +856,7 @@ mangled in to disambiguate.
   FUNC-REPRESENTATION ::= 'W'                // protocol witness
 
   COROUTINE-KIND ::= 'A'                     // yield-once coroutine
+  COROUTINE-KIND ::= 'I'                     // yield-once-2 coroutine
   COROUTINE-KIND ::= 'G'                     // yield-many coroutine
 
   #if SWIFT_RUNTIME_VERSION >= 5.5

docs/SIL.rst

@@ -789,13 +789,16 @@ coroutine, where a normal function return would need to transfer ownership of
 its return value, since a normal function's context ceases to exist and be able
 to maintain ownership of the value after it returns.
 
-To support these concepts, SIL supports two kinds of coroutine:
-``@yield_many`` and ``@yield_once``. Either of these attributes may be
+To support these concepts, SIL supports two flavors: single-yield and
+multi-yield.  These two flavors correspond to three kinds.  A multi-yield
+coroutine is of kind ``@yield_many``. A single-yield coroutine is of kind
+either ``@yield_once`` or ``@yield_once_2``. Any of these attributes may be
 written before a function type to indicate that it is a coroutine type.
-``@yield_many`` and ``@yield_once`` coroutines are allowed to also be
-``@async``. (Note that ``@async`` functions are not themselves modeled
-explicitly as coroutines in SIL, although the implementation may use a coroutine
-lowering strategy.)
+
+Both single-yield and multi-yield coroutines are allowed to also be ``@async``.
+(Note that ``@async`` functions are not themselves modeled explicitly as
+coroutines in SIL, although the implementation may use a coroutine lowering
+strategy.)
 
 A coroutine type may declare any number of *yielded values*, which is to
 say, values which are provided to the caller at a yield point.  Yielded
@@ -816,9 +819,10 @@ calling a yield-many coroutine of any kind.
 Coroutines may contain the special ``yield`` and ``unwind``
 instructions.
 
-A ``@yield_many`` coroutine may yield as many times as it desires.
-A ``@yield_once`` coroutine may yield exactly once before returning,
-although it may also ``throw`` before reaching that point.
+A multi-yield (``@yield_many``) coroutine may yield as many times as it desires.
+A single-yield (``@yield_once`` or ``@yield_once_2``) coroutine may yield
+exactly once before returning, although it may also ``throw`` before reaching
+that point.
 
 Variadic Generics
 `````````````````
@@ -8376,9 +8380,10 @@ the current function was invoked with a ``try_apply`` instruction, control
 resumes at the normal destination, and the value of the basic block argument
 will be the operand of this ``return`` instruction.
 
-If the current function is a ``yield_once`` coroutine, there must not be
-a path from the entry block to a ``return`` which does not pass through
-a ``yield`` instruction. This rule does not apply in the ``raw`` SIL stage.
+If the current function is a single-yield coroutine (``yield_once`` or
+``yield_once_2``), there must not be a path from the entry block to a
+``return`` which does not pass through a ``yield`` instruction. This rule does
+not apply in the ``raw`` SIL stage.
 
 ``return`` does not retain or release its operand or any other values.
 
@@ -8446,9 +8451,10 @@ The ``resume`` and ``unwind`` destination blocks must be uniquely
 referenced by the ``yield`` instruction.  This prevents them from becoming
 critical edges.
 
-In a ``yield_once`` coroutine, there must not be a control flow path leading
-from the ``resume`` edge to another ``yield`` instruction in this function.
-This rule does not apply in the ``raw`` SIL stage.
+In a single-yield coroutine (``yield_once`` or ``yield_once_2``), there must
+not be a control flow path leading from the ``resume`` edge to another
+``yield`` instruction in this function. This rule does not apply in the ``raw``
+SIL stage.
 
 There must not be a control flow path leading from the ``unwind`` edge to
 a ``return`` instruction, to a ``throw`` instruction, or to any block

include/swift/AST/IRGenOptions.h

@@ -165,6 +165,9 @@ struct PointerAuthOptions : clang::PointerAuthOptions {
   /// Resumption functions from yield-once coroutines.
   PointerAuthSchema YieldOnceResumeFunctions;
 
+  /// Resumption functions from yield-once-2 coroutines.
+  PointerAuthSchema YieldOnce2ResumeFunctions;
+
   /// Resumption functions from yield-many coroutines.
   PointerAuthSchema YieldManyResumeFunctions;
 

include/swift/AST/TypeAttr.def

@@ -101,6 +101,7 @@ SIMPLE_SIL_TYPE_ATTR(pseudogeneric, Pseudogeneric)
 SIMPLE_SIL_TYPE_ATTR(unimplementable, Unimplementable)
 SIMPLE_SIL_TYPE_ATTR(yields, Yields)
 SIMPLE_SIL_TYPE_ATTR(yield_once, YieldOnce)
+SIMPLE_SIL_TYPE_ATTR(yield_once_2, YieldOnce2)
 SIMPLE_SIL_TYPE_ATTR(yield_many, YieldMany)
 SIMPLE_SIL_TYPE_ATTR(captures_generics, CapturesGenerics)
 // Used at the SIL level to mark a type as moveOnly.

include/swift/AST/Types.h

@@ -4823,11 +4823,17 @@ enum class SILCoroutineKind : uint8_t {
   /// It must not have normal results and may have arbitrary yield results.
   YieldOnce,
 
+  /// This function is a yield-once coroutine (used by read and modify
+  /// accessors).  It has the following differences from YieldOnce:
+  /// - it does not observe errors thrown by its caller
+  /// - it uses the callee-allocated ABI
+  YieldOnce2,
+
   /// This function is a yield-many coroutine (used by e.g. generators).
   /// It must not have normal results and may have arbitrary yield results.
   YieldMany,
 };
-  
+
 class SILFunctionConventions;
 
 
@@ -5039,6 +5045,17 @@ class SILFunctionType final
   SILCoroutineKind getCoroutineKind() const {
     return SILCoroutineKind(Bits.SILFunctionType.CoroutineKind);
   }
+  /// Whether this coroutine's ABI is callee-allocated.
+  bool isCalleeAllocatedCoroutine() const {
+    switch (getCoroutineKind()) {
+    case SILCoroutineKind::None:
+    case SILCoroutineKind::YieldOnce:
+    case SILCoroutineKind::YieldMany:
+      return false;
+    case SILCoroutineKind::YieldOnce2:
+      return true;
+    }
+  }
 
   bool isSendable() const { return getExtInfo().isSendable(); }
   bool isUnimplementable() const { return getExtInfo().isUnimplementable(); }

include/swift/Demangling/TypeDecoder.h

@@ -51,6 +51,7 @@ enum class ImplMetatypeRepresentation {
 enum class ImplCoroutineKind {
   None,
   YieldOnce,
+  YieldOnce2,
   YieldMany,
 };
 
@@ -1097,6 +1098,8 @@ class TypeDecoder {
             return MAKE_NODE_TYPE_ERROR0(child, "expected text");
           if (child->getText() == "yield_once") {
             coroutineKind = ImplCoroutineKind::YieldOnce;
+          } else if (child->getText() == "yield_once_2") {
+            coroutineKind = ImplCoroutineKind::YieldOnce2;
           } else if (child->getText() == "yield_many") {
             coroutineKind = ImplCoroutineKind::YieldMany;
           } else

include/swift/SIL/SILInstruction.h

@@ -3251,6 +3251,10 @@ class BeginApplyInst final
 public:
   using MultipleValueInstructionTrailingObjects::totalSizeToAlloc;
 
+  bool isCalleeAllocated() const {
+    return getSubstCalleeType()->isCalleeAllocatedCoroutine();
+  }
+
   MultipleValueInstructionResult *getTokenResult() const {
     return const_cast<MultipleValueInstructionResult *>(
              &getAllResultsBuffer().back());

lib/AST/ASTDemangler.cpp

@@ -582,6 +582,8 @@ getCoroutineKind(ImplCoroutineKind kind) {
     return SILCoroutineKind::None;
   case ImplCoroutineKind::YieldOnce:
     return SILCoroutineKind::YieldOnce;
+  case ImplCoroutineKind::YieldOnce2:
+    return SILCoroutineKind::YieldOnce2;
   case ImplCoroutineKind::YieldMany:
     return SILCoroutineKind::YieldMany;
   }

lib/AST/ASTMangler.cpp

@@ -2149,6 +2149,9 @@ void ASTMangler::appendImplFunctionType(SILFunctionType *fn,
   case SILCoroutineKind::YieldOnce:
     OpArgs.push_back('A');
     break;
+  case SILCoroutineKind::YieldOnce2:
+    OpArgs.push_back('I');
+    break;
   case SILCoroutineKind::YieldMany:
     OpArgs.push_back('G');
     break;

lib/AST/ASTPrinter.cpp

@@ -6748,6 +6748,9 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     case SILCoroutineKind::YieldOnce:
       Printer << "@yield_once ";
       return;
+    case SILCoroutineKind::YieldOnce2:
+      Printer << "@yield_once_2 ";
+      return;
     case SILCoroutineKind::YieldMany:
       Printer << "@yield_many ";
       return;