[CoroutineAccessors] Added modify.

The name is a placeholder for the mutating single-yield coroutine
accessor.

Author: nate-chandler

docs/ABI/Mangling.rst

@@ -388,10 +388,11 @@ Entities
   ACCESSOR ::= 'w'                           // willSet
   ACCESSOR ::= 'W'                           // didSet
   ACCESSOR ::= 'r'                           // read
-  ACCESSOR ::= 'M'                           // modify (temporary)
+  ACCESSOR ::= 'M'                           // _modify (temporary)
   ACCESSOR ::= 'a' ADDRESSOR-KIND            // mutable addressor
   ACCESSOR ::= 'l' ADDRESSOR-KIND            // non-mutable addressor
   ACCESSOR ::= 'p'                           // pseudo accessor referring to the storage itself
+  ACCESSOR ::= 'x'                           // modify
 
   ADDRESSOR-KIND ::= 'u'                     // unsafe addressor (no owner)
   ADDRESSOR-KIND ::= 'O'                     // owning addressor (non-native owner), not used anymore

include/swift/ABI/MetadataValues.h

@@ -372,6 +372,7 @@ class MethodDescriptorFlags {
     Setter,
     ModifyCoroutine,
     ReadCoroutine,
+    Modify2Coroutine,
   };
 
 private:
@@ -594,6 +595,7 @@ class ProtocolRequirementFlags {
     ModifyCoroutine,
     AssociatedTypeAccessFunction,
     AssociatedConformanceAccessFunction,
+    Modify2Coroutine,
   };
 
 private:

include/swift/AST/AccessorKinds.def

@@ -161,6 +161,14 @@ COROUTINE_ACCESSOR(Read, _read)
 /// one can be synthesized if the storage is mutable at all.
 COROUTINE_ACCESSOR(Modify, _modify)
 
+/// This is a modify accessor: a yield-once coroutine which is called when a
+/// the storage is modified which works by yielding an inout value
+/// of the storage type.
+///
+/// If the storage is not implemented with a modify accessor then
+/// one can be synthesized if the storage is mutable at all.
+EXPERIMENTAL_COROUTINE_ACCESSOR(Modify2, modify, CoroutineAccessors)
+
 /// This is a willSet observer: a function which "decorates" an
 /// underlying assignment operation by being called prior to the
 /// operation when a value is assigned to the storage.

include/swift/AST/DiagnosticsParse.def

@@ -305,6 +305,9 @@ ERROR(observing_accessor_in_subscript,none,
       "%select{'willSet'|'didSet'}0 is not allowed in subscripts", (unsigned))
 ERROR(getset_cannot_be_implied,none,
       "variable with implied type cannot have implied getter/setter", ())
+ERROR(accessor_requires_coroutine_accessors,none,
+      "%0 is only valid when experimental feature coroutine accessors is enabled",
+      (StringRef))
 
 // Import
 ERROR(decl_expected_module_name,none,

include/swift/AST/StorageImpl.h

@@ -28,6 +28,8 @@ class raw_ostream;
 
 namespace swift {
 
+class ASTContext;
+
 enum StorageIsMutable_t : bool {
   StorageIsNotMutable = false,
   StorageIsMutable = true
@@ -57,6 +59,8 @@ enum class AccessorKind {
 
 inline bool requiresFeatureCoroutineAccessors(AccessorKind kind) {
   switch (kind) {
+  case AccessorKind::Modify2:
+    return true;
   case AccessorKind::Get:
   case AccessorKind::DistributedGet:
   case AccessorKind::Set:
@@ -75,6 +79,7 @@ inline bool isYieldingAccessor(AccessorKind kind) {
   switch (kind) {
   case AccessorKind::Read:
   case AccessorKind::Modify:
+  case AccessorKind::Modify2:
     return true;
   case AccessorKind::Get:
   case AccessorKind::DistributedGet:
@@ -96,6 +101,7 @@ inline bool isYieldingDefaultNonmutatingAccessor(AccessorKind kind) {
   case AccessorKind::DistributedGet:
   case AccessorKind::Set:
   case AccessorKind::Modify:
+  case AccessorKind::Modify2:
   case AccessorKind::WillSet:
   case AccessorKind::DidSet:
   case AccessorKind::Address:
@@ -108,6 +114,7 @@ inline bool isYieldingDefaultNonmutatingAccessor(AccessorKind kind) {
 inline bool isYieldingDefaultMutatingAccessor(AccessorKind kind) {
   switch (kind) {
   case AccessorKind::Modify:
+  case AccessorKind::Modify2:
     return true;
   case AccessorKind::Get:
   case AccessorKind::DistributedGet:
@@ -297,8 +304,11 @@ enum class WriteImplKind {
   /// There's a mutable addressor.
   MutableAddress,
 
-  /// There's a modify coroutine.
+  /// There's a _modify coroutine.
   Modify,
+
+  /// There's a modify coroutine.
+  Modify2,
 };
 enum { NumWriteImplKindBits = 4 };
 
@@ -316,9 +326,12 @@ enum class ReadWriteImplKind {
   /// Do a read into a temporary and then a write back.
   MaterializeToTemporary,
 
-  /// There's a modify coroutine.
+  /// There's a _modify coroutine.
   Modify,
 
+  /// There's a modify coroutine.
+  Modify2,
+
   /// We have a didSet, so we're either going to use
   /// MaterializeOrTemporary or the "simple didSet"
   // access pattern.
@@ -391,6 +404,13 @@ class StorageImplInfo {
       assert(readWriteImpl == ReadWriteImplKind::Modify);
       return;
 
+    case WriteImplKind::Modify2:
+      assert(readImpl == ReadImplKind::Get ||
+             readImpl == ReadImplKind::Address ||
+             readImpl == ReadImplKind::Read);
+      assert(readWriteImpl == ReadWriteImplKind::Modify2);
+      return;
+
     case WriteImplKind::MutableAddress:
       assert(readImpl == ReadImplKind::Get ||
              readImpl == ReadImplKind::Address ||
@@ -411,8 +431,9 @@ class StorageImplInfo {
   }
 
   static StorageImplInfo getOpaque(StorageIsMutable_t isMutable,
-                                   OpaqueReadOwnership ownership) {
-    return (isMutable ? getMutableOpaque(ownership)
+                                   OpaqueReadOwnership ownership,
+                                   const ASTContext &ctx) {
+    return (isMutable ? getMutableOpaque(ownership, ctx)
                       : getImmutableOpaque(ownership));
   }
 
@@ -422,7 +443,8 @@ class StorageImplInfo {
   }
 
   /// Describe the implementation of a mutable property implemented opaquely.
-  static StorageImplInfo getMutableOpaque(OpaqueReadOwnership ownership);
+  static StorageImplInfo getMutableOpaque(OpaqueReadOwnership ownership,
+                                          const ASTContext &ctx);
 
   static StorageImplInfo getComputed(StorageIsMutable_t isMutable) {
     return (isMutable ? getMutableComputed()

include/swift/Demangling/DemangleNodes.def

@@ -178,6 +178,7 @@ NODE(ObjCMetadataUpdateFunction)
 NODE(ObjCResilientClassStub)
 NODE(FullObjCResilientClassStub)
 CONTEXT_NODE(ModifyAccessor)
+CONTEXT_NODE(Modify2Accessor)
 CONTEXT_NODE(Module)
 CONTEXT_NODE(NativeOwningAddressor)
 CONTEXT_NODE(NativeOwningMutableAddressor)

lib/AST/ASTDumper.cpp

@@ -248,6 +248,8 @@ static StringRef getDumpString(WriteImplKind kind) {
     return "mutable_addressor";
   case WriteImplKind::Modify:
     return "modify_coroutine";
+  case WriteImplKind::Modify2:
+    return "modify2_coroutine";
   }
   llvm_unreachable("bad kind");
 }
@@ -264,6 +266,8 @@ static StringRef getDumpString(ReadWriteImplKind kind) {
     return "materialize_to_temporary";
   case ReadWriteImplKind::Modify:
     return "modify_coroutine";
+  case ReadWriteImplKind::Modify2:
+    return "modify2_coroutine";
   case ReadWriteImplKind::StoredWithDidSet:
     return "stored_with_didset";
   case ReadWriteImplKind::InheritedWithDidSet:

lib/AST/ASTMangler.cpp

@@ -107,6 +107,8 @@ static StringRef getCodeForAccessorKind(AccessorKind kind) {
     return "au";
   case AccessorKind::Init:
     return "i";
+  case AccessorKind::Modify2:
+    return "x";
   }
   llvm_unreachable("bad accessor kind");
 }

lib/AST/ASTPrinter.cpp

@@ -2359,6 +2359,12 @@ void PrintAST::printSelfAccessKindModifiersIfNeeded(const FuncDecl *FD) {
   }
 }
 
+static bool
+shouldPrintUnderscoredCoroutineAccessors(const AbstractStorageDecl *ASD) {
+  // TODO: CoroutineAccessors: Print only when necessary.
+  return true;
+}
+
 void PrintAST::printAccessors(const AbstractStorageDecl *ASD) {
   if (isa<VarDecl>(ASD) && !Options.PrintPropertyAccessors)
     return;
@@ -2501,8 +2507,13 @@ void PrintAST::printAccessors(const AbstractStorageDecl *ASD) {
   // Collect the accessor declarations that we should print.
   SmallVector<AccessorDecl *, 4> accessorsToPrint;
   auto AddAccessorToPrint = [&](AccessorKind kind) {
+    if (Options.SuppressCoroutineAccessors &&
+        requiresFeatureCoroutineAccessors(kind))
+      return;
     auto *Accessor = ASD->getAccessor(kind);
-    if (Accessor && shouldPrint(Accessor))
+    if (!Accessor)
+      return;
+    if (shouldPrint(Accessor))
       accessorsToPrint.push_back(Accessor);
   };
 
@@ -2542,8 +2553,10 @@ void PrintAST::printAccessors(const AbstractStorageDecl *ASD) {
     }
     case WriteImplKind::Set:
       AddAccessorToPrint(AccessorKind::Set);
-      if (!shouldHideModifyAccessor())
+      if (!shouldHideModifyAccessor()) {
         AddAccessorToPrint(AccessorKind::Modify);
+        AddAccessorToPrint(AccessorKind::Modify2);
+      }
       break;
     case WriteImplKind::MutableAddress:
       AddAccessorToPrint(AccessorKind::MutableAddress);
@@ -2553,6 +2566,13 @@ void PrintAST::printAccessors(const AbstractStorageDecl *ASD) {
     case WriteImplKind::Modify:
       AddAccessorToPrint(AccessorKind::Modify);
       break;
+    case WriteImplKind::Modify2:
+      if (ASD->getAccessor(AccessorKind::Modify) &&
+          shouldPrintUnderscoredCoroutineAccessors(ASD)) {
+        AddAccessorToPrint(AccessorKind::Modify);
+      }
+      AddAccessorToPrint(AccessorKind::Modify2);
+      break;
     }
   }
 
@@ -4060,6 +4080,7 @@ void PrintAST::visitAccessorDecl(AccessorDecl *decl) {
   case AccessorKind::Address:
   case AccessorKind::Read:
   case AccessorKind::Modify:
+  case AccessorKind::Modify2:
   case AccessorKind::DidSet:
   case AccessorKind::MutableAddress:
     recordDeclLoc(decl,

lib/AST/ASTVerifier.cpp

@@ -3411,10 +3411,11 @@ class Verifier : public ASTWalker {
           abort();
         }
         if (FD->isDynamic() != storageDecl->isDynamic() &&
-            // We allow a non dynamic setter if there is a dynamic modify,
-            // observer, or mutable addressor.
+            // We allow a non dynamic setter if there is a dynamic
+            // _modify/modify, observer, or mutable addressor.
             !(FD->isSetter() &&
               (storageDecl->getWriteImpl() == WriteImplKind::Modify ||
+               storageDecl->getWriteImpl() == WriteImplKind::Modify2 ||
                storageDecl->getWriteImpl() ==
                    WriteImplKind::StoredWithObservers ||
                storageDecl->getWriteImpl() == WriteImplKind::MutableAddress) &&