[move-only] When storing a trivial field of a borrowed parameter, treat the store as a trivial use.

rdar://111354827

Author: gottesmm

lib/SILOptimizer/Mandatory/MoveOnlyBorrowToDestructureUtils.cpp

@@ -342,6 +342,21 @@ bool Implementation::gatherUses(SILValue value) {
         return false;
       }
 
+      // Check if our use type is trivial. In such a case, just treat this as a
+      // liveness use.
+      SILType type = nextUse->get()->getType();
+      if (type.isTrivial(nextUse->getUser()->getFunction())) {
+        LLVM_DEBUG(llvm::dbgs() << "        Found non lifetime ending use!\n");
+        blocksToUses.insert(nextUse->getParentBlock(),
+                            {nextUse,
+                             {liveness.getNumSubElements(), *leafRange,
+                              false /*is lifetime ending*/}});
+        liveness.updateForUse(nextUse->getUser(), *leafRange,
+                              false /*is lifetime ending*/);
+        instToInterestingOperandIndexMap.insert(nextUse->getUser(), nextUse);
+        continue;
+      }
+
       LLVM_DEBUG(llvm::dbgs() << "        Found lifetime ending use!\n");
       destructureNeedingUses.push_back(nextUse);
       blocksToUses.insert(nextUse->getParentBlock(),

test/SILOptimizer/moveonly_addresschecker_diagnostics_without_partial.swift

@@ -0,0 +1,19 @@
+// RUN: %target-swift-emit-sil -O -sil-verify-all -verify -enable-experimental-feature NoImplicitCopy -enable-experimental-feature MoveOnlyClasses %s
+
+struct Test: ~Copyable {
+  public let baseAddress: UnsafeRawPointer
+  public let count: Int
+}
+
+extension Test {
+
+  public static func ==(lhs: borrowing Test, rhs: borrowing Test) -> Bool {
+    let count = lhs.count
+    guard count == rhs.count else { return false }
+
+    if count == 0 { return true } else if lhs.baseAddress == rhs.baseAddress { return true }
+    if count == 1 || lhs.baseAddress == rhs.baseAddress { return true }
+
+    return lhs.baseAddress.load(as: UInt8.self) == rhs.baseAddress.load(as: UInt8.self)
+  }
+}