Merge pull request #18156 from rjmccall/generalized-accessors

Implement generalized accessors using yield-once coroutines

Author: rjmccall

docs/ABI/Mangling.rst

@@ -223,10 +223,12 @@ Entities
   ACCESSOR ::= 'G'                           // global getter
   ACCESSOR ::= 'w'                           // willSet
   ACCESSOR ::= 'W'                           // didSet
+  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
-                                         
+
   ADDRESSOR-KIND ::= 'u'                     // unsafe addressor (no owner)
   ADDRESSOR-KIND ::= 'O'                     // owning addressor (non-native owner)
   ADDRESSOR-KIND ::= 'o'                     // owning addressor (native owner)

include/swift/AST/AccessorKinds.def

@@ -65,6 +65,14 @@
 #define OBJC_ACCESSOR(ID, KEYWORD) OPAQUE_ACCESSOR(ID, KEYWORD)
 #endif
 
+/// COROUTINE_ACCESSOR(ID, KEYWORD)
+///   The given accessor is a coroutine accessor, i.e. a reader or modifier.
+///
+///   Defaults to SINGLETON_ACCESSOR(ID, KEYWORD).
+#ifndef COROUTINE_ACCESSOR
+#define COROUTINE_ACCESSOR(ID, KEYWORD) SINGLETON_ACCESSOR(ID, KEYWORD)
+#endif
+
 /// ANY_ADDRESSOR(ACCESSOR_ID, ADDRESSOR_ID, KEYWORD)
 ///   The given keyword corresponds to an addressor of the given kind.
 ///
@@ -148,6 +156,24 @@ OBSERVING_ACCESSOR(WillSet, willSet)
 /// setter idiom.
 OBSERVING_ACCESSOR(DidSet, didSet)
 
+/// This is a read accessor: a 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).
+COROUTINE_ACCESSOR(Read, _read)
+
+/// This is a modify accessor: a coroutine which is called when a
+/// the storage is assigned to (like a setter) or read-modified
+/// (like materializeForSet), but 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.
+/// Modify accessors are intended to eventually replace materializeForSet.
+COROUTINE_ACCESSOR(Modify, _modify)
+
 /// This is an address-family accessor: a function that is called when
 /// a value is loaded from the storage, like a getter, but which works
 /// by returning a pointer to an immutable value of the storage type.
@@ -189,6 +215,7 @@ LAST_ACCESSOR(MutableAddress)
 #undef ANY_ADDRESSOR
 #undef OBJC_ACCESSOR
 #undef OPAQUE_ACCESSOR
+#undef COROUTINE_ACCESSOR
 #undef OBSERVING_ACCESSOR
 #undef SINGLETON_ACCESSOR
 #undef ACCESSOR

include/swift/AST/AnyFunctionRef.h

@@ -83,6 +83,31 @@ class AnyFunctionRef {
     return TheFunction.get<AbstractClosureExpr *>()->getResultType();
   }
 
+  struct YieldResult {
+    Type Ty;
+    VarDecl::Specifier Specifier;
+  };
+
+  ArrayRef<YieldResult>
+  getBodyYieldResults(SmallVectorImpl<YieldResult> &buffer) const {
+    assert(buffer.empty());
+    if (auto *AFD = TheFunction.dyn_cast<AbstractFunctionDecl *>()) {
+      if (auto *AD = dyn_cast<AccessorDecl>(AFD)) {
+        if (AD->isCoroutine()) {
+          auto valueTy = AD->getStorage()->getValueInterfaceType();
+          valueTy = AD->mapTypeIntoContext(valueTy);
+          auto specifier =
+            AD->getAccessorKind() == AccessorKind::Modify
+              ? VarDecl::Specifier::InOut
+              : VarDecl::Specifier::Shared;
+          buffer.push_back({valueTy, specifier});
+          return buffer;
+        }
+      }
+    }
+    return {};
+  }
+
   BraceStmt *getBody() const {
     if (auto *AFD = TheFunction.dyn_cast<AbstractFunctionDecl *>())
       return AFD->getBody();

include/swift/AST/Decl.h

@@ -151,6 +151,8 @@ enum class DescriptiveDeclKind : uint8_t {
   MaterializeForSet,
   Addressor,
   MutableAddressor,
+  ReadAccessor,
+  ModifyAccessor,
   WillSet,
   DidSet,
   EnumElement,
@@ -428,9 +430,9 @@ class alignas(1 << DeclAlignInBits) Decl {
     SelfAccess : 2
   );
 
-  SWIFT_INLINE_BITFIELD(AccessorDecl, FuncDecl, 3+3,
+  SWIFT_INLINE_BITFIELD(AccessorDecl, FuncDecl, 4+3,
     /// The kind of accessor this is.
-    AccessorKind : 3,
+    AccessorKind : 4,
 
     /// The kind of addressor this is.
     AddressorKind : 3
@@ -4334,8 +4336,7 @@ class AbstractStorageDecl : public ValueDecl {
     return getAccessor(AccessorKind::Address);
   }
 
-  /// \brief Return the decl for the 'mutableAddress' accessors if
-  /// it exists; this is only valid on a declaration with addressors.
+  /// \brief Return the decl for the mutable accessor if it exists.
   AccessorDecl *getMutableAddressor() const {
     return getAccessor(AccessorKind::MutableAddress);
   }
@@ -4346,7 +4347,17 @@ class AbstractStorageDecl : public ValueDecl {
       return getAddressor();
     return getMutableAddressor();
   }
-  
+
+  /// \brief Return the decl for the 'read' coroutine accessor if it exists.
+  AccessorDecl *getReadCoroutine() const {
+    return getAccessor(AccessorKind::Read);
+  }
+
+  /// \brief Return the decl for the 'modify' coroutine accessor if it exists.
+  AccessorDecl *getModifyCoroutine() const {
+    return getAccessor(AccessorKind::Modify);
+  }
+
   /// \brief Return the decl for the willSet specifier if it exists, this is
   /// only valid on a declaration with Observing storage.
   AccessorDecl *getWillSetFunc() const {
@@ -5626,8 +5637,26 @@ class AccessorDecl final : public FuncDecl {
   bool isGetterOrSetter() const { return isGetter() || isSetter(); }
 
   bool isObservingAccessor() const {
-    return getAccessorKind() == AccessorKind::DidSet ||
-           getAccessorKind() == AccessorKind::WillSet;
+    switch (getAccessorKind()) {
+#define OBSERVING_ACCESSOR(ID, KEYWORD) \
+    case AccessorKind::ID: return true;
+#define ACCESSOR(ID) \
+    case AccessorKind::ID: return false;
+#include "swift/AST/AccessorKinds.def"
+    }
+    llvm_unreachable("bad accessor kind");
+  }
+
+  /// Is this accessor one of the kinds that's implicitly a coroutine?
+  bool isCoroutine() const {
+    switch (getAccessorKind()) {
+#define COROUTINE_ACCESSOR(ID, KEYWORD) \
+    case AccessorKind::ID: return true;
+#define ACCESSOR(ID) \
+    case AccessorKind::ID: return false;
+#include "swift/AST/AccessorKinds.def"
+    }
+    llvm_unreachable("bad accessor kind");
   }
 
   static bool classof(const Decl *D) {

include/swift/AST/DiagnosticsParse.def

@@ -262,8 +262,6 @@ ERROR(duplicate_accessor,none,
 ERROR(conflicting_accessor,none,
       "%select{variable|subscript}0 cannot provide both %1 and %2",
       (unsigned, StringRef, StringRef))
-ERROR(modify_mutatingness_different_from_setter,none,
-      "mutating-ness of 'modify' accessor cannot differ from setter", ())
 NOTE(previous_accessor,none,
      "%select{|previous definition of }1%0 %select{defined |}1here", (StringRef, bool))
 ERROR(expected_accessor_name,none,
@@ -285,7 +283,7 @@ ERROR(missing_getter,none,
       (unsigned, StringRef))
 ERROR(missing_reading_accessor,none,
       "%select{variable|subscript}0 with %1 must also have "
-      "a getter or an addressor",
+      "a getter, addressor, or 'read' accessor",
       (unsigned, StringRef))
 ERROR(observing_accessor_conflicts_with_accessor,none,
       "%select{'willSet'|'didSet'}0 cannot be provided together with %1",
@@ -938,6 +936,10 @@ NOTE(indent_expression_to_silence,none,
 ERROR(expected_expr_throw,PointsToFirstBadToken,
       "expected expression in 'throw' statement", ())
 
+// Yield Statment
+ERROR(expected_expr_yield,PointsToFirstBadToken,
+      "expected expression in 'yield' statement", ())
+
 // Defer Statement
 ERROR(expected_lbrace_after_defer,PointsToFirstBadToken,
       "expected '{' after 'defer'", ())
@@ -1061,9 +1063,9 @@ ERROR(case_stmt_without_body,none,
 // 'try' on statements
 ERROR(try_on_stmt,none,
       "'try' cannot be used with '%0'", (StringRef))
-ERROR(try_on_return_throw,none,
-      "'try' must be placed on the %select{returned|thrown}0 expression",
-      (bool))
+ERROR(try_on_return_throw_yield,none,
+      "'try' must be placed on the %select{returned|thrown|yielded}0 expression",
+      (unsigned))
 ERROR(try_on_var_let,none,
       "'try' must be placed on the initial value expression", ())
 

include/swift/AST/DiagnosticsSema.def

@@ -336,6 +336,9 @@ ERROR(cannot_throw_error_code,none,
       "thrown error code type %0 does not conform to 'Error'; construct an %1 "
       "instance", (Type, Type))
 
+ERROR(bad_yield_count,none,
+      "expected %0 yield value(s)", (unsigned))
+
 ERROR(cannot_throw_nil,none,
       "cannot infer concrete Error for thrown 'nil' value", ())
 
@@ -368,6 +371,23 @@ ERROR(cannot_convert_partial_argument_value_protocol,none,
 ERROR(cannot_convert_argument_value_nil,none,
       "'nil' is not compatible with expected argument type %0", (Type))
 
+ERROR(cannot_yield_rvalue_by_reference_same_type,none,
+      "cannot yield immutable value of type %0 as an inout yield", (Type))
+ERROR(cannot_yield_rvalue_by_reference,none,
+      "cannot yield immutable value of type %0 as an inout yield of type %1",
+      (Type,Type))
+ERROR(cannot_yield_wrong_type_by_reference,none,
+      "cannot yield reference to storage of type %0 as an inout yield of type %1",
+      (Type,Type))
+ERROR(cannot_convert_yield_value,none,
+      "cannot convert value of type %0 to expected yield type %1",
+      (Type,Type))
+ERROR(cannot_convert_yield_value_protocol,none,
+      "yielded type %0 does not conform to expected type %1",
+      (Type,Type))
+ERROR(cannot_convert_yield_value_nil,none,
+      "nil is not compatible with expected yield type %0", (Type))
+
 ERROR(cannot_convert_closure_result,none,
       "cannot convert value of type %0 to closure result type %1",
       (Type,Type))
@@ -924,6 +944,9 @@ ERROR(missing_explicit_conversion,none,
 ERROR(missing_address_of,none,
       "passing value of type %0 to an inout parameter requires explicit '&'",
       (Type))
+ERROR(missing_address_of_yield,none,
+      "yielding mutable value of type %0 requires explicit '&'",
+      (Type))
 ERROR(extraneous_address_of,none,
       "use of extraneous '&'",
       ())
@@ -1079,6 +1102,10 @@ ERROR(functions_mutating_and_not,none,
 ERROR(static_functions_not_mutating,none,
       "static functions must not be declared mutating", ())
 
+ERROR(modify_mutatingness_differs_from_setter,none,
+      "'modify' accessor cannot be %select{nonmutating|mutating}0 "
+      "when the setter is %select{mutating|nonmutating}0", (bool))
+
 ERROR(transparent_in_protocols_not_supported,none,
       "'@_transparent' attribute is not supported on declarations within protocols", ())
 ERROR(transparent_in_classes_not_supported,none,
@@ -3632,6 +3659,8 @@ ERROR(objc_observing_accessor, none,
       "observing accessors are not allowed to be marked @objc", ())
 ERROR(objc_addressor, none,
       "addressors are not allowed to be marked @objc", ())
+ERROR(objc_coroutine_accessor, none,
+      "'read' and 'modify' accessors are not allowed to be marked @objc", ())
 ERROR(objc_invalid_on_func_variadic,none,
       "method cannot be %" OBJC_ATTR_SELECT "0 because it has a variadic "
       "parameter", (unsigned))

include/swift/AST/Stmt.h

@@ -84,6 +84,11 @@ class alignas(8) Stmt {
     CaseCount : 32
   );
 
+  SWIFT_INLINE_BITFIELD_FULL(YieldStmt, Stmt, 32,
+    : NumPadBits,
+    NumYields : 32
+  );
+
   } Bits;
 
   /// Return the given value for the 'implicit' flag if present, or if None,
@@ -209,7 +214,48 @@ class ReturnStmt : public Stmt {
 
   static bool classof(const Stmt *S) { return S->getKind() == StmtKind::Return;}
 };
+
+/// YieldStmt - A yield statement.  The yield-values sequence is not optional,
+/// but the parentheses are.
+///    yield 42
+class YieldStmt final
+    : public Stmt, private llvm::TrailingObjects<YieldStmt, Expr*> {
+  friend TrailingObjects;
+
+  SourceLoc YieldLoc;
+  SourceLoc LPLoc;
+  SourceLoc RPLoc;
+
+  YieldStmt(SourceLoc yieldLoc, SourceLoc lpLoc, ArrayRef<Expr *> yields,
+            SourceLoc rpLoc, Optional<bool> implicit = None)
+    : Stmt(StmtKind::Yield, getDefaultImplicitFlag(implicit, yieldLoc)),
+      YieldLoc(yieldLoc), LPLoc(lpLoc), RPLoc(rpLoc) {
+    Bits.YieldStmt.NumYields = yields.size();
+    memcpy(getMutableYields().data(), yields.data(),
+           yields.size() * sizeof(Expr*));
+  }
+
+public:
+  static YieldStmt *create(const ASTContext &ctx, SourceLoc yieldLoc,
+                           SourceLoc lp, ArrayRef<Expr*> yields, SourceLoc rp);
+
+  SourceLoc getYieldLoc() const { return YieldLoc; }
+  SourceLoc getLParenLoc() const { return LPLoc; }
+  SourceLoc getRParenLoc() const { return RPLoc; }
+
+  SourceLoc getStartLoc() const { return YieldLoc; }
+  SourceLoc getEndLoc() const;
+
+  ArrayRef<Expr*> getYields() const {
+    return {getTrailingObjects<Expr*>(), Bits.YieldStmt.NumYields};
+  }
+  MutableArrayRef<Expr*> getMutableYields() {
+    return {getTrailingObjects<Expr*>(), Bits.YieldStmt.NumYields};
+  }
 
+  static bool classof(const Stmt *S) { return S->getKind() == StmtKind::Yield; }
+};
+
 /// DeferStmt - A 'defer' statement.  This runs the substatement it contains
 /// when the enclosing scope is exited.
 ///

include/swift/AST/StmtNodes.def

@@ -46,6 +46,7 @@
 
 STMT(Brace, Stmt)
 STMT(Return, Stmt)
+STMT(Yield, Stmt)
 STMT(Defer, Stmt)
 ABSTRACT_STMT(Labeled, Stmt)
   ABSTRACT_STMT(LabeledConditional, LabeledStmt)