[no-implicit-copy] When accessing a field from a no-implicit-copy struct, unwrap it. Also do not run the move only borrow to destructure transform error.

gottesmm · gottesmm · commit d909c8978e7e · 2023-02-01T14:48:45.000-08:00
The reason to do the first is to ensure that when I enable -sil-verify-all, we
do not have errors due to a copy_value of a move only type.

The reason to do the second thing is that:

1. If we have a move only type that is no implicit copy, I am in a subsequent
commit going to emit a type checker error saying that one cannot do this. When
we implement consuming/borrowing bindings/etc, we can make this looser if it
gets into the way.

2. If we have a copyable no implicit copy type, then any structural accesses
that we may want to do that would require a destructure must be to a copyable
type which is ok to copy as long as we do the unwrap from the first thing.

rdar://104929957
diff --git a/lib/SILGen/SILGenLValue.cpp b/lib/SILGen/SILGenLValue.cpp
@@ -21,6 +21,7 @@
 #include "ExecutorBreadcrumb.h"
 #include "Initialization.h"
 #include "LValue.h"
+#include "ManagedValue.h"
 #include "RValue.h"
 #include "SILGen.h"
 #include "SILGenFunction.h"
@@ -4606,6 +4607,19 @@ RValue SILGenFunction::emitLoadOfLValue(SILLocation loc, LValue &&src,
                      substFormalType, rvalueTL, C, IsNotTake, isBaseGuaranteed);
       } else if (isReadAccessResultOwned(src.getAccessKind()) &&
           !projection.isPlusOne(*this)) {
+
+        // Before we copy, if we have a move only wrapped value, unwrap the
+        // value using a guaranteed moveonlywrapper_to_copyable.
+        if (projection.getType().isMoveOnlyWrapped()) {
+          // We are assuming we always get a guaranteed value here.
+          assert(projection.getValue()->getOwnershipKind() ==
+                 OwnershipKind::Guaranteed);
+          // We use SILValues here to ensure we get a tight scope around our
+          // copy.
+          projection =
+              B.createGuaranteedMoveOnlyWrapperToCopyableValue(loc, projection);
+        }
+
         projection = projection.copy(*this, loc);
       }
 
diff --git a/lib/SILOptimizer/Mandatory/MoveOnlyBorrowToDestructureTransform.cpp b/lib/SILOptimizer/Mandatory/MoveOnlyBorrowToDestructureTransform.cpp
@@ -345,6 +345,20 @@ void BorrowToDestructureTransform::checkDestructureUsesOnBoundary() const {
 
 bool BorrowToDestructureTransform::gatherBorrows(
     MarkMustCheckInst *mmci, StackList<BeginBorrowInst *> &borrowWorklist) {
+  // If we have a no implicit copy mark_must_check, we do not run the borrow to
+  // destructure transform since:
+  //
+  // 1. If we have a move only type, we should have emitted an earlier error
+  //    saying that move only types should not be marked as no implicit copy.
+  //
+  // 2. If we do not have a move only type, then we know that all fields that we
+  //    access directly and would cause a need to destructure must be copyable,
+  //    so no transformation/error is needed.
+  if (mmci->getType().isMoveOnlyWrapped()) {
+    LLVM_DEBUG(llvm::dbgs() << "Skipping move only wrapped inst: " << *mmci);
+    return true;
+  }
+
   LLVM_DEBUG(llvm::dbgs() << "Searching for borrows for inst: " << *mmci);
 
   StackList<Operand *> worklist(mmci->getFunction());
diff --git a/test/SILGen/noimplicitcopy.swift b/test/SILGen/noimplicitcopy.swift
@@ -22,6 +22,15 @@ class Klass {
     func increment() { i += 1 }
 }
 
+struct Trivial {
+    var value = 5
+}
+
+struct NonTrivial {
+    var value = Klass()
+}
+
+
 ///////////
 // Tests //
 ///////////
@@ -461,3 +470,24 @@ func callPrintKlassOwnedOwnedArgThrows() throws {
     y = Klass()
     try printKlassOwnedArgThrows(y)
 }
+
+//////////////
+// Gep Test //
+//////////////
+
+// CHECK-LABEL: sil hidden [ossa] @$s14noimplicitcopy19test_nontrivial_gepyyAA7TrivialVF : $@convention(thin) (Trivial) -> () {
+// CHECK: bb0([[ARG:%.*]] : $Trivial):
+// CHECK:   [[WRAPPED:%.*]] = copyable_to_moveonlywrapper [owned] [[ARG]]
+// CHECK:   [[MV_WRAPPED:%.*]] = move_value [lexical] [[WRAPPED]]
+// CHECK:   [[MARKED:%.*]] = mark_must_check [no_implicit_copy] [[MV_WRAPPED]]
+// CHECK:   [[BORROW:%.*]] = begin_borrow [[MARKED]]
+// CHECK:   [[EXT:%.*]] = struct_extract [[BORROW]]
+// CHECK:   [[UNWRAPPED:%.*]] = moveonlywrapper_to_copyable [guaranteed] [[EXT]]
+// CHECK:   apply {{%.*}}([[UNWRAPPED]])
+// CHECK:   end_borrow [[BORROW]]
+// CHECK:   destroy_value [[MARKED]]
+// CHECK: } // end sil function '$s14noimplicitcopy19test_nontrivial_gepyyAA7TrivialVF'
+func test_nontrivial_gep(_ x: Trivial) {
+    @_noImplicitCopy let y = x
+    print2(y.value)
+}
diff --git a/test/SILOptimizer/noimplicitcopy.swift b/test/SILOptimizer/noimplicitcopy.swift
@@ -866,26 +866,23 @@ public func aggStructAccessFieldOwnedArg(@_noImplicitCopy _ x2: __owned AggStruc
 
 public func aggStructConsumeField(_ x: AggStruct) {
     @_noImplicitCopy let x2 = x
-    // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}
     classConsume(x2.lhs)
     for _ in 0..<1024 {
-        classConsume(x2.lhs) // expected-note {{consuming use here}}
+        classConsume(x2.lhs)
     }
 }
 
 public func aggStructConsumeFieldArg(@_noImplicitCopy _ x2: AggStruct) {
-    // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}
     classConsume(x2.lhs)
     for _ in 0..<1024 {
-        classConsume(x2.lhs) // expected-note {{consuming use here}}
+        classConsume(x2.lhs)
     }
 }
 
 public func aggStructConsumeFieldOwnedArg(@_noImplicitCopy _ x2: __owned AggStruct) {
-    // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}
     classConsume(x2.lhs)
     for _ in 0..<1024 {
-        classConsume(x2.lhs) // expected-note {{consuming use here}}
+        classConsume(x2.lhs)
     }
 }
 
@@ -913,26 +910,25 @@ public func aggStructAccessGrandFieldOwnedArg(@_noImplicitCopy _ x2: __owned Agg
 
 public func aggStructConsumeGrandField(_ x: AggStruct) {
     @_noImplicitCopy let x2 = x
-    // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}
+
     classConsume(x2.pair.lhs)
     for _ in 0..<1024 {
-        classConsume(x2.pair.lhs) // expected-note {{consuming use here}}
+        classConsume(x2.pair.lhs)
     }
 }
 
 public func aggStructConsumeGrandFieldArg(@_noImplicitCopy _ x2: AggStruct) {
-    // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}
     classConsume(x2.pair.lhs)
     for _ in 0..<1024 {
-        classConsume(x2.pair.lhs) // expected-note {{consuming use here}}
+        classConsume(x2.pair.lhs)
     }
 }
 
 public func aggStructConsumeGrandFieldOwnedArg(@_noImplicitCopy _ x2: __owned AggStruct) {
-    // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}
+
     classConsume(x2.pair.lhs)
     for _ in 0..<1024 {
-        classConsume(x2.pair.lhs) // expected-note {{consuming use here}}
+        classConsume(x2.pair.lhs)
     }
 }
 
@@ -1136,26 +1132,24 @@ public func aggGenericStructAccessFieldOwnedArg(@_noImplicitCopy _ x2: __owned A
 
 public func aggGenericStructConsumeField(_ x: AggGenericStruct<Klass>) {
     @_noImplicitCopy let x2 = x
-    // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}
+
     classConsume(x2.lhs)
     for _ in 0..<1024 {
-        classConsume(x2.lhs) // expected-note {{consuming use here}}
+        classConsume(x2.lhs)
     }
 }
 
 public func aggGenericStructConsumeFieldArg(@_noImplicitCopy _ x2: AggGenericStruct<Klass>) {
-    // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}
     classConsume(x2.lhs)
     for _ in 0..<1024 {
-        classConsume(x2.lhs) // expected-note {{consuming use here}}
+        classConsume(x2.lhs)
     }
 }
 
 public func aggGenericStructConsumeFieldOwnedArg(@_noImplicitCopy _ x2: __owned AggGenericStruct<Klass>) {
-    // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}
     classConsume(x2.lhs)
     for _ in 0..<1024 {
-        classConsume(x2.lhs) // expected-note {{consuming use here}}
+        classConsume(x2.lhs)
     }
 }
 
@@ -1183,26 +1177,24 @@ public func aggGenericStructAccessGrandFieldOwnedArg(@_noImplicitCopy _ x2: __ow
 
 public func aggGenericStructConsumeGrandField(_ x: AggGenericStruct<Klass>) {
     @_noImplicitCopy let x2 = x
-    // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}
+
     classConsume(x2.pair.lhs)
     for _ in 0..<1024 {
-        classConsume(x2.pair.lhs) // expected-note {{consuming use here}}
+        classConsume(x2.pair.lhs)
     }
 }
 
 public func aggGenericStructConsumeGrandFieldArg(@_noImplicitCopy _ x2: AggGenericStruct<Klass>) {
-    // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}
     classConsume(x2.pair.lhs)
     for _ in 0..<1024 {
-        classConsume(x2.pair.lhs) // expected-note {{consuming use here}}
+        classConsume(x2.pair.lhs)
     }
 }
 
 public func aggGenericStructConsumeGrandFieldOwnedArg(@_noImplicitCopy _ x2: __owned AggGenericStruct<Klass>) {
-    // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}
     classConsume(x2.pair.lhs)
     for _ in 0..<1024 {
-        classConsume(x2.pair.lhs) // expected-note {{consuming use here}}
+        classConsume(x2.pair.lhs)
     }
 }
 
@@ -1400,26 +1392,24 @@ public func aggGenericStructAccessFieldOwnedArg<T>(@_noImplicitCopy _ x2: __owne
 
 public func aggGenericStructConsumeField<T>(_ x: AggGenericStruct<T>) {
     @_noImplicitCopy let x2 = x
-    // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}
+
     classConsume(x2.lhs)
     for _ in 0..<1024 {
-        classConsume(x2.lhs) // expected-note {{consuming use here}}
+        classConsume(x2.lhs)
     }
 }
 
 public func aggGenericStructConsumeFieldArg<T>(@_noImplicitCopy _ x2: AggGenericStruct<T>) {
-    // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}
     classConsume(x2.lhs)
     for _ in 0..<1024 {
-        classConsume(x2.lhs) // expected-note {{consuming use here}}
+        classConsume(x2.lhs)
     }
 }
 
 public func aggGenericStructConsumeFieldOwnedArg<T>(@_noImplicitCopy _ x2: __owned AggGenericStruct<T>) {
-    // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}
     classConsume(x2.lhs)
     for _ in 0..<1024 {
-        classConsume(x2.lhs) // expected-note {{consuming use here}}
+        classConsume(x2.lhs)
     }
 }
 
@@ -1447,26 +1437,25 @@ public func aggGenericStructAccessGrandFieldOwnedArg<T>(@_noImplicitCopy _ x2: _
 
 public func aggGenericStructConsumeGrandField<T>(_ x: AggGenericStruct<T>) {
     @_noImplicitCopy let x2 = x
-    // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}
+
     classConsume(x2.pair.lhs)
     for _ in 0..<1024 {
-        classConsume(x2.pair.lhs) // expected-note {{consuming use here}}
+        classConsume(x2.pair.lhs)
     }
 }
 
 public func aggGenericStructConsumeGrandFieldArg<T>(@_noImplicitCopy _ x2: AggGenericStruct<T>) {
-    // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}
+
     classConsume(x2.pair.lhs)
     for _ in 0..<1024 {
-        classConsume(x2.pair.lhs) // expected-note {{consuming use here}}
+        classConsume(x2.pair.lhs)
     }
 }
 
 public func aggGenericStructConsumeGrandFieldOwnedArg<T>(@_noImplicitCopy _ x2: __owned AggGenericStruct<T>) {
-    // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}
     classConsume(x2.pair.lhs)
     for _ in 0..<1024 {
-        classConsume(x2.pair.lhs) // expected-note {{consuming use here}}
+        classConsume(x2.pair.lhs)
     }
 }
 
diff --git a/test/SILOptimizer/noimplicitcopy_borrow_to_destructure_transform.sil b/test/SILOptimizer/noimplicitcopy_borrow_to_destructure_transform.sil
diff --git a/test/SILOptimizer/noimplicitcopy_trivial.swift b/test/SILOptimizer/noimplicitcopy_trivial.swift

Original file line number	Diff line number	Diff line change
`@@ -866,26 +866,23 @@ public func aggStructAccessFieldOwnedArg(@_noImplicitCopy _ x2: __owned AggStruc`
`866`	`866`
`867`	`867`	`public func aggStructConsumeField(_ x: AggStruct) {`
`868`	`868`	`@_noImplicitCopy let x2 = x`
`869`		`- // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}`
`870`	`869`	`classConsume(x2.lhs)`
`871`	`870`	`for _ in 0..<1024 {`
`872`		`- classConsume(x2.lhs) // expected-note {{consuming use here}}`
	`871`	`+ classConsume(x2.lhs)`
`873`	`872`	`}`
`874`	`873`	`}`
`875`	`874`
`876`	`875`	`public func aggStructConsumeFieldArg(@_noImplicitCopy _ x2: AggStruct) {`
`877`		`- // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}`
`878`	`876`	`classConsume(x2.lhs)`
`879`	`877`	`for _ in 0..<1024 {`
`880`		`- classConsume(x2.lhs) // expected-note {{consuming use here}}`
	`878`	`+ classConsume(x2.lhs)`
`881`	`879`	`}`
`882`	`880`	`}`
`883`	`881`
`884`	`882`	`public func aggStructConsumeFieldOwnedArg(@_noImplicitCopy _ x2: __owned AggStruct) {`
`885`		`- // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}`
`886`	`883`	`classConsume(x2.lhs)`
`887`	`884`	`for _ in 0..<1024 {`
`888`		`- classConsume(x2.lhs) // expected-note {{consuming use here}}`
	`885`	`+ classConsume(x2.lhs)`
`889`	`886`	`}`
`890`	`887`	`}`
`891`	`888`
`@@ -913,26 +910,25 @@ public func aggStructAccessGrandFieldOwnedArg(@_noImplicitCopy _ x2: __owned Agg`
`913`	`910`
`914`	`911`	`public func aggStructConsumeGrandField(_ x: AggStruct) {`
`915`	`912`	`@_noImplicitCopy let x2 = x`
`916`		`- // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}`
	`913`	`+`
`917`	`914`	`classConsume(x2.pair.lhs)`
`918`	`915`	`for _ in 0..<1024 {`
`919`		`- classConsume(x2.pair.lhs) // expected-note {{consuming use here}}`
	`916`	`+ classConsume(x2.pair.lhs)`
`920`	`917`	`}`
`921`	`918`	`}`
`922`	`919`
`923`	`920`	`public func aggStructConsumeGrandFieldArg(@_noImplicitCopy _ x2: AggStruct) {`
`924`		`- // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}`
`925`	`921`	`classConsume(x2.pair.lhs)`
`926`	`922`	`for _ in 0..<1024 {`
`927`		`- classConsume(x2.pair.lhs) // expected-note {{consuming use here}}`
	`923`	`+ classConsume(x2.pair.lhs)`
`928`	`924`	`}`
`929`	`925`	`}`
`930`	`926`
`931`	`927`	`public func aggStructConsumeGrandFieldOwnedArg(@_noImplicitCopy _ x2: __owned AggStruct) {`
`932`		`- // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}`
	`928`	`+`
`933`	`929`	`classConsume(x2.pair.lhs)`
`934`	`930`	`for _ in 0..<1024 {`
`935`		`- classConsume(x2.pair.lhs) // expected-note {{consuming use here}}`
	`931`	`+ classConsume(x2.pair.lhs)`
`936`	`932`	`}`
`937`	`933`	`}`
`938`	`934`
`@@ -1136,26 +1132,24 @@ public func aggGenericStructAccessFieldOwnedArg(@_noImplicitCopy _ x2: __owned A`
`1136`	`1132`
`1137`	`1133`	`public func aggGenericStructConsumeField(_ x: AggGenericStruct<Klass>) {`
`1138`	`1134`	`@_noImplicitCopy let x2 = x`
`1139`		`- // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}`
	`1135`	`+`
`1140`	`1136`	`classConsume(x2.lhs)`
`1141`	`1137`	`for _ in 0..<1024 {`
`1142`		`- classConsume(x2.lhs) // expected-note {{consuming use here}}`
	`1138`	`+ classConsume(x2.lhs)`
`1143`	`1139`	`}`
`1144`	`1140`	`}`
`1145`	`1141`
`1146`	`1142`	`public func aggGenericStructConsumeFieldArg(@_noImplicitCopy _ x2: AggGenericStruct<Klass>) {`
`1147`		`- // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}`
`1148`	`1143`	`classConsume(x2.lhs)`
`1149`	`1144`	`for _ in 0..<1024 {`
`1150`		`- classConsume(x2.lhs) // expected-note {{consuming use here}}`
	`1145`	`+ classConsume(x2.lhs)`
`1151`	`1146`	`}`
`1152`	`1147`	`}`
`1153`	`1148`
`1154`	`1149`	`public func aggGenericStructConsumeFieldOwnedArg(@_noImplicitCopy _ x2: __owned AggGenericStruct<Klass>) {`
`1155`		`- // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}`
`1156`	`1150`	`classConsume(x2.lhs)`
`1157`	`1151`	`for _ in 0..<1024 {`
`1158`		`- classConsume(x2.lhs) // expected-note {{consuming use here}}`
	`1152`	`+ classConsume(x2.lhs)`
`1159`	`1153`	`}`
`1160`	`1154`	`}`
`1161`	`1155`
`@@ -1183,26 +1177,24 @@ public func aggGenericStructAccessGrandFieldOwnedArg(@_noImplicitCopy _ x2: __ow`
`1183`	`1177`
`1184`	`1178`	`public func aggGenericStructConsumeGrandField(_ x: AggGenericStruct<Klass>) {`
`1185`	`1179`	`@_noImplicitCopy let x2 = x`
`1186`		`- // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}`
	`1180`	`+`
`1187`	`1181`	`classConsume(x2.pair.lhs)`
`1188`	`1182`	`for _ in 0..<1024 {`
`1189`		`- classConsume(x2.pair.lhs) // expected-note {{consuming use here}}`
	`1183`	`+ classConsume(x2.pair.lhs)`
`1190`	`1184`	`}`
`1191`	`1185`	`}`
`1192`	`1186`
`1193`	`1187`	`public func aggGenericStructConsumeGrandFieldArg(@_noImplicitCopy _ x2: AggGenericStruct<Klass>) {`
`1194`		`- // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}`
`1195`	`1188`	`classConsume(x2.pair.lhs)`
`1196`	`1189`	`for _ in 0..<1024 {`
`1197`		`- classConsume(x2.pair.lhs) // expected-note {{consuming use here}}`
	`1190`	`+ classConsume(x2.pair.lhs)`
`1198`	`1191`	`}`
`1199`	`1192`	`}`
`1200`	`1193`
`1201`	`1194`	`public func aggGenericStructConsumeGrandFieldOwnedArg(@_noImplicitCopy _ x2: __owned AggGenericStruct<Klass>) {`
`1202`		`- // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}`
`1203`	`1195`	`classConsume(x2.pair.lhs)`
`1204`	`1196`	`for _ in 0..<1024 {`
`1205`		`- classConsume(x2.pair.lhs) // expected-note {{consuming use here}}`
	`1197`	`+ classConsume(x2.pair.lhs)`
`1206`	`1198`	`}`
`1207`	`1199`	`}`
`1208`	`1200`
`@@ -1400,26 +1392,24 @@ public func aggGenericStructAccessFieldOwnedArg<T>(@_noImplicitCopy _ x2: __owne`
`1400`	`1392`
`1401`	`1393`	`public func aggGenericStructConsumeField<T>(_ x: AggGenericStruct<T>) {`
`1402`	`1394`	`@_noImplicitCopy let x2 = x`
`1403`		`- // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}`
	`1395`	`+`
`1404`	`1396`	`classConsume(x2.lhs)`
`1405`	`1397`	`for _ in 0..<1024 {`
`1406`		`- classConsume(x2.lhs) // expected-note {{consuming use here}}`
	`1398`	`+ classConsume(x2.lhs)`
`1407`	`1399`	`}`
`1408`	`1400`	`}`
`1409`	`1401`
`1410`	`1402`	`public func aggGenericStructConsumeFieldArg<T>(@_noImplicitCopy _ x2: AggGenericStruct<T>) {`
`1411`		`- // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}`
`1412`	`1403`	`classConsume(x2.lhs)`
`1413`	`1404`	`for _ in 0..<1024 {`
`1414`		`- classConsume(x2.lhs) // expected-note {{consuming use here}}`
	`1405`	`+ classConsume(x2.lhs)`
`1415`	`1406`	`}`
`1416`	`1407`	`}`
`1417`	`1408`
`1418`	`1409`	`public func aggGenericStructConsumeFieldOwnedArg<T>(@_noImplicitCopy _ x2: __owned AggGenericStruct<T>) {`
`1419`		`- // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}`
`1420`	`1410`	`classConsume(x2.lhs)`
`1421`	`1411`	`for _ in 0..<1024 {`
`1422`		`- classConsume(x2.lhs) // expected-note {{consuming use here}}`
	`1412`	`+ classConsume(x2.lhs)`
`1423`	`1413`	`}`
`1424`	`1414`	`}`
`1425`	`1415`
`@@ -1447,26 +1437,25 @@ public func aggGenericStructAccessGrandFieldOwnedArg<T>(@_noImplicitCopy _ x2: _`
`1447`	`1437`
`1448`	`1438`	`public func aggGenericStructConsumeGrandField<T>(_ x: AggGenericStruct<T>) {`
`1449`	`1439`	`@_noImplicitCopy let x2 = x`
`1450`		`- // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}`
	`1440`	`+`
`1451`	`1441`	`classConsume(x2.pair.lhs)`
`1452`	`1442`	`for _ in 0..<1024 {`
`1453`		`- classConsume(x2.pair.lhs) // expected-note {{consuming use here}}`
	`1443`	`+ classConsume(x2.pair.lhs)`
`1454`	`1444`	`}`
`1455`	`1445`	`}`
`1456`	`1446`
`1457`	`1447`	`public func aggGenericStructConsumeGrandFieldArg<T>(@_noImplicitCopy _ x2: AggGenericStruct<T>) {`
`1458`		`- // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}`
	`1448`	`+`
`1459`	`1449`	`classConsume(x2.pair.lhs)`
`1460`	`1450`	`for _ in 0..<1024 {`
`1461`		`- classConsume(x2.pair.lhs) // expected-note {{consuming use here}}`
	`1451`	`+ classConsume(x2.pair.lhs)`
`1462`	`1452`	`}`
`1463`	`1453`	`}`
`1464`	`1454`
`1465`	`1455`	`public func aggGenericStructConsumeGrandFieldOwnedArg<T>(@_noImplicitCopy _ x2: __owned AggGenericStruct<T>) {`
`1466`		`- // expected-error @-1 {{'x2' has a move only field that was consumed before later uses}}`
`1467`	`1456`	`classConsume(x2.pair.lhs)`
`1468`	`1457`	`for _ in 0..<1024 {`
`1469`		`- classConsume(x2.pair.lhs) // expected-note {{consuming use here}}`
	`1458`	`+ classConsume(x2.pair.lhs)`
`1470`	`1459`	`}`
`1471`	`1460`	`}`
`1472`	`1461`