[SIL/DI] InitAccessors: Get all required info from AssignOrInit instead of instruction location

This is a more robust way of accessing the property information
because instruction has a reference to init accessor declaration.

Author: xedin

include/swift/SIL/SILInstruction.h

@@ -4935,15 +4935,16 @@ class AssignByWrapperInst
   }
 };
 
-/// AssignByWrapperInst - Represents an abstract assignment via a wrapper,
-/// which may either be an initialization or a store sequence.  This is only
-/// valid in Raw SIL.
+/// AssignOrInitInst - Represents an abstract assignment via a init accessor
+/// or a setter, which may either be an initialization or a store sequence.
+/// This is only valid in Raw SIL.
 ///
 /// Note that this instruction does not inherit from AssignInstBase because
 /// there is no physical destination of the assignment. Both the init
 /// and the setter are factored into functions.
 class AssignOrInitInst
-    : public InstructionBase<SILInstructionKind::AssignOrInitInst, NonValueInstruction>,
+    : public InstructionBase<SILInstructionKind::AssignOrInitInst,
+                             NonValueInstruction>,
       public CopyLikeInstruction {
   friend SILBuilder;
   USE_SHARED_UINT8;
@@ -4969,7 +4970,7 @@ class AssignOrInitInst
 
 public:
   SILValue getSrc() const { return Operands[0].get(); }
-  SILValue getInitializer() { return Operands[1].get(); }
+  SILValue getInitializer() const { return Operands[1].get(); }
   SILValue getSetter() { return  Operands[2].get(); }
 
   Mode getMode() const {
@@ -4980,8 +4981,13 @@ class AssignOrInitInst
     sharedUInt8().AssignOrInitInst.mode = uint8_t(mode);
   }
 
+  ArrayRef<VarDecl *> getInitializedProperties() const;
+  ArrayRef<VarDecl *> getAccessedProperties() const;
+
   ArrayRef<Operand> getAllOperands() const { return Operands.asArray(); }
   MutableArrayRef<Operand> getAllOperands() { return Operands.asArray(); }
+
+  AccessorDecl *getReferencedInitAccessor() const;
 };
 
 /// Indicates that a memory location is uninitialized at this point and needs to

lib/SIL/IR/SILInstructions.cpp

@@ -1265,6 +1265,29 @@ AssignOrInitInst::AssignOrInitInst(SILDebugLocation Loc, SILValue Src,
   sharedUInt8().AssignOrInitInst.mode = uint8_t(Mode);
 }
 
+AccessorDecl *AssignOrInitInst::getReferencedInitAccessor() const {
+  auto *initRef =
+      cast<FunctionRefInst>(getInitializer()->getDefiningInstruction());
+  auto *accessorRef = initRef->getReferencedFunction();
+  return cast<AccessorDecl>(accessorRef->getDeclContext());
+}
+
+ArrayRef<VarDecl *> AssignOrInitInst::getInitializedProperties() const {
+  auto *accessor = getReferencedInitAccessor();
+  if (auto *initAttr = accessor->getAttrs().getAttribute<InitializesAttr>()) {
+    return initAttr->getPropertyDecls(accessor);
+  }
+  return {};
+}
+
+ArrayRef<VarDecl *> AssignOrInitInst::getAccessedProperties() const {
+  auto *accessor = getReferencedInitAccessor();
+  if (auto *accessAttr = accessor->getAttrs().getAttribute<AccessesAttr>()) {
+    return accessAttr->getPropertyDecls(accessor);
+  }
+  return {};
+}
+
 MarkFunctionEscapeInst *
 MarkFunctionEscapeInst::create(SILDebugLocation Loc,
                                ArrayRef<SILValue> Elements, SILFunction &F) {

lib/SILOptimizer/Mandatory/DIMemoryUseCollector.cpp

@@ -1187,22 +1187,20 @@ ElementUseCollector::collectAssignOrInitUses(PartialApplyInst *pai,
                                              unsigned BaseEltNo) {
   for (Operand *Op : pai->getUses()) {
     SILInstruction *User = Op->getUser();
-    if (!isa<AssignOrInitInst>(User) || Op->getOperandNumber() != 1) {
+    if (!isa<AssignOrInitInst>(User) || Op->getOperandNumber() != 2) {
       continue;
     }
 
-    auto instLoc = User->getLoc();
-    auto *assignment = instLoc.getAsASTNode<AssignExpr>();
-    assert(assignment);
+    /// AssignOrInit doesn't operate on `self` so we need to make sure
+    /// that the flag is dropped before calling \c addElementUses.
+    llvm::SaveAndRestore<bool> X(IsSelfOfNonDelegatingInitializer, false);
 
-    auto propertyRef = cast<MemberRefExpr>(assignment->getDest())->getDecl();
-
-    auto initAccessor =
-        cast<VarDecl>(propertyRef.getDecl())->getAccessor(AccessorKind::Init);
+    auto *inst = cast<AssignOrInitInst>(User);
+    auto *typeDC = inst->getReferencedInitAccessor()
+                       ->getDeclContext()
+                       ->getSelfNominalTypeDecl();
 
     auto selfTy = pai->getOperand(1)->getType();
-    auto *typeDC =
-        propertyRef.getDecl()->getDeclContext()->getSelfNominalTypeDecl();
 
     auto addUse = [&](VarDecl *property, DIUseKind useKind) {
       auto expansionContext = TypeExpansionContext(*pai->getFunction());
@@ -1211,17 +1209,11 @@ ElementUseCollector::collectAssignOrInitUses(PartialApplyInst *pai,
                      useKind);
     };
 
-    if (auto *initializes =
-            initAccessor->getAttrs().getAttribute<InitializesAttr>()) {
-      for (auto *property : initializes->getPropertyDecls(initAccessor))
-        addUse(property, DIUseKind::InitOrAssign);
-    }
+    for (auto *property : inst->getInitializedProperties())
+      addUse(property, DIUseKind::InitOrAssign);
 
-    if (auto *initializes =
-            initAccessor->getAttrs().getAttribute<AccessesAttr>()) {
-      for (auto *property : initializes->getPropertyDecls(initAccessor))
-        addUse(property, DIUseKind::Load);
-    }
+    for (auto *property : inst->getAccessedProperties())
+      addUse(property, DIUseKind::Load);
   }
 }