[move-only] Teach the move only object checker how to handle concrete resilient guaranteed arguments.

The only difference from normal concrete guaranteed parameter emission is we
have a load_borrow on the argument before the copy_value. That is instead of:

```
bb0(%0 : @guaranteed $Type):
  %1 = copy_value %0
  %2 = mark_must_check [no_consume_or_assign] %1
```

we have,

```
bb0(%0 : $*Type): // in_guaranteed
  %1 = load_borrow %0
  %2 = copy_value %1
  %3 = mark_must_check [no_consume_or_assign] %2
```

So I just needed to update the checker to recognize that pattern.

This is tested by just making sure that the checker can handle the borrowVal in
the tests without emitting an error.

rdar://109170906
(cherry picked from commit 7d7c929)

Author: gottesmm

lib/SILOptimizer/Mandatory/MoveOnlyObjectCheckerUtils.cpp

@@ -110,6 +110,21 @@ bool swift::siloptimizer::searchForCandidateObjectMarkMustChecks(
             }
           }
 
+          // In the case we have a resilient argument, we may have the following pattern:
+          //
+          // bb0(%0 : $*Type): // in_guaranteed
+          //   %1 = load_borrow %0
+          //   %2 = copy_value
+          //   %3 = mark_must_check [no_copy_or_assign]
+          if (auto *lbi = dyn_cast<LoadBorrowInst>(cvi->getOperand())) {
+            if (auto *arg = dyn_cast<SILFunctionArgument>(lbi->getOperand())) {
+              if (arg->getKnownParameterInfo().isIndirectInGuaranteed()) {
+                moveIntroducersToProcess.insert(mmci);
+                continue;
+              }
+            }
+          }
+
           if (auto *bbi = dyn_cast<BeginBorrowInst>(cvi->getOperand())) {
             if (bbi->isLexical()) {
               moveIntroducersToProcess.insert(mmci);
@@ -656,6 +671,11 @@ void MoveOnlyObjectCheckerPImpl::check(DominanceInfo *domTree,
             i = copyToMoveOnly;
           }
 
+          // Handle:
+          //
+          // bb0(%0 : @guaranteed $Type):
+          //   %1 = copy_value %0
+          //   %2 = mark_must_check [no_consume_or_assign] %1
           if (auto *arg = dyn_cast<SILFunctionArgument>(i->getOperand(0))) {
             if (arg->getOwnershipKind() == OwnershipKind::Guaranteed) {
               for (auto *use : markedInst->getConsumingUses()) {
@@ -669,6 +689,28 @@ void MoveOnlyObjectCheckerPImpl::check(DominanceInfo *domTree,
               continue;
             }
           }
+
+          // Handle:
+          //
+          // bb0(%0 : $*Type): // in_guaranteed
+          //   %1 = load_borrow %0
+          //   %2 = copy_value %1
+          //   %3 = mark_must_check [no_consume_or_assign] %2
+          if (auto *lbi = dyn_cast<LoadBorrowInst>(i->getOperand(0))) {
+            if (auto *arg = dyn_cast<SILFunctionArgument>(lbi->getOperand())) {
+              if (arg->getKnownParameterInfo().isIndirectInGuaranteed()) {
+                for (auto *use : markedInst->getConsumingUses()) {
+                  destroys.push_back(cast<DestroyValueInst>(use->getUser()));
+                }
+                while (!destroys.empty())
+                  destroys.pop_back_val()->eraseFromParent();
+                markedInst->replaceAllUsesWith(lbi);
+                markedInst->eraseFromParent();
+                cvi->eraseFromParent();
+                continue;
+              }
+            }
+          }
         }
       }
     }

test/SILOptimizer/moveonly_addresschecker_diagnostics_library_evolution.swift

@@ -8,6 +8,21 @@
 // MARK: Deinit Tests //
 ////////////////////////
 
+@_moveOnly public struct EmptyStruct {}
+@_moveOnly public struct NonEmptyStruct {
+    var e = EmptyStruct()
+}
+public class CopyableKlass {
+    var s = NonEmptyStruct()
+}
+
+public func borrowVal(_ x: borrowing NonEmptyStruct) {}
+public func borrowVal(_ x: borrowing EmptyStruct) {}
+
+/////////////////
+// MARK: Tests //
+/////////////////
+
 public struct DeinitTest : ~Copyable {
     deinit {}
 }