[CoroutineAccessors] Added read.

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

Author: nate-chandler

docs/ABI/Mangling.rst

@@ -387,12 +387,13 @@ Entities
   ACCESSOR ::= 'G'                           // global getter
   ACCESSOR ::= 'w'                           // willSet
   ACCESSOR ::= 'W'                           // didSet
-  ACCESSOR ::= 'r'                           // read
+  ACCESSOR ::= 'r'                           // _read
   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
+  ACCESSOR ::= 'y'                           // read
 
   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,
+    Read2Coroutine,
     Modify2Coroutine,
   };
 
@@ -595,6 +596,7 @@ class ProtocolRequirementFlags {
     ModifyCoroutine,
     AssociatedTypeAccessFunction,
     AssociatedConformanceAccessFunction,
+    Read2Coroutine,
     Modify2Coroutine,
   };
 

include/swift/AST/AccessorKinds.def

@@ -153,6 +153,14 @@ OBJC_ACCESSOR(Set, set)
 /// one can always be synthesized (even if the storage type is move-only).
 COROUTINE_ACCESSOR(Read, _read)
 
+/// This is a read accessor: a yield-once coroutine which is called when a
+/// value is loaded from the storage, like a getter, but which works
+/// by yielding a borrowed value of the storage type.
+///
+/// If the storage is not implemented with a read accessor then
+/// one can always be synthesized (even if the storage type is move-only).
+EXPERIMENTAL_COROUTINE_ACCESSOR(Read2, read, CoroutineAccessors)
+
 /// 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.

include/swift/AST/StorageImpl.h

@@ -59,6 +59,7 @@ enum class AccessorKind {
 
 inline bool requiresFeatureCoroutineAccessors(AccessorKind kind) {
   switch (kind) {
+  case AccessorKind::Read2:
   case AccessorKind::Modify2:
     return true;
   case AccessorKind::Get:
@@ -78,6 +79,7 @@ inline bool requiresFeatureCoroutineAccessors(AccessorKind kind) {
 inline bool isYieldingAccessor(AccessorKind kind) {
   switch (kind) {
   case AccessorKind::Read:
+  case AccessorKind::Read2:
   case AccessorKind::Modify:
   case AccessorKind::Modify2:
     return true;
@@ -96,6 +98,7 @@ inline bool isYieldingAccessor(AccessorKind kind) {
 inline bool isYieldingDefaultNonmutatingAccessor(AccessorKind kind) {
   switch (kind) {
   case AccessorKind::Read:
+  case AccessorKind::Read2:
     return true;
   case AccessorKind::Get:
   case AccessorKind::DistributedGet:
@@ -120,6 +123,7 @@ inline bool isYieldingDefaultMutatingAccessor(AccessorKind kind) {
   case AccessorKind::DistributedGet:
   case AccessorKind::Set:
   case AccessorKind::Read:
+  case AccessorKind::Read2:
   case AccessorKind::WillSet:
   case AccessorKind::DidSet:
   case AccessorKind::Address:
@@ -278,8 +282,11 @@ enum class ReadImplKind {
   /// There's an immutable addressor.
   Address,
 
-  /// There's a read coroutine.
+  /// There's a _read coroutine.
   Read,
+
+  /// There's a read coroutine.
+  Read2,
 };
 enum { NumReadImplKindBits = 4 };
 
@@ -392,29 +399,30 @@ class StorageImplInfo {
     case WriteImplKind::Set:
       assert(readImpl == ReadImplKind::Get ||
              readImpl == ReadImplKind::Address ||
-             readImpl == ReadImplKind::Read);
+             readImpl == ReadImplKind::Read || readImpl == ReadImplKind::Read2);
       assert(readWriteImpl == ReadWriteImplKind::MaterializeToTemporary ||
-             readWriteImpl == ReadWriteImplKind::Modify);
+             readWriteImpl == ReadWriteImplKind::Modify ||
+             readWriteImpl == ReadWriteImplKind::Modify2);
       return;
 
     case WriteImplKind::Modify:
       assert(readImpl == ReadImplKind::Get ||
              readImpl == ReadImplKind::Address ||
-             readImpl == ReadImplKind::Read);
+             readImpl == ReadImplKind::Read || readImpl == ReadImplKind::Read2);
       assert(readWriteImpl == ReadWriteImplKind::Modify);
       return;
 
     case WriteImplKind::Modify2:
       assert(readImpl == ReadImplKind::Get ||
              readImpl == ReadImplKind::Address ||
-             readImpl == ReadImplKind::Read);
+             readImpl == ReadImplKind::Read || readImpl == ReadImplKind::Read2);
       assert(readWriteImpl == ReadWriteImplKind::Modify2);
       return;
 
     case WriteImplKind::MutableAddress:
       assert(readImpl == ReadImplKind::Get ||
              readImpl == ReadImplKind::Address ||
-             readImpl == ReadImplKind::Read);
+             readImpl == ReadImplKind::Read || readImpl == ReadImplKind::Read2);
       assert(readWriteImpl == ReadWriteImplKind::MutableAddress);
       return;
     }
@@ -434,12 +442,13 @@ class StorageImplInfo {
                                    OpaqueReadOwnership ownership,
                                    const ASTContext &ctx) {
     return (isMutable ? getMutableOpaque(ownership, ctx)
-                      : getImmutableOpaque(ownership));
+                      : getImmutableOpaque(ownership, ctx));
   }
 
   /// Describe the implementation of a immutable property implemented opaquely.
-  static StorageImplInfo getImmutableOpaque(OpaqueReadOwnership ownership) {
-    return { getOpaqueReadImpl(ownership) };
+  static StorageImplInfo getImmutableOpaque(OpaqueReadOwnership ownership,
+                                            const ASTContext &ctx) {
+    return {getOpaqueReadImpl(ownership, ctx)};
   }
 
   /// Describe the implementation of a mutable property implemented opaquely.
@@ -492,7 +501,8 @@ class StorageImplInfo {
   }
 
 private:
-  static ReadImplKind getOpaqueReadImpl(OpaqueReadOwnership ownership);
+  static ReadImplKind getOpaqueReadImpl(OpaqueReadOwnership ownership,
+                                        const ASTContext &ctx);
 };
 
 llvm::StringRef getAccessorLabel(AccessorKind kind);

include/swift/Demangling/DemangleNodes.def

@@ -231,6 +231,7 @@ NODE(ReabstractionThunkHelper)
 NODE(ReabstractionThunkHelperWithSelf)
 NODE(ReabstractionThunkHelperWithGlobalActor)
 CONTEXT_NODE(ReadAccessor)
+CONTEXT_NODE(Read2Accessor)
 NODE(RelatedEntityDeclName)
 NODE(RetroactiveConformance)
 NODE(ReturnType)

lib/AST/ASTDumper.cpp

@@ -228,6 +228,8 @@ static StringRef getDumpString(ReadImplKind kind) {
     return "addressor";
   case ReadImplKind::Read:
     return "read_coroutine";
+  case ReadImplKind::Read2:
+    return "read2_coroutine";
   }
   llvm_unreachable("bad kind");
 }

lib/AST/ASTMangler.cpp

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

lib/AST/ASTPrinter.cpp

@@ -2539,6 +2539,13 @@ void PrintAST::printAccessors(const AbstractStorageDecl *ASD) {
     case ReadImplKind::Read:
       AddAccessorToPrint(AccessorKind::Read);
       break;
+    case ReadImplKind::Read2:
+      if (ASD->getAccessor(AccessorKind::Read) &&
+          shouldPrintUnderscoredCoroutineAccessors(ASD)) {
+        AddAccessorToPrint(AccessorKind::Read);
+      }
+      AddAccessorToPrint(AccessorKind::Read2);
+      break;
     }
     switch (impl.getWriteImpl()) {
     case WriteImplKind::Immutable:
@@ -4079,6 +4086,7 @@ void PrintAST::visitAccessorDecl(AccessorDecl *decl) {
   case AccessorKind::DistributedGet:
   case AccessorKind::Address:
   case AccessorKind::Read:
+  case AccessorKind::Read2:
   case AccessorKind::Modify:
   case AccessorKind::Modify2:
   case AccessorKind::DidSet:

lib/AST/ASTVerifier.cpp

@@ -3423,6 +3423,7 @@ class Verifier : public ASTWalker {
             // We allow a non dynamic getter if there is a dynamic read.
             !(FD->isGetter() &&
               (storageDecl->getReadImpl() == ReadImplKind::Read ||
+               storageDecl->getReadImpl() == ReadImplKind::Read2 ||
                storageDecl->getReadImpl() == ReadImplKind::Address) &&
               storageDecl->shouldUseNativeDynamicDispatch())) {
           Out << "Property and accessor do not match for 'dynamic'\n";

lib/AST/AccessRequests.cpp

@@ -56,6 +56,7 @@ AccessLevelRequest::evaluate(Evaluator &evaluator, ValueDecl *D) const {
     case AccessorKind::DistributedGet:
     case AccessorKind::Address:
     case AccessorKind::Read:
+    case AccessorKind::Read2:
       return storage->getFormalAccess();
     case AccessorKind::Set:
     case AccessorKind::MutableAddress: