Property delegates as custom attributes

docs/SIL.rst

@@ -2333,6 +2333,32 @@ with a sequence that also correctly destroys the current value.
 This instruction is only valid in Raw SIL and is rewritten as appropriate
 by the definitive initialization pass.
 
+assign_by_delegate
+``````````````````
+::
+
+  sil-instruction ::= 'assign_by_delegate' sil-operand 'to' sil-operand ',' 'init' sil-operand ',' 'set' sil-operand 
+
+  assign_by_delegate %0 : $S to %1 : $*T, init %2 : $F, set %3 : $G
+  // $S can be a value or address type
+  // $T must be the type of a property delegate.
+  // $F must be a function type, taking $S as a single argument and returning $T
+  // $G must be a function type, taking $S as a single argument and with not return value
+
+Similar to the ``assign`` instruction, but the assignment is done via a
+delegate.
+
+In case of an initialization, the function ``%2`` is called with ``%0`` as
+argument. The result is stored to ``%1``. In case ``%2`` is an address type,
+it is simply passed as a first out-argument to ``%2``.
+
+In case of a re-assignment, the function ``%3`` is called with ``%0`` as
+argument. As ``%3`` is a setter (e.g. for the property in the containing
+nominal type), the destination address ``%1`` is not used in this case.
+
+This instruction is only valid in Raw SIL and is rewritten as appropriate
+by the definitive initialization pass.
+
 mark_uninitialized
 ``````````````````
 ::

include/swift/AST/ASTContext.h

@@ -833,6 +833,13 @@ class ASTContext final {
                                               const IterableDeclContext *idc,
                                               LazyMemberLoader *lazyLoader);
 
+  /// Access the side cache for property delegate backing property types,
+  /// used because TypeChecker::typeCheckBinding() needs somewhere to stash
+  /// the backing property type.
+  Type getSideCachedPropertyDelegateBackingPropertyType(VarDecl *var) const;
+  void setSideCachedPropertyDelegateBackingPropertyType(VarDecl *var,
+                                                        Type type);
+
   /// Returns memory usage of this ASTContext.
   size_t getTotalMemory() const;
 

include/swift/AST/ASTTypeIDZone.def

@@ -16,4 +16,7 @@
 //===----------------------------------------------------------------------===//
 SWIFT_TYPEID_NAMED(NominalTypeDecl *, NominalTypeDecl)
 SWIFT_TYPEID_NAMED(VarDecl *, VarDecl)
-SWIFT_TYPEID(PropertyBehaviorTypeInfo)
+SWIFT_TYPEID(Type)
+SWIFT_TYPEID(PropertyDelegateBackingPropertyInfo)
+SWIFT_TYPEID(PropertyDelegateTypeInfo)
+SWIFT_TYPEID_NAMED(CustomAttr *, CustomAttr)

include/swift/AST/ASTTypeIDs.h

@@ -20,8 +20,11 @@
 #include "swift/Basic/TypeID.h"
 namespace swift {
 
+class CustomAttr;
 class NominalTypeDecl;
-struct PropertyBehaviorTypeInfo;
+struct PropertyDelegateBackingPropertyInfo;
+struct PropertyDelegateTypeInfo;
+class Type;
 class VarDecl;
 
 #define SWIFT_AST_TYPEID_ZONE 1

include/swift/AST/Attr.def

@@ -399,6 +399,9 @@ SIMPLE_DECL_ATTR(_implementationOnly, ImplementationOnly,
 DECL_ATTR(_custom, Custom,
   OnAnyDecl | UserInaccessible,
   85)
+SIMPLE_DECL_ATTR(_propertyDelegate, PropertyDelegate,
+  OnStruct | OnClass | OnEnum,
+  86)
 
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS

include/swift/AST/Attr.h

@@ -1428,6 +1428,7 @@ class CustomAttr final : public DeclAttribute,
   TypeLoc type;
   Expr *arg;
   PatternBindingInitializer *initContext;
+  Expr *semanticInit = nullptr;
 
   unsigned hasArgLabelLocs : 1;
   unsigned numArgLabels : 16;
@@ -1463,6 +1464,9 @@ class CustomAttr final : public DeclAttribute,
   Expr *getArg() const { return arg; }
   void setArg(Expr *newArg) { arg = newArg; }
 
+  Expr *getSemanticInit() const { return semanticInit; }
+  void setSemanticInit(Expr *expr) { semanticInit = expr; }
+
   PatternBindingInitializer *getInitContext() const { return initContext; }
 
   static bool classof(const DeclAttribute *DA) {

include/swift/AST/CaptureInfo.h

@@ -17,6 +17,7 @@
 #include "swift/AST/TypeAlignments.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/PointerIntPair.h"
+#include "llvm/ADT/PointerUnion.h"
 #include <vector>
 
 namespace swift {
@@ -31,13 +32,20 @@ template <> struct DenseMapInfo<swift::CapturedValue>;
 namespace swift {
 class ValueDecl;
 class FuncDecl;
+class OpaqueValueExpr;
 
 /// CapturedValue includes both the declaration being captured, along with flags
 /// that indicate how it is captured.
 class CapturedValue {
-  llvm::PointerIntPair<ValueDecl*, 2, unsigned> Value;
+public:
+  using Storage =
+      llvm::PointerIntPair<llvm::PointerUnion<ValueDecl*, OpaqueValueExpr*>, 2,
+                           unsigned>;
+
+private:
+  Storage Value;
 
-  explicit CapturedValue(llvm::PointerIntPair<ValueDecl*, 2, unsigned> V) : Value(V) {}
+  explicit CapturedValue(Storage V) : Value(V) {}
 
 public:
   friend struct llvm::DenseMapInfo<CapturedValue>;
@@ -53,16 +61,21 @@ class CapturedValue {
     IsNoEscape = 1 << 1
   };
 
-  CapturedValue(ValueDecl *D, unsigned Flags) : Value(D, Flags) {}
+  CapturedValue(llvm::PointerUnion<ValueDecl*, OpaqueValueExpr*> Ptr,
+                unsigned Flags)
+      : Value(Ptr, Flags) {}
 
   static CapturedValue getDynamicSelfMetadata() {
-    return CapturedValue(nullptr, 0);
+    return CapturedValue((ValueDecl *)nullptr, 0);
   }
 
   bool isDirect() const { return Value.getInt() & IsDirect; }
   bool isNoEscape() const { return Value.getInt() & IsNoEscape; }
 
   bool isDynamicSelfMetadata() const { return !Value.getPointer(); }
+  bool isOpaqueValue() const {
+    return Value.getPointer().is<OpaqueValueExpr *>();
+  }
 
   CapturedValue mergeFlags(CapturedValue cv) {
     assert(Value.getPointer() == cv.Value.getPointer() &&
@@ -73,7 +86,13 @@ class CapturedValue {
   ValueDecl *getDecl() const {
     assert(Value.getPointer() && "dynamic Self metadata capture does not "
            "have a value");
-    return Value.getPointer();
+    return Value.getPointer().dyn_cast<ValueDecl *>();
+  }
+
+  OpaqueValueExpr *getOpaqueValue() const {
+    assert(Value.getPointer() && "dynamic Self metadata capture does not "
+           "have a value");
+    return Value.getPointer().dyn_cast<OpaqueValueExpr *>();
   }
 
   unsigned getFlags() const { return Value.getInt(); }
@@ -98,8 +117,7 @@ namespace llvm {
 template <> struct DenseMapInfo<swift::CapturedValue> {
   using CapturedValue = swift::CapturedValue;
 
-  using PtrIntPairDenseMapInfo =
-      DenseMapInfo<llvm::PointerIntPair<swift::ValueDecl *, 2, unsigned>>;
+  using PtrIntPairDenseMapInfo = DenseMapInfo<CapturedValue::Storage>;
 
   static inline swift::CapturedValue getEmptyKey() {
     return CapturedValue{PtrIntPairDenseMapInfo::getEmptyKey()};
@@ -128,19 +146,20 @@ class DynamicSelfType;
 class CaptureInfo {
   const CapturedValue *Captures;
   DynamicSelfType *DynamicSelf;
+  OpaqueValueExpr *OpaqueValue;
   unsigned Count = 0;
   bool GenericParamCaptures : 1;
   bool Computed : 1;
 
 public:
   CaptureInfo()
-    : Captures(nullptr), DynamicSelf(nullptr), Count(0),
+    : Captures(nullptr), DynamicSelf(nullptr), OpaqueValue(nullptr), Count(0),
       GenericParamCaptures(0), Computed(0) { }
 
   bool hasBeenComputed() { return Computed; }
 
   bool isTrivial() {
-    return Count == 0 && !GenericParamCaptures && !DynamicSelf;
+    return Count == 0 && !GenericParamCaptures && !DynamicSelf && !OpaqueValue;
   }
 
   ArrayRef<CapturedValue> getCaptures() const {
@@ -184,6 +203,18 @@ class CaptureInfo {
     DynamicSelf = dynamicSelf;
   }
 
+  bool hasOpaqueValueCapture() const {
+    return OpaqueValue != nullptr;
+  }
+
+  OpaqueValueExpr *getOpaqueValue() const {
+    return OpaqueValue;
+  }
+
+  void setOpaqueValue(OpaqueValueExpr *OVE) {
+    OpaqueValue = OVE;
+  }
+
   void dump() const;
   void print(raw_ostream &OS) const;
 };