[move-only] Make sure that we handle load [take] that are actually borrows correctly.

Before the previous commit, we didn't see load [take] very often since it occurs
mostly on temporaries where we treat the copy_addr as the relevant take. Now
that we are checking temporaries though, we need to support this behavior.

Author: gottesmm

lib/SILOptimizer/Mandatory/MoveOnlyAddressCheckerUtils.cpp

@@ -2523,29 +2523,27 @@ void MoveOnlyAddressCheckerPImpl::rewriteUses(
   // scope, we would have emitted the scope expansion error during diagnostics.
   for (auto pair : addressUseState.borrows) {
     if (auto *li = dyn_cast<LoadInst>(pair.first)) {
-      if (li->getOwnershipQualifier() == LoadOwnershipQualifier::Copy) {
-        // If we had a load [copy], borrow then we know that all of its destroys
-        // must have been destroy_value. So we can just gather up those
-        // destroy_value and use then to create a new load_borrow scope.
-        SILBuilderWithScope builder(li);
-        auto *lbi = builder.createLoadBorrow(li->getLoc(), li->getOperand());
-        // We use this auxillary list to avoid iterator invalidation of
-        // li->getConsumingUse();
-        StackList<DestroyValueInst *> toDelete(lbi->getFunction());
-        for (auto *consumeUse : li->getConsumingUses()) {
-          auto *dvi = cast<DestroyValueInst>(consumeUse->getUser());
-          SILBuilderWithScope destroyBuilder(dvi);
-          destroyBuilder.createEndBorrow(dvi->getLoc(), lbi);
-          toDelete.push_back(dvi);
-          changed = true;
-        }
-        while (!toDelete.empty())
-          toDelete.pop_back_val()->eraseFromParent();
-
-        li->replaceAllUsesWith(lbi);
-        li->eraseFromParent();
-        continue;
+      // If we had a load -> load_borrow then we know that all of its destroys
+      // must have been destroy_value. So we can just gather up those
+      // destroy_value and use then to create a new load_borrow scope.
+      SILBuilderWithScope builder(li);
+      auto *lbi = builder.createLoadBorrow(li->getLoc(), li->getOperand());
+      // We use this auxillary list to avoid iterator invalidation of
+      // li->getConsumingUse();
+      StackList<DestroyValueInst *> toDelete(lbi->getFunction());
+      for (auto *consumeUse : li->getConsumingUses()) {
+        auto *dvi = cast<DestroyValueInst>(consumeUse->getUser());
+        SILBuilderWithScope destroyBuilder(dvi);
+        destroyBuilder.createEndBorrow(dvi->getLoc(), lbi);
+        toDelete.push_back(dvi);
+        changed = true;
       }
+      while (!toDelete.empty())
+        toDelete.pop_back_val()->eraseFromParent();
+
+      li->replaceAllUsesWith(lbi);
+      li->eraseFromParent();
+      continue;
     }
 
     llvm::dbgs() << "Borrow: " << *pair.first;

test/SILOptimizer/moveonly_addresschecker.sil

@@ -29,6 +29,7 @@ public struct NonTrivialStruct {
 sil @useNonTrivialStruct : $@convention(thin) (@guaranteed NonTrivialStruct) -> ()
 sil @getNonTrivialStruct : $@convention(thin) () -> @owned NonTrivialStruct
 sil @consumeNonTrivialStructAddr : $@convention(thin) (@in NonTrivialStruct) -> ()
+sil @consumeNonTrivialStruct : $@convention(thin) (@owned NonTrivialStruct) -> ()
 
 @_moveOnly
 public struct NonTrivialStructPair {
@@ -535,3 +536,42 @@ sil [ossa] @test_in_use : $@convention(thin) () -> () {
   %9999 = tuple ()
   return %9999 : $()
 }
+
+//////////////////////////////////////////
+// MARK: Load Take As Borrow/Copy Tests //
+//////////////////////////////////////////
+
+// CHECK-LABEL: sil [ossa] @load_take_as_load_borrow : $@convention(thin) (@owned NonTrivialStruct) -> () {
+// CHECK: [[ALLOC:%.*]] = alloc_stack $NonTrivialStruct
+// CHECK: [[BORROW:%.*]] = load_borrow [[ALLOC]]
+// CHECK: end_borrow [[BORROW]]
+// CHECK: } // end sil function 'load_take_as_load_borrow'
+sil [ossa] @load_take_as_load_borrow : $@convention(thin) (@owned NonTrivialStruct) -> () {
+bb0(%0 : @owned $NonTrivialStruct):
+  %1 = alloc_stack $NonTrivialStruct
+  %1a = mark_must_check [consumable_and_assignable] %1 : $*NonTrivialStruct
+  store %0 to [init] %1a : $*NonTrivialStruct
+  %2 = load [take] %1a : $*NonTrivialStruct
+  destroy_value %2 : $NonTrivialStruct
+  dealloc_stack %1 : $*NonTrivialStruct
+  %9999 = tuple()
+  return %9999 : $()
+}
+
+// CHECK-LABEL: sil [ossa] @load_take_as_load_take : $@convention(thin) (@owned NonTrivialStruct) -> () {
+// CHECK: [[ALLOC:%.*]] = alloc_stack $NonTrivialStruct
+// CHECK: [[LOAD:%.*]] = load [take] [[ALLOC]]
+// CHECK: apply {{%.*}}([[LOAD]])
+// CHECK: } // end sil function 'load_take_as_load_take'
+sil [ossa] @load_take_as_load_take : $@convention(thin) (@owned NonTrivialStruct) -> () {
+bb0(%0 : @owned $NonTrivialStruct):
+  %1 = alloc_stack $NonTrivialStruct
+  %1a = mark_must_check [consumable_and_assignable] %1 : $*NonTrivialStruct
+  store %0 to [init] %1a : $*NonTrivialStruct
+  %2 = load [take] %1a : $*NonTrivialStruct
+  %f = function_ref @consumeNonTrivialStruct : $@convention(thin) (@owned NonTrivialStruct) -> ()
+  apply %f(%2) : $@convention(thin) (@owned NonTrivialStruct) -> ()
+  dealloc_stack %1 : $*NonTrivialStruct
+  %9999 = tuple()
+  return %9999 : $()
+}

test/SILOptimizer/moveonly_addresschecker_diagnostics.sil

@@ -507,3 +507,25 @@ bb3:
   %23 = tuple ()
   return %23 : $()
 }
+
+/////////////////////////////////////////////
+// MARK: Load Take as Load Copy Diagnostic //
+/////////////////////////////////////////////
+
+sil [ossa] @load_take_as_load_copy : $@convention(thin) (@owned NonTrivialStruct) -> () {
+bb0(%0 : @owned $NonTrivialStruct):
+  %1 = alloc_stack $NonTrivialStruct, let, name "foo"
+  %1a = mark_must_check [consumable_and_assignable] %1 : $*NonTrivialStruct
+  // expected-error @-1 {{'foo' consumed more than once}}
+  store %0 to [init] %1a : $*NonTrivialStruct
+  %2 = load [take] %1a : $*NonTrivialStruct
+  %2a = copy_value %2 : $NonTrivialStruct
+  %f = function_ref @consumingUseNonTrivialStruct : $@convention(thin) (@owned NonTrivialStruct) -> ()
+  apply %f(%2) : $@convention(thin) (@owned NonTrivialStruct) -> ()
+  // expected-note @-1 {{consumed here}}
+  apply %f(%2a) : $@convention(thin) (@owned NonTrivialStruct) -> ()
+  // expected-note @-1 {{consumed again here}}
+  dealloc_stack %1 : $*NonTrivialStruct
+  %9999 = tuple()
+  return %9999 : $()
+}