[NFC] MoveAddrChecker: Extract reused expression.

To enable changing its definition.

Author: nate-chandler

lib/SILOptimizer/Mandatory/MoveOnlyAddressCheckerUtils.cpp

@@ -992,11 +992,11 @@ addressBeginsInitialized(MarkUnresolvedNonCopyableValueInst *address) {
   // FIXME: Whether the initial use is an initialization ought to be entirely
   // derivable from the CheckKind of the mark instruction.
 
+  SILValue operand = address->getOperand();
   {
     // Then check if our markedValue is from an argument that is in,
     // in_guaranteed, inout, or inout_aliasable, consider the marked address to
     // be the initialization point.
-    SILValue operand = address->getOperand();
     if (auto *c = dyn_cast<CopyableToMoveOnlyWrapperAddrInst>(operand))
       operand = c->getOperand();
     if (auto *fArg = dyn_cast<SILFunctionArgument>(operand)) {
@@ -1031,7 +1031,7 @@ addressBeginsInitialized(MarkUnresolvedNonCopyableValueInst *address) {
   }
 
   // A read or write access always begins on an initialized value.
-  if (auto access = dyn_cast<BeginAccessInst>(address->getOperand())) {
+  if (auto access = dyn_cast<BeginAccessInst>(operand)) {
     switch (access->getAccessKind()) {
     case SILAccessKind::Deinit:
     case SILAccessKind::Read:
@@ -1049,7 +1049,8 @@ addressBeginsInitialized(MarkUnresolvedNonCopyableValueInst *address) {
   // See if our address is from a closure guaranteed box that we did not promote
   // to an address. In such a case, just treat our
   // mark_unresolved_non_copyable_value as the init of our value.
-  if (auto *projectBox = dyn_cast<ProjectBoxInst>(stripAccessMarkers(address->getOperand()))) {
+  if (auto *projectBox =
+          dyn_cast<ProjectBoxInst>(stripAccessMarkers(operand))) {
     if (auto *fArg = dyn_cast<SILFunctionArgument>(projectBox->getOperand())) {
       if (fArg->isClosureCapture()) {
         assert(fArg->getArgumentConvention() ==
@@ -1074,8 +1075,8 @@ addressBeginsInitialized(MarkUnresolvedNonCopyableValueInst *address) {
 
   // Check if our address is from a ref_element_addr. In such a case, we treat
   // the mark_unresolved_non_copyable_value as the initialization.
-  if (auto *refEltAddr = dyn_cast<RefElementAddrInst>(
-          stripAccessMarkers(address->getOperand()))) {
+  if (auto *refEltAddr =
+          dyn_cast<RefElementAddrInst>(stripAccessMarkers(operand))) {
     LLVM_DEBUG(llvm::dbgs()
                << "Found ref_element_addr use... "
                   "adding mark_unresolved_non_copyable_value as init!\n");
@@ -1085,40 +1086,39 @@ addressBeginsInitialized(MarkUnresolvedNonCopyableValueInst *address) {
   // Check if our address is from a global_addr. In such a case, we treat the
   // mark_unresolved_non_copyable_value as the initialization.
   if (auto *globalAddr =
-          dyn_cast<GlobalAddrInst>(stripAccessMarkers(address->getOperand()))) {
+          dyn_cast<GlobalAddrInst>(stripAccessMarkers(operand))) {
     LLVM_DEBUG(llvm::dbgs()
                << "Found global_addr use... "
                   "adding mark_unresolved_non_copyable_value as init!\n");
     return true;
   }
 
-  if (auto *ptai = dyn_cast<PointerToAddressInst>(
-          stripAccessMarkers(address->getOperand()))) {
+  if (auto *ptai =
+          dyn_cast<PointerToAddressInst>(stripAccessMarkers(operand))) {
     assert(ptai->isStrict());
     LLVM_DEBUG(llvm::dbgs()
                << "Found pointer to address use... "
                   "adding mark_unresolved_non_copyable_value as init!\n");
     return true;
   }
-  
+
   if (auto *bai = dyn_cast_or_null<BeginApplyInst>(
-        stripAccessMarkers(address->getOperand())->getDefiningInstruction())) {
+          stripAccessMarkers(operand)->getDefiningInstruction())) {
     LLVM_DEBUG(llvm::dbgs()
                << "Adding accessor coroutine begin_apply as init!\n");
     return true;
   }
-  
+
   if (auto *eai = dyn_cast<UncheckedTakeEnumDataAddrInst>(
-          stripAccessMarkers(address->getOperand()))) {
+          stripAccessMarkers(operand))) {
     LLVM_DEBUG(llvm::dbgs()
                << "Adding enum projection as init!\n");
     return true;
   }
 
   // Assume a strict check of a temporary or formal access is initialized
   // before the check.
-  if (auto *asi = dyn_cast<AllocStackInst>(
-          stripAccessMarkers(address->getOperand()));
+  if (auto *asi = dyn_cast<AllocStackInst>(stripAccessMarkers(operand));
       asi && address->isStrict()) {
     LLVM_DEBUG(llvm::dbgs()
                << "Adding strict-marked alloc_stack as init!\n");
@@ -1133,14 +1133,14 @@ addressBeginsInitialized(MarkUnresolvedNonCopyableValueInst *address) {
   }
 
   // Assume a value whose deinit has been dropped has been initialized.
-  if (auto *ddi = dyn_cast<DropDeinitInst>(address->getOperand())) {
+  if (auto *ddi = dyn_cast<DropDeinitInst>(operand)) {
     LLVM_DEBUG(llvm::dbgs()
                << "Adding copyable_to_move_only_wrapper as init!\n");
     return true;
   }
 
   // Assume a value wrapped in a MoveOnlyWrapper is initialized.
-  if (auto *m2c = dyn_cast<CopyableToMoveOnlyWrapperAddrInst>(address->getOperand())) {
+  if (auto *m2c = dyn_cast<CopyableToMoveOnlyWrapperAddrInst>(operand)) {
     LLVM_DEBUG(llvm::dbgs()
                << "Adding copyable_to_move_only_wrapper as init!\n");
     return true;