[move-only] Add additional test coverage to nonescaping closure test.

Specifically:

1. I added consuming test cases alongside __owned test cases.

2. I inserted the actual error messages so that we can see if we are emitting
   the correct error messages.

3. I enabled the NONTRIVIAL and NONTRIVIAL/REABSTRACT variants of the tests.

There are some differences in the address only version of the test that I am
still looking into.

Author: gottesmm

test/SILOptimizer/moveonly_nonescaping_closures.swift

@@ -1,4 +1,6 @@
 // RUN: %target-swift-frontend -emit-sil -verify %s
+// RUN: %target-swift-frontend -DNONTRIVIAL -emit-sil -verify %s
+// RUN: %target-swift-frontend -DNONTRIVIAL -DREABSTRACT -emit-sil -verify %s
 // TODO: test with (-DNONTRIVIAL | -DADDRESS_ONLY) * (REABSTRACT)
 
 protocol P {}
@@ -52,17 +54,33 @@ func b(x: __owned M) { // expected-error {{'x' used after consume}}
     // expected-note @-2:37 {{consuming use here}}
 }
 
+func b2(x: consuming M) {
+    clodger({ borrow(x) }, // expected-note {{conflicting access is here}}
+            consume: x) // expected-error {{overlapping accesses to 'x', but deinitialization requires exclusive access}}
+}
+
 func c(x: __owned M) {
     clodger({ borrow(x) })
     borrow(x)
     consume(x)
 }
 
+func c2(x: consuming M) {
+    clodger({ borrow(x) })
+    borrow(x)
+    consume(x)
+}
+
 func d(x: __owned M) { // expected-error {{'x' consumed in closure. This is illegal since if the closure is invoked more than once the binding will be uninitialized on later invocations}}
     clodger({ consume(x) })
     // expected-note @-1 {{consuming use here}}
 }
 
+func d2(x: consuming M) { // expected-error {{'x' consumed in closure but not reinitialized before end of closure}}
+    clodger({ consume(x) })
+    // expected-note @-1 {{consuming use here}}
+}
+
 func e(x: inout M) {
     clodger({ mutate(&x) })
     mutate(&x)
@@ -76,16 +94,19 @@ func f(x: borrowing M) {
 }
 
 func g(x: inout M) {
-    clodger({ mutate(&x) }, borrow: x) // expected-error{{}} // expected-note{{}}
+    clodger({ mutate(&x) }, // expected-error {{overlapping accesses to 'x', but modification requires exclusive access}}}
+            borrow: x)      // expected-note {{conflicting access is here}}
 }
 
 func h(x: inout M) {
-    clodger({ mutate(&x) }, consume: x) // expected-error{{}} // expected-note{{}}
+    clodger({ mutate(&x) }, // expected-note {{conflicting access is here}}
+            consume: x) // expected-error {{overlapping accesses to 'x', but deinitialization requires exclusive access}}}
     x = M()
 }
 
 func i(x: inout M) {
-    clodger({ mutate(&x) }, mutate: &x) // expected-error{{}} // expected-note{{}}
+    clodger({ mutate(&x) }, // expected-note {{conflicting access is here}}
+            mutate: &x) // expected-error {{overlapping accesses to 'x', but modification requires exclusive access}}}
 }
 
 // Multiple closures are allowed to capture the same inout binding concurrently.
@@ -100,20 +121,20 @@ func k(x: borrowing M) {
 }
 
 
-func l(x: inout M) { // expected-error{{}}
-    clodger({ consume(x) }) // expected-note{{}}
+func l(x: inout M) { // expected-error {{'x' consumed in closure but not reinitialized before end of closure}}
+    clodger({ consume(x) }) // expected-note {{consuming use here}}
 }
 
-func m(x: inout M) { // expected-error{{}}
-    consume(x) // expected-note{{}}
+func m(x: inout M) { // expected-error {{'x' used after consume}}
+    consume(x) // expected-note {{consuming use here}}
 
-    clodger({ borrow(x) }) // expected-note{{}}
+    clodger({ borrow(x) }) // expected-note {{non-consuming use here}}
 }
 
-func n(x: inout M) { // expected-error{{}}
-    consume(x) // expected-note{{}}
+func n(x: inout M) { // expected-error {{'x' used after consume}}
+    consume(x) // expected-note {{consuming use here}}
 
-    clodger({ // expected-note{{}}
+    clodger({ // expected-note {{non-consuming use here}}
         mutate(&x)
     })
 }