[Sema/SIL] InitAccessors: Incorporate init accessors into memberwise initializers

Properties with init accessors are used in place of properties they
are supposed to initialize in order of stored properties.

Author: xedin

include/swift/AST/Decl.h

@@ -47,6 +47,7 @@
 #include "swift/Basic/Range.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/Support/TrailingObjects.h"
+#include <map>
 #include <type_traits>
 
 namespace swift {
@@ -3985,6 +3986,12 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   /// 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;

lib/AST/Decl.cpp

@@ -4894,6 +4894,18 @@ NominalTypeDecl::getInitAccessorProperties() const {
       {});
 }
 
+void NominalTypeDecl::collectPropertiesInitializableByInitAccessors(
+    std::multimap<VarDecl *, VarDecl *> &result) const {
+  for (auto *property : getInitAccessorProperties()) {
+    auto *initAccessor = property->getAccessor(AccessorKind::Init);
+    if (auto *initAttr =
+            initAccessor->getAttrs().getAttribute<InitializesAttr>()) {
+      for (auto *subsumed : initAttr->getPropertyDecls(initAccessor))
+        result.insert({subsumed, property});
+    }
+  }
+}
+
 ArrayRef<Decl *>
 NominalTypeDecl::getStoredPropertiesAndMissingMemberPlaceholders() const {
   auto &ctx = getASTContext();

lib/SILGen/SILGenConstructor.cpp

@@ -30,6 +30,7 @@
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILUndef.h"
 #include "swift/SIL/TypeLowering.h"
+#include <map>
 
 using namespace swift;
 using namespace Lowering;
@@ -271,6 +272,47 @@ static RValue maybeEmitPropertyWrapperInitFromValue(
                                                           subs, std::move(arg));
 }
 
+static void emitApplyOfInitAccessor(SILGenFunction &SGF, SILLocation loc,
+                                    AccessorDecl *accessor, SILValue selfValue,
+                                    SILType selfTy, RValue &&initialValue) {
+  SmallVector<SILValue> arguments;
+
+  auto emitFieldReference = [&](VarDecl *field) {
+    auto fieldTy =
+        selfTy.getFieldType(field, SGF.SGM.M, SGF.getTypeExpansionContext());
+    return SGF.B.createStructElementAddr(loc, selfValue, field,
+                                         fieldTy.getAddressType());
+  };
+
+  // First, let's emit all of the indirect results.
+  if (auto *initAttr = accessor->getAttrs().getAttribute<InitializesAttr>()) {
+    for (auto *property : initAttr->getPropertyDecls(accessor)) {
+      arguments.push_back(emitFieldReference(property));
+    }
+  }
+
+  // `initialValue`
+  std::move(initialValue).forwardAll(SGF, arguments);
+
+  // And finally, all of the properties in `accesses(...)` list which are
+  // `inout` arguments.
+  if (auto *accessAttr = accessor->getAttrs().getAttribute<AccessesAttr>()) {
+    for (auto *property : accessAttr->getPropertyDecls(accessor)) {
+      arguments.push_back(emitFieldReference(property));
+    }
+  }
+
+  SubstitutionMap subs;
+  if (auto *env =
+          accessor->getDeclContext()->getGenericEnvironmentOfContext()) {
+    subs = env->getForwardingSubstitutionMap();
+  }
+
+  SILValue accessorRef =
+      SGF.emitGlobalFunctionRef(loc, SGF.getAccessorDeclRef(accessor));
+  (void)SGF.B.createApply(loc, accessorRef, subs, arguments, ApplyOptions());
+}
+
 static SubstitutionMap getSubstitutionsForPropertyInitializer(
     DeclContext *dc,
     NominalTypeDecl *nominal) {
@@ -312,6 +354,12 @@ static void emitImplicitValueConstructor(SILGenFunction &SGF,
   auto selfIfaceTy = selfDecl->getInterfaceType();
   SILType selfTy = SGF.getSILTypeInContext(selfResultInfo, loweredFunctionTy);
 
+  auto *decl = selfTy.getStructOrBoundGenericStruct();
+  assert(decl && "not a struct?!");
+
+  std::multimap<VarDecl *, VarDecl *> initializedViaAccessor;
+  decl->collectPropertiesInitializableByInitAccessors(initializedViaAccessor);
+
   // Emit the indirect return argument, if any.
   SILValue resultSlot;
   if (selfTy.isAddress()) {
@@ -324,6 +372,10 @@ static void emitImplicitValueConstructor(SILGenFunction &SGF,
     VD->setSpecifier(ParamSpecifier::InOut);
     VD->setInterfaceType(selfIfaceTy);
     resultSlot = SGF.F.begin()->createFunctionArgument(selfTy, VD);
+  } else if (!initializedViaAccessor.empty()) {
+    // Allocate "self" on stack which we are going to use to
+    // reference/init fields and then load to return.
+    resultSlot = SGF.emitTemporaryAllocation(Loc, selfTy);
   }
 
   LoweredParamsInContextGenerator loweredParams(SGF);
@@ -343,15 +395,34 @@ static void emitImplicitValueConstructor(SILGenFunction &SGF,
   (void) loweredParams.claimNext();
   loweredParams.finish();
 
-  auto *decl = selfTy.getStructOrBoundGenericStruct();
-  assert(decl && "not a struct?!");
-
   auto subs = getSubstitutionsForPropertyInitializer(decl, decl);
 
   // If we have an indirect return slot, initialize it in-place.
   if (resultSlot) {
+    // Tracks all the init accessors we have emitted
+    // because they can initialize more than one property.
+    llvm::SmallPtrSet<AccessorDecl *, 2> emittedInitAccessors;
+
     auto elti = elements.begin(), eltEnd = elements.end();
     for (VarDecl *field : decl->getStoredProperties()) {
+
+      // Handle situations where this stored propery is initialized
+      // via a call to an init accessor on some other property.
+      if (initializedViaAccessor.count(field)) {
+        auto *initProperty = initializedViaAccessor.find(field)->second;
+        auto *initAccessor = initProperty->getAccessor(AccessorKind::Init);
+
+        if (emittedInitAccessors.count(initAccessor))
+          continue;
+
+        emitApplyOfInitAccessor(SGF, Loc, initAccessor, resultSlot, selfTy,
+                                std::move(*elti));
+
+        emittedInitAccessors.insert(initAccessor);
+        ++elti;
+        continue;
+      }
+
       auto fieldTy =
           selfTy.getFieldType(field, SGF.SGM.M, SGF.getTypeExpansionContext());
       SILValue slot =
@@ -423,6 +494,16 @@ static void emitImplicitValueConstructor(SILGenFunction &SGF,
       }
     }
 
+    // Load as "take" from our stack allocation and return.
+    if (!selfTy.isAddress() && !initializedViaAccessor.empty()) {
+      auto resultValue = SGF.B.emitLoadValueOperation(
+          Loc, resultSlot, LoadOwnershipQualifier::Take);
+
+      SGF.B.createReturn(ImplicitReturnLocation(Loc), resultValue,
+                         std::move(functionLevelScope));
+      return;
+    }
+
     SGF.B.createReturn(ImplicitReturnLocation(Loc),
                        SGF.emitEmptyTuple(Loc), std::move(functionLevelScope));
     return;

lib/Sema/CodeSynthesis.cpp

@@ -294,6 +294,12 @@ static ConstructorDecl *createImplicitConstructor(NominalTypeDecl *decl,
   if (ICK == ImplicitConstructorKind::Memberwise) {
     assert(isa<StructDecl>(decl) && "Only struct have memberwise constructor");
 
+    std::multimap<VarDecl *, VarDecl *> initializedViaAccessor;
+    decl->collectPropertiesInitializableByInitAccessors(initializedViaAccessor);
+
+    // A single property could be used to initialize N other stored
+    // properties via a call to its init accessor.
+    llvm::SmallPtrSet<VarDecl *, 4> usedInitProperties;
     for (auto member : decl->getMembers()) {
       auto var = dyn_cast<VarDecl>(member);
       if (!var)
@@ -302,6 +308,20 @@ static ConstructorDecl *createImplicitConstructor(NominalTypeDecl *decl,
       if (!var->isMemberwiseInitialized(/*preferDeclaredProperties=*/true))
         continue;
 
+      // Check whether this property could be initialized via init accessor.
+      //
+      // Note that we check for a single match here because intersecting
+      // properties are going to be diagnosed.
+      if (initializedViaAccessor.count(var) == 1) {
+        auto *initializerProperty = initializedViaAccessor.find(var)->second;
+        // Parameter for this property is already emitted.
+        if (usedInitProperties.count(initializerProperty))
+          continue;
+
+        var = initializerProperty;
+        usedInitProperties.insert(initializerProperty);
+      }
+
       accessLevel = std::min(accessLevel, var->getFormalAccess());
 
       params.push_back(createMemberwiseInitParameter(decl, Loc, var));

test/SIL/init_accessors.swift

@@ -303,3 +303,79 @@ struct TestGeneric<T, U> {
     self.data = (b, a)
   }
 }
+
+func test_local_with_memberwise() {
+  class MyValue {}
+
+  struct TestMemberwiseConcrete {
+    var a: Int
+    var b: String
+
+    var pair: (Int, String) {
+      init(initialValue) initializes(a b) {
+        a = initialValue.0
+        b = initialValue.1
+      }
+
+      get { (a, b) }
+      set { }
+    }
+
+    var c: [MyValue]
+
+    // CHECK-LABEL: sil private @$s14init_accessors26test_local_with_memberwiseyyF22TestMemberwiseConcreteL_V4pair1cADSi_SSt_SayAaByyF7MyValueL_CGtcfC : $@convention(method) (Int, @owned String, @owned Array<MyValue>, @thin TestMemberwiseConcrete.Type) -> @owned TestMemberwiseConcrete
+    // CHECK:  [[SELF_VALUE:%.*]] = alloc_stack $TestMemberwiseConcrete
+    // CHECK-NEXT: [[A_REF:%.*]] = struct_element_addr [[SELF_VALUE]] : $*TestMemberwiseConcrete, #<abstract function>TestMemberwiseConcrete.a
+    // CHECK-NEXT: [[B_REF:%.*]] = struct_element_addr [[SELF_VALUE]] : $*TestMemberwiseConcrete, #<abstract function>TestMemberwiseConcrete.b
+    // CHECK:  [[INIT_ACCESSOR_REF:%.*]] = function_ref @$s14init_accessors26test_local_with_memberwiseyyF22TestMemberwiseConcreteL_V4pairSi_SStvi : $@convention(thin) (Int, @owned String) -> (@out Int, @out String)
+    // CHECK-NEXT: {{.*}} = apply [[INIT_ACCESSOR_REF]]([[A_REF]], [[B_REF]], %0, %1) : $@convention(thin) (Int, @owned String) -> (@out Int, @out String)
+    // CHECK-NEXT: [[C_REF:%.*]] = struct_element_addr %4 : $*TestMemberwiseConcrete, #<abstract function>TestMemberwiseConcrete.c
+    // CHECK-NEXT: store %2 to [[C_REF]] : $*Array<MyValue>
+    // CHECK-NEXT: [[RESULT:%.*]] = load [[SELF_VALUE]] : $*TestMemberwiseConcrete
+    // CHECK-NEXT: dealloc_stack [[SELF_VALUE]] : $*TestMemberwiseConcrete
+    // CHECK-NEXT: return [[RESULT]] : $TestMemberwiseConcrete
+  }
+
+  _ = TestMemberwiseConcrete(pair: (0, "a"), c: [])
+
+  struct TestMemberwiseGeneric<T, C> where C: RangeReplaceableCollection, C.Element == T {
+    var _a: T
+    var _b: String
+    var _c: C
+
+    var a: T {
+      init(initialValue) initializes(_a) {
+        _a = initialValue
+      }
+
+      get { _a }
+      set { }
+    }
+
+    var pair: (String, C) {
+      init(initialValue) initializes(_b _c) accesses(_a) {
+        _b = initialValue.0
+        _c = initialValue.1
+        _c.append(_a)
+      }
+
+      get { (_b, _c) }
+      set { }
+    }
+
+    // CHECK-LABEL: sil private @$s14init_accessors26test_local_with_memberwiseyyF21TestMemberwiseGenericL_V1a4pairADyxq_Gx_SS_q_ttcfC : $@convention(method) <T, C where T == C.Element, C : RangeReplaceableCollection> (@in T, @owned String, @in C, @thin TestMemberwiseGeneric<T, C>.Type) -> @out TestMemberwiseGeneric<T, C>
+    // CHECK: bb0([[SELF_VALUE:%.*]]  : $*TestMemberwiseGeneric<T, C>, [[A_VALUE:%*.]] : $*T, [[B_VALUE:%.*]] : $String, [[C_VALUE:%.*]] : $*C, [[METATYPE:%.*]] : $@thin TestMemberwiseGeneric<T, C>.Type):
+    // CHECK-NEXT: [[A_REF:%.*]] = struct_element_addr [[SELF_VALUE]] : $*TestMemberwiseGeneric<T, C>, #<abstract function>TestMemberwiseGeneric._a
+    // CHECK: [[INIT_ACCESSOR_REF:%.*]] = function_ref @$s14init_accessors26test_local_with_memberwiseyyF21TestMemberwiseGenericL_V1axvi : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_0 == τ_0_1.Element, τ_0_1 : RangeReplaceableCollection> (@in τ_0_0) -> @out τ_0_0 // user: %7
+    // CHECK-NEXT: {{.*}} = apply [[INIT_ACCESSOR_REF]]<T, C>([[A_REF]], [[A_VALUE]]) : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_0 == τ_0_1.Element, τ_0_1 : RangeReplaceableCollection> (@in τ_0_0) -> @out τ_0_0
+    // CHECK-NEXT: [[B_REF:%.*]] = struct_element_addr [[SELF_VALUE]] : $*TestMemberwiseGeneric<T, C>, #<abstract function>TestMemberwiseGeneric._b
+    // CHECK-NEXT: [[C_REF:%.*]] = struct_element_addr [[SELF_VALUE]] : $*TestMemberwiseGeneric<T, C>, #<abstract function>TestMemberwiseGeneric._c
+    // CHECK-NEXT: [[A_REF:%.*]] = struct_element_addr [[SELF_VALUE]] : $*TestMemberwiseGeneric<T, C>, #<abstract function>TestMemberwiseGeneric._a
+    // CHECK: [[INIT_ACCESSOR_REF:%.*]] = function_ref @$s14init_accessors26test_local_with_memberwiseyyF21TestMemberwiseGenericL_V4pairSS_q_tvi : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_0 == τ_0_1.Element, τ_0_1 : RangeReplaceableCollection> (@owned String, @in τ_0_1, @inout τ_0_0) -> (@out String, @out τ_0_1)
+    // CHECK-NEXT: {{.*}} = apply [[INIT_ACCESSOR_REF]]<T, C>([[B_REF]], [[C_REF]], [[B_VALUE]], [[C_VALUE]], [[A_REF]]) : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_0 == τ_0_1.Element, τ_0_1 : RangeReplaceableCollection> (@owned String, @in τ_0_1, @inout τ_0_0) -> (@out String, @out τ_0_1)
+    // CHECK-NEXT: [[VOID:%.*]] = tuple ()
+    // CHECK-NEXT: return [[VOID]] : $()
+  }
+
+  _ = TestMemberwiseGeneric(a: 1, pair: ("a", [0]))
+}