[DI/Lowering] InitAccessors: Implement lowering of property assignments

DI marks all of of the previously initialized properties and Raw SIL
lowering emits `destroy_addr` before calling init accessor for such
properties to destroy previously set value.

Author: xedin

lib/SILOptimizer/Mandatory/DIMemoryUseCollector.cpp

@@ -663,7 +663,7 @@ class ElementUseCollector {
                             llvm::SmallDenseMap<VarDecl *, unsigned> &EN);
 
   void addElementUses(unsigned BaseEltNo, SILType UseTy, SILInstruction *User,
-                      DIUseKind Kind);
+                      DIUseKind Kind, NullablePtr<VarDecl> Field = 0);
   void collectTupleElementUses(TupleElementAddrInst *TEAI, unsigned BaseEltNo);
   void collectStructElementUses(StructElementAddrInst *SEAI,
                                 unsigned BaseEltNo);
@@ -675,7 +675,8 @@ class ElementUseCollector {
 /// of $*(Int,Int) is a use of both Int elements of the tuple.  This is a helper
 /// to keep the Uses data structure up to date for aggregate uses.
 void ElementUseCollector::addElementUses(unsigned BaseEltNo, SILType UseTy,
-                                         SILInstruction *User, DIUseKind Kind) {
+                                         SILInstruction *User, DIUseKind Kind,
+                                         NullablePtr<VarDecl> Field) {
   // If we're in a subelement of a struct or enum, just mark the struct, not
   // things that come after it in a parent tuple.
   unsigned NumElements = 1;
@@ -685,7 +686,7 @@ void ElementUseCollector::addElementUses(unsigned BaseEltNo, SILType UseTy,
         getElementCountRec(TypeExpansionContext(*User->getFunction()), Module,
                            UseTy, IsSelfOfNonDelegatingInitializer);
 
-  trackUse(DIMemoryUse(User, Kind, BaseEltNo, NumElements));
+  trackUse(DIMemoryUse(User, Kind, BaseEltNo, NumElements, Field));
 }
 
 /// Given a tuple_element_addr or struct_element_addr, compute the new
@@ -1211,7 +1212,7 @@ ElementUseCollector::collectAssignOrInitUses(PartialApplyInst *pai,
       auto expansionContext = TypeExpansionContext(*pai->getFunction());
       auto type = selfTy.getFieldType(property, Module, expansionContext);
       addElementUses(Module.getFieldIndex(typeDC, property), type, User,
-                     useKind);
+                     useKind, property);
     };
 
     auto initializedElts = inst->getInitializedProperties();

lib/SILOptimizer/Mandatory/DIMemoryUseCollector.h

@@ -314,9 +314,12 @@ struct DIMemoryUse {
   /// track of which tuple elements are affected.
   unsigned FirstElement, NumElements;
 
-  DIMemoryUse(SILInstruction *Inst, DIUseKind Kind, unsigned FE, unsigned NE)
-      : Inst(Inst), Kind(Kind), FirstElement(FE), NumElements(NE) {
-  }
+  NullablePtr<VarDecl> Field;
+
+  DIMemoryUse(SILInstruction *Inst, DIUseKind Kind, unsigned FE, unsigned NE,
+              NullablePtr<VarDecl> Field = 0)
+      : Inst(Inst), Kind(Kind), FirstElement(FE), NumElements(NE),
+        Field(Field) {}
 
   DIMemoryUse() : Inst(nullptr) {}
 

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -1471,12 +1471,7 @@ void LifetimeChecker::handleStoreUse(unsigned UseID) {
     auto allFieldsInitialized =
         getAnyUninitializedMemberAtInst(Use.Inst, 0,
                                         TheMemory.getNumElements()) == -1;
-    if (allFieldsInitialized) {
-      Use.Kind = DIUseKind::Set;
-    } else {
-      diagnose(Module, Use.Inst->getLoc(), diag::use_of_self_before_fully_init);
-      return;
-    }
+    Use.Kind = allFieldsInitialized ? DIUseKind::Set : DIUseKind::Assign;
   } else if (isFullyInitialized) {
     Use.Kind = DIUseKind::Assign;
   } else {
@@ -2399,6 +2394,9 @@ void LifetimeChecker::updateInstructionForInitState(unsigned UseID) {
     llvm::erase_if(NonLoadUses[Inst], [&](unsigned id) { return id == UseID; });
 
     switch (Use.Kind) {
+    case DIUseKind::Assign:
+      AI->markAsInitialized(Use.Field.get());
+      LLVM_FALLTHROUGH;
     case DIUseKind::Initialization:
       AI->setMode(AssignOrInitInst::Init);
       break;

lib/SILOptimizer/Mandatory/RawSILInstLowering.cpp

@@ -300,19 +300,33 @@ lowerAssignOrInitInstruction(SILBuilderWithScope &b,
                                       /*fromBuiltin=*/false);
       }
 
-      auto emitFieldReference = [&](VarDecl *field) -> SILValue {
+      auto emitFieldReference = [&](VarDecl *field,
+                                    bool emitDestroy = false) -> SILValue {
+        SILValue fieldRef;
         if (isRefSelf) {
-          return b.createRefElementAddr(loc, selfRef, field);
+          fieldRef = b.createRefElementAddr(loc, selfRef, field);
+        } else {
+          fieldRef = b.createStructElementAddr(loc, selfRef, field);
         }
-        return b.createStructElementAddr(loc, selfRef, field);
+
+        if (emitDestroy)
+          b.createDestroyAddr(loc, fieldRef);
+
+        return fieldRef;
       };
 
       SmallVector<SILValue> arguments;
 
       // First, emit all of the properties listed in `initializes(...)`. They
       // are passed as indirect results.
-      for (auto *property : inst->getInitializedProperties())
-        arguments.push_back(emitFieldReference(property));
+      {
+        auto toInitialize = inst->getInitializedProperties();
+        for (unsigned index : indices(toInitialize)) {
+          arguments.push_back(emitFieldReference(
+              toInitialize[index],
+              /*emitDestroy=*/inst->isPropertyAlreadyInitialized(index)));
+        }
+      }
 
       // Now emit `initialValue` which is the only argument specified
       // by the user.

test/SIL/init_accessors.swift

@@ -379,3 +379,62 @@ func test_local_with_memberwise() {
 
   _ = TestMemberwiseGeneric(a: 1, pair: ("a", [0]))
 }
+
+func test_assignments() {
+  struct Test {
+    var _a: Int
+    var _b: Int
+
+    var a: Int {
+      init(initialValue) initializes(_a) {
+        self._a = initialValue
+      }
+      get { _a }
+      set { _a = newValue  }
+    }
+
+    var pair: (Int, Int) {
+      init(initialValue) initializes(_a, _b) {
+        _a = initialValue.0
+        _b = initialValue.1
+      }
+
+      get { (_a, _b) }
+      set { }
+    }
+
+    // CHECK-LABEL: sil private @$s14init_accessors16test_assignmentsyyF4TestL_V1aADSi_tcfC : $@convention(method) (Int, @thin Test.Type) -> Test
+    // CHECK: [[INIT_ACCESSOR:%.*]] = function_ref @$s14init_accessors16test_assignmentsyyF4TestL_V1aSivi : $@convention(thin) (Int) -> @out Int
+    // CHECK: [[A_REF:%.*]] = struct_element_addr {{.*}} : $*Test, #<abstract function>Test._a
+    // CHECK-NEXT: {{.*}} = apply [[INIT_ACCESSOR]]([[A_REF]], %0) : $@convention(thin) (Int) -> @out Int
+    // CHECK: [[INIT_ACCESSOR:%.*]] = function_ref @$s14init_accessors16test_assignmentsyyF4TestL_V1aSivi : $@convention(thin) (Int) -> @out Int
+    // CHECK: [[A_REF:%.*]] = struct_element_addr {{.*}} : $*Test, #<abstract function>Test._a
+    // CHECK-NEXT: destroy_addr [[A_REF]] : $*Int
+    // CHECK-NEXT: {{.*}} = apply [[INIT_ACCESSOR]]([[A_REF]], %0) : $@convention(thin) (Int) -> @out Int
+    // CHECK: [[B_REF:%.*]] = struct_element_addr %23 : $*Test, #<abstract function>Test._b
+    // CHECK-NEXT: store {{.*}} to [[B_REF]] : $*Int
+    // CHECK: [[SETTER_REF:%.*]] = function_ref @$s14init_accessors16test_assignmentsyyF4TestL_V1aSivs : $@convention(method) (Int, @inout Test) -> ()
+    // CHECK-NEXT: [[SETTER_CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[SETTER_REF]]([[SELF_VALUE:%.*]]) : $@convention(method) (Int, @inout Test) -> ()
+    // CHECK: {{.*}} = apply [[SETTER_CLOSURE]](%0) : $@callee_guaranteed (Int) -> ()
+    init(a: Int) {
+      self.a = a
+      self.a = a
+      self._b = 42
+      self.a = a
+    }
+
+    // CHECK-LABEL: sil private @$s14init_accessors16test_assignmentsyyF4TestL_V1a1bADSi_SitcfC : $@convention(method) (Int, Int, @thin Test.Type) -> Test
+    // CHECK: [[INIT_ACCESSOR:%.*]] = function_ref @$s14init_accessors16test_assignmentsyyF4TestL_V1aSivi : $@convention(thin) (Int) -> @out Int
+    // CHECK: [[A_REF:%.*]] = struct_element_addr {{.*}} : $*Test, #<abstract function>Test._a
+    // CHECK-NEXT: {{.*}} = apply [[INIT_ACCESSOR]]([[A_REF]], %0) : $@convention(thin) (Int) -> @out Int
+    // CHECK: [[INIT_ACCESSOR:%.*]] = function_ref @$s14init_accessors16test_assignmentsyyF4TestL_V4pairSi_Sitvi : $@convention(thin) (Int, Int) -> (@out Int, @out Int)
+    // CHECK: [[A_REF:%.*]] = struct_element_addr [[SELF_VALUE:%.*]] : $*Test, #<abstract function>Test._a
+    // CHECK-NEXT: destroy_addr [[A_REF]] : $*Int
+    // CHECK-NEXT: [[B_REF:%.*]] = struct_element_addr [[SELF_VALUE]] : $*Test, #<abstract function>Test._b
+    // CHECK-NEXT: {{.*}} = apply [[INIT_ACCESSOR]]([[A_REF]], [[B_REF]], {{.*}}) : $@convention(thin) (Int, Int) -> (@out Int, @out Int)
+    init(a: Int, b: Int) {
+      self.a = a
+      self.pair = (0, b)
+    }
+  }
+}

test/SILOptimizer/init_accessor_definite_init_diagnostics.swift

@@ -79,7 +79,7 @@ struct TestPartial {
 
   init(x: Int, y: Int) {
     self.x = x
-    self.point = (x, y) // expected-error {{'self' used before all stored properties are initialized}}
+    self.point = (x, y) // Ok (x is going to get `destroy_addr`)
   }
 
   init(_ x: Int, _ y: Int) {