[Parse/Sema/SIL] Implement init accessors feature

- Adds a new kind of accessor - init accessor - which could be used
  to initialize one or more stored properties of the type.
  - Just like getter and setter accessors, init accessor could be used
    on any computed property.
  - Init accessors can specify a set of properties they initialize and
    accesses (property that should be initialized already) via declaration
    attributes - `initializes` and `accesses`;

  - Example of init accessor that initializes a stored property:
    ```swift
    public struct Test {
      private var _a: Int

      public var a: Int {
        init(initialValue) initializes(_a) {
          _a = initialValue
        }

        get { _a }
        set { _a = newValue }
      }
    }
    ```

- Modifies memberwise initializers to take advantage of this new
  mechanism by replacing one or more stored property parameters with
  corresponding init accessor(s).
  - `struct Test` from previous example would get `init(a: Int) { self.a = a }`.

- Adds a new SIL instruction - `assign_or_init`; Similar to `assign_by_wrapper`
  the "mode" is set by DI based on each use site.
  - New intruction also tracks "assignments" - fields that have been
    previously initialized and would re-assigned by invocation of init
    accessor, it enables as to call init accessors multiple times even
    before all fields have been initializes.

- When used in an initializer body, init accessor (i.e. `self.a = a`)
  call becomes either an initialization (if all of the fields haven't
  been initialized yet), or a call to setter.

Author: hborla

include/swift/AST/AccessorKinds.def

@@ -100,6 +100,14 @@
   ANY_ADDRESSOR(ID, KEYWORD)
 #endif
 
+/// INIT_ACCESSOR(ID, KEYWORD)
+///   The given accessor is an init accessor.
+///
+///   Defaults to SINGLETON_ACCESSOR(ID, KEYWORD).
+#ifndef INIT_ACCESSOR
+#define INIT_ACCESSOR(ID, KEYWORD) SINGLETON_ACCESSOR(ID, KEYWORD)
+#endif
+
 // Suppress entries for accessors which can't be written in source code.
 #ifndef SUPPRESS_ARTIFICIAL_ACCESSORS
 #define SUPPRESS_ARTIFICIAL_ACCESSORS 0
@@ -174,11 +182,16 @@ IMMUTABLE_ADDRESSOR(Address, unsafeAddress)
 /// of the type).
 MUTABLE_ADDRESSOR(MutableAddress, unsafeMutableAddress)
 
+/// This is an init accessor: a function that is called when DI
+/// re-writes assignment to initialization.
+INIT_ACCESSOR(Init, init)
+
 #ifdef LAST_ACCESSOR
-LAST_ACCESSOR(MutableAddress)
+LAST_ACCESSOR(Init)
 #undef LAST_ACCESSOR
 #endif
 
+#undef INIT_ACCESSOR
 #undef IMMUTABLE_ADDRESSOR
 #undef MUTABLE_ADDRESSOR
 #undef ANY_ADDRESSOR

include/swift/AST/Attr.h

@@ -55,6 +55,7 @@ class Decl;
 class AbstractFunctionDecl;
 class FuncDecl;
 class ClassDecl;
+class AccessorDecl;
 class GenericFunctionType;
 class LazyConformanceLoader;
 class LazyMemberLoader;
@@ -1530,6 +1531,68 @@ class SpecializeAttr final
   }
 };
 
+class InitializesAttr final
+    : public DeclAttribute,
+      private llvm::TrailingObjects<InitializesAttr, Identifier> {
+  friend TrailingObjects;
+
+  size_t numProperties;
+
+  InitializesAttr(SourceLoc atLoc, SourceRange range,
+                  ArrayRef<Identifier> properties);
+
+public:
+  static InitializesAttr *create(ASTContext &ctx,
+                                 SourceLoc atLoc, SourceRange range,
+                                 ArrayRef<Identifier> properties);
+
+  size_t numTrailingObjects(OverloadToken<Identifier>) const {
+    return numProperties;
+  }
+
+  unsigned getNumProperties() const { return numProperties; }
+
+  ArrayRef<Identifier> getProperties() const {
+    return {getTrailingObjects<Identifier>(), numProperties};
+  }
+
+  ArrayRef<VarDecl *> getPropertyDecls(AccessorDecl *attachedTo) const;
+
+  static bool classof(const DeclAttribute *DA) {
+    return DA->getKind() == DAK_Initializes;
+  }
+};
+
+class AccessesAttr final
+    : public DeclAttribute,
+      private llvm::TrailingObjects<AccessesAttr, Identifier> {
+  friend TrailingObjects;
+
+  size_t numProperties;
+
+  AccessesAttr(SourceLoc atLoc, SourceRange range,
+               ArrayRef<Identifier> properties);
+
+public:
+  static AccessesAttr *create(ASTContext &ctx,
+                              SourceLoc atLoc, SourceRange range,
+                              ArrayRef<Identifier> properties);
+
+  size_t numTrailingObjects(OverloadToken<Identifier>) const {
+    return numProperties;
+  }
+
+  ArrayRef<Identifier> getProperties() const {
+    return {getTrailingObjects<Identifier>(), numProperties};
+  }
+
+  ArrayRef<VarDecl *> getPropertyDecls(AccessorDecl *attachedTo) const;
+
+  static bool classof(const DeclAttribute *DA) {
+    return DA->getKind() == DAK_Accesses;
+  }
+};
+
 /// The @_implements attribute, which treats a decl as the implementation for
 /// some named protocol requirement (but otherwise not-visible by that name).
 class ImplementsAttr : public DeclAttribute {

include/swift/AST/Decl.h

@@ -46,6 +46,7 @@
 #include "swift/Basic/Range.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/Support/TrailingObjects.h"
+#include <map>
 #include <type_traits>
 
 namespace swift {
@@ -183,6 +184,7 @@ enum class DescriptiveDeclKind : uint8_t {
   DistributedMethod,
   Getter,
   Setter,
+  InitAccessor,
   Addressor,
   MutableAddressor,
   ReadAccessor,
@@ -3979,6 +3981,16 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   /// Return a collection of the stored member variables of this type.
   ArrayRef<VarDecl *> getStoredProperties() const;
 
+  /// Return a collection of all properties with init accessors in
+  /// this type.
+  ArrayRef<VarDecl *> getInitAccessorProperties() const;
+
+  /// Establish a mapping between properties that could be iniitalized
+  /// via other properties by means of init accessors. This mapping is
+  /// one-to-many because we allow intersecting `initializes(...)`.
+  void collectPropertiesInitializableByInitAccessors(
+      std::multimap<VarDecl *, VarDecl *> &result) const;
+
   /// Return a collection of the stored member variables of this type, along
   /// with placeholders for unimportable stored properties.
   ArrayRef<Decl *> getStoredPropertiesAndMissingMemberPlaceholders() const;
@@ -7564,6 +7576,10 @@ class AccessorDecl final : public FuncDecl {
     llvm_unreachable("bad accessor kind");
   }
 
+  bool isInitAccessor() const {
+    return (getAccessorKind() == AccessorKind::Init);
+  }
+
   /// \returns true if this is non-mutating due to applying a 'mutating'
   /// attribute. For example a "mutating set" accessor.
   bool isExplicitNonMutating() const;

include/swift/AST/DiagnosticsParse.def

@@ -309,6 +309,9 @@ ERROR(observing_accessor_in_subscript,none,
 ERROR(getset_cannot_be_implied,none,
       "variable with implied type cannot have implied getter/setter", ())
 
+ERROR(init_accessor_expected_name,none,
+      "expected property name in init accessor effect", ())
+
 // Import
 ERROR(decl_expected_module_name,none,
       "expected module name in import declaration", ())
@@ -2116,5 +2119,13 @@ ERROR(sil_markuncheckedreferencebinding_requires_attribute,none,
 ERROR(sil_markuncheckedreferencebinding_invalid_attribute,none,
       "Attribute '[%0]' can not be applied to mark_unchecked_reference_binding", (StringRef))
 
+//------------------------------------------------------------------------------
+// MARK: Init accessors
+//------------------------------------------------------------------------------
+
+ERROR(init_accessor_is_not_on_property,none,
+      "init accessors could only be associated with properties",
+      ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/DiagnosticsSIL.def

@@ -189,6 +189,9 @@ ERROR(ivar_not_initialized_at_superinit,none,
 ERROR(ivar_not_initialized_at_implicit_superinit,none,
       "property '%0' not initialized at implicitly generated super.init call",
       (StringRef, bool))
+ERROR(ivar_not_initialized_by_init_accessor,none,
+      "property %0 not initialized by init accessor",
+      (DeclName))
 
 ERROR(self_use_before_fully_init,none,
       "'self' used in %select{method call|property access}1 %0 before "

include/swift/AST/DiagnosticsSema.def

@@ -5807,6 +5807,8 @@ ERROR(no_opaque_return_type_of,none,
 
 ERROR(objc_observing_accessor, none,
       "observing accessors are not allowed to be marked @objc", ())
+ERROR(objc_init_accessor, none,
+      "init accessors cannot be marked @objc", ())
 ERROR(objc_addressor, none,
       "addressors are not allowed to be marked @objc", ())
 ERROR(objc_coroutine_accessor, none,
@@ -7226,6 +7228,25 @@ NOTE(opt_out_from_missing_reflection_metadata_attr,none,
      " unavailable extension",
      (StringRef))
 
+//------------------------------------------------------------------------------
+// MARK: Init accessors
+//------------------------------------------------------------------------------
+
+ERROR(init_accessor_can_refer_only_to_properties,none,
+      "init accessor cannot refer to %0 %1; init accessors can refer only"
+      " to stored properties",
+      (DescriptiveDeclKind, DeclNameRef))
+
+ERROR(init_accessor_initializes_attribute_on_other_declaration,none,
+      "initalizes(...) attribute could only be used with init accessors",
+      ())
+ERROR(init_accessor_accesses_attribute_on_other_declaration,none,
+      "accesses(...) attribute could only be used with init accessors",
+      ())
+ERROR(init_accessor_property_both_init_and_accessed,none,
+      "property %0 cannot be both initialized and accessed",
+      (DeclName))
+
 
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/TypeCheckRequests.h

@@ -1671,6 +1671,25 @@ class StoredPropertiesAndMissingMembersRequest :
   bool isCached() const { return true; }
 };
 
+/// Request to obtain a list of computed properties with init accesors
+/// in the given nominal type.
+class InitAccessorPropertiesRequest :
+    public SimpleRequest<InitAccessorPropertiesRequest,
+                         ArrayRef<VarDecl *>(NominalTypeDecl *),
+                         RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  ArrayRef<VarDecl *>
+  evaluate(Evaluator &evaluator, NominalTypeDecl *decl) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 class StorageImplInfoRequest :
     public SimpleRequest<StorageImplInfoRequest,
                          StorageImplInfo(AbstractStorageDecl *),
@@ -4274,6 +4293,25 @@ class IsNonUserModuleRequest
   bool isCached() const { return true; }
 };
 
+class InitAccessorReferencedVariablesRequest
+    : public SimpleRequest<InitAccessorReferencedVariablesRequest,
+                           ArrayRef<VarDecl *>(DeclAttribute *, AccessorDecl *,
+                                               ArrayRef<Identifier>),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  ArrayRef<VarDecl *> evaluate(Evaluator &evaluator, DeclAttribute *attr,
+                               AccessorDecl *attachedTo,
+                               ArrayRef<Identifier>) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 #define SWIFT_TYPEID_ZONE TypeChecker
 #define SWIFT_TYPEID_HEADER "swift/AST/TypeCheckerTypeIDZone.def"
 #include "swift/Basic/DefineTypeIDZone.h"

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -306,6 +306,9 @@ SWIFT_REQUEST(TypeChecker, StoredPropertiesAndMissingMembersRequest,
               ArrayRef<Decl *>(NominalTypeDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, StoredPropertiesRequest,
               ArrayRef<VarDecl *>(NominalTypeDecl *), Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, InitAccessorPropertiesRequest,
+              ArrayRef<VarDecl *>(NominalTypeDecl *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, StructuralTypeRequest, Type(TypeAliasDecl *), Cached,
               NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, SuperclassTypeRequest,
@@ -481,3 +484,7 @@ SWIFT_REQUEST(TypeChecker, IsNonUserModuleRequest,
 SWIFT_REQUEST(TypeChecker, TypeCheckObjCImplementationRequest,
               unsigned(ExtensionDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, InitAccessorReferencedVariablesRequest,
+              ArrayRef<VarDecl *>(DeclAttribute *, AccessorDecl *,
+                                  ArrayRef<Identifier>),
+              Cached, NoLocationInfo)

include/swift/Basic/Features.def

@@ -119,6 +119,7 @@ EXPERIMENTAL_FEATURE(NamedOpaqueTypes, false)
 EXPERIMENTAL_FEATURE(FlowSensitiveConcurrencyCaptures, false)
 EXPERIMENTAL_FEATURE(CodeItemMacros, true)
 EXPERIMENTAL_FEATURE(TupleConformances, false)
+EXPERIMENTAL_FEATURE(InitAccessors, false)
 
 // FIXME: MoveOnlyClasses is not intended to be in production,
 // but our tests currently rely on it, and we want to run those

include/swift/Demangling/DemangleNodes.def

@@ -143,6 +143,7 @@ NODE(ImplErrorResult)
 NODE(InOut)
 NODE(InfixOperator)
 CONTEXT_NODE(Initializer)
+CONTEXT_NODE(InitAccessor)
 NODE(Isolated)
 NODE(KeyPathGetterThunkHelper)
 NODE(KeyPathSetterThunkHelper)

include/swift/Parse/Parser.h

@@ -1265,6 +1265,10 @@ class Parser {
                                        AccessorKind currentKind,
                                        SourceLoc const& currentLoc);
 
+  ParserStatus parseInitAccessorEffects(ParsedAccessors &accessors,
+                                        AccessorKind currentKind,
+                                        DeclAttributes &Attributes);
+
   /// Parse accessors provided as a separate list, for use in macro
   /// expansions.
   void parseTopLevelAccessors(

include/swift/SIL/InstructionUtils.h

@@ -145,6 +145,10 @@ SILValue isPartialApplyOfReabstractionThunk(PartialApplyInst *PAI);
 /// init or set function.
 bool onlyUsedByAssignByWrapper(PartialApplyInst *PAI);
 
+/// Returns true if \p PAI is only used by an \c assign_or_init
+/// instruction as init or set function.
+bool onlyUsedByAssignOrInit(PartialApplyInst *PAI);
+
 /// Returns the runtime effects of \p inst.
 ///
 /// Predicts which runtime calls are called in the generated code for `inst`.

include/swift/SIL/SILBuilder.h

@@ -955,6 +955,14 @@ class SILBuilder {
         getSILDebugLocation(Loc), Src, Dest, Initializer, Setter, mode));
   }
 
+  AssignOrInitInst *createAssignOrInit(SILLocation Loc, SILValue Src,
+                                       SILValue Initializer,
+                                       SILValue Setter,
+                                       AssignOrInitInst::Mode Mode) {
+    return insert(new (getModule()) AssignOrInitInst(
+        getSILDebugLocation(Loc), Src, Initializer, Setter, Mode));
+  }
+
   StoreBorrowInst *createStoreBorrow(SILLocation Loc, SILValue Src,
                                      SILValue DestAddr) {
     return insert(new (getModule())
@@ -1009,7 +1017,11 @@ class SILBuilder {
                                                          SILValue src) {
     return createMarkUninitialized(Loc, src, MarkUninitializedInst::RootSelf);
   }
-  
+  MarkUninitializedInst *createMarkUninitializedOut(SILLocation Loc,
+                                                    SILValue src) {
+    return createMarkUninitialized(Loc, src, MarkUninitializedInst::Out);
+  }
+
   MarkFunctionEscapeInst *createMarkFunctionEscape(SILLocation Loc,
                                                    ArrayRef<SILValue> vars) {
     return insert(

include/swift/SIL/SILCloner.h

@@ -1353,6 +1353,17 @@ void SILCloner<ImplClass>::visitAssignByWrapperInst(AssignByWrapperInst *Inst) {
                 getOpValue(Inst->getSetter()), Inst->getMode()));
 }
 
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitAssignOrInitInst(AssignOrInitInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  recordClonedInstruction(
+      Inst, getBuilder().createAssignOrInit(
+                getOpLocation(Inst->getLoc()),
+                getOpValue(Inst->getSrc()),
+                getOpValue(Inst->getInitializer()),
+                getOpValue(Inst->getSetter()), Inst->getMode()));
+}
+
 template<typename ImplClass>
 void
 SILCloner<ImplClass>::visitMarkUninitializedInst(MarkUninitializedInst *Inst) {

include/swift/SIL/SILDeclRef.h

@@ -382,6 +382,9 @@ struct SILDeclRef {
     return kind == Kind::Initializer || kind == Kind::Destroyer;
   }
 
+  /// True if the SILDeclRef references an init accessor declaration.
+  bool isInitAccessor() const;
+
   /// True if the function should be treated as transparent.
   bool isTransparent() const;
   /// True if the function should have its body serialized.