tighten up consistency in terminology

- refer to a "consuming use" as simply a "consume", to reserve "use" for non-consuming uses.
- refer to "non-consuming uses" as just a "use".
- don't call it a "user defined deinit" and instead a "deinitializer" to match Sema
- be specific about what binding a closure is capturing that is preventing consumption.

rdar://109281444

Author: kavon

include/swift/AST/DiagnosticsSIL.def

@@ -764,7 +764,7 @@ ERROR(sil_moveonlychecker_capture_consumed, none,
 ERROR(sil_moveonlychecker_inout_not_reinitialized_before_end_of_function, none,
       "missing reinitialization of inout parameter '%0' after consume", (StringRef))
 ERROR(sil_moveonlychecker_value_consumed_in_a_loop, none,
-      "'%0' consumed by a use in a loop", (StringRef))
+      "'%0' consumed in a loop", (StringRef))
 
 ERROR(sil_moveonlychecker_use_after_partial_consume, none,
       "cannot use '%0' after partial consume", (StringRef))
@@ -774,28 +774,23 @@ ERROR(sil_moveonlychecker_notconsumable_but_assignable_was_consumed, none,
       (StringRef, bool))
 
 ERROR(sil_moveonlychecker_cannot_destructure_has_deinit, none,
-      "cannot partially consume '%0' since it has a user defined deinit",
+      "cannot partially consume '%0' when it has a deinitializer",
       (StringRef))
 
 NOTE(sil_moveonlychecker_partial_consume_here, none,
-     "partial consume here", ())
+     "partially consumed here", ())
 NOTE(sil_moveonlychecker_consuming_use_here, none,
-     "consuming use here", ())
+     "consumed here", ())
 NOTE(sil_moveonlychecker_other_consuming_use_here, none,
-     "other consuming use here", ())
+     "other consume here", ())
 NOTE(sil_moveonlychecker_two_consuming_uses_here, none,
-     "two consuming uses here", ())
+     "multiple consumes here", ())
 NOTE(sil_moveonlychecker_consuming_and_non_consuming_uses_here, none,
-     "consuming and non-consuming uses here", ())
+     "consumed and used here", ())
 NOTE(sil_moveonlychecker_consuming_closure_use_here, none,
-     "closure capture here", ())
-
-// TODO: a lot of these "non-consuming use" notes are just emitted to point out
-// an "invalid use after consume". I'd say most of them are for that.
-// In the other narrow cases where that's not quite right, we could go with
-// something vague like "use here"
+     "closure capturing '%0' here", (StringRef))
 NOTE(sil_moveonlychecker_nonconsuming_use_here, none,
-     "non-consuming use here", ())
+     "used here", ())
 
 NOTE(sil_movekillscopyablevalue_value_cyclic_consumed_in_loop_here, none,
      "consuming in loop use here", ())

lib/SILOptimizer/Mandatory/MoveOnlyDiagnostics.cpp

@@ -205,7 +205,7 @@ void DiagnosticEmitter::emitObjectGuaranteedDiagnostic(
     diagnose(astContext, markedValue,
              diag::sil_moveonlychecker_guaranteed_value_captured_by_closure,
              varName);
-    emitObjectDiagnosticsForPartialApplyUses();
+    emitObjectDiagnosticsForPartialApplyUses(varName);
     registerDiagnosticEmitted(markedValue);
   }
 
@@ -379,22 +379,27 @@ void DiagnosticEmitter::emitObjectDiagnosticsForGuaranteedUses(
   }
 }
 
-void DiagnosticEmitter::emitObjectDiagnosticsForPartialApplyUses() const {
+void DiagnosticEmitter::emitObjectDiagnosticsForPartialApplyUses(
+    StringRef capturedVarName) const {
   auto &astContext = fn->getASTContext();
 
   for (auto *user : getCanonicalizer().consumingUsesNeedingCopy) {
     if (!isa<PartialApplyInst>(user))
       continue;
-    diagnose(astContext, user,
-             diag::sil_moveonlychecker_consuming_closure_use_here);
+    diagnose(astContext,
+             user,
+             diag::sil_moveonlychecker_consuming_closure_use_here,
+             capturedVarName);
   }
 
   for (auto *user : getCanonicalizer().consumingBoundaryUsers) {
     if (!isa<PartialApplyInst>(user))
       continue;
 
-    diagnose(astContext, user,
-             diag::sil_moveonlychecker_consuming_closure_use_here);
+    diagnose(astContext,
+             user,
+             diag::sil_moveonlychecker_consuming_closure_use_here,
+             capturedVarName);
   }
 }
 

lib/SILOptimizer/Mandatory/MoveOnlyDiagnostics.h

@@ -166,7 +166,7 @@ class DiagnosticEmitter {
   /// the caller processed it correctly. false, then we continue to process it.
   void
   emitObjectDiagnosticsForGuaranteedUses(bool ignorePartialApply = false) const;
-  void emitObjectDiagnosticsForPartialApplyUses() const;
+  void emitObjectDiagnosticsForPartialApplyUses(StringRef capturedVarName) const;
 
   void registerDiagnosticEmitted(MarkMustCheckInst *value) {
     ++diagnosticCount;

test/SILGen/moveonly_escaping_closure.swift

@@ -74,23 +74,23 @@ func testConsumeCopyable(_ x: consuming DeinitStruct) {
 }
 
 func testConsumeNonCopyable1(_ x: consuming DeinitStruct) {
-    // expected-error @+1 {{cannot partially consume 'x' since it has a user defined deinit}}
+    // expected-error @+1 {{cannot partially consume 'x' when it has a deinitializer}}
     consume(x.third.rhs)
 }
 
 func testConsumeNonCopyable2(_ x: consuming DeinitStruct) {
-    // expected-error @+1 {{cannot partially consume 'x' since it has a user defined deinit}}
+    // expected-error @+1 {{cannot partially consume 'x' when it has a deinitializer}}
     consume(x.fourth.0)
 }
 
 func testConsumeNonCopyable3(_ x: consuming DeinitStruct) {
-    // expected-error @+1 {{cannot partially consume 'x' since it has a user defined deinit}}
+    // expected-error @+1 {{cannot partially consume 'x' when it has a deinitializer}}
     consume(x.fourth.1)
 }
 
 
 func testConsumeNonCopyable4(_ x: consuming DeinitStruct) {
-    // expected-error @+1 {{cannot partially consume 'x' since it has a user defined deinit}}
+    // expected-error @+1 {{cannot partially consume 'x' when it has a deinitializer}}
     consume(x.fifth)
 }
 
@@ -120,33 +120,33 @@ func testStructContainDeinitStructConsumeCopyable1(_ x: consuming StructContainD
 
 
 func testStructContainStructContainDeinitStructConsumeNonCopyable1(_ xyz: consuming StructContainDeinitStruct) {
-    // expected-error @+1 {{cannot partially consume 'xyz.first' since it has a user defined deinit}}
+    // expected-error @+1 {{cannot partially consume 'xyz.first' when it has a deinitializer}}
     consume(xyz.first.third.rhs)
 }
 
 func testStructContainStructContainDeinitStructConsumeNonCopyable1a(_ x: consuming StructContainDeinitStruct) {
-    // expected-error @+1 {{cannot partially consume 'x.second.0' since it has a user defined deinit}}
+    // expected-error @+1 {{cannot partially consume 'x.second.0' when it has a deinitializer}}
     consume(x.second.0.third.rhs)
 }
 
 func testStructContainStructContainDeinitStructConsumeNonCopyable2(_ x: consuming StructContainDeinitStruct) {
-    // expected-error @+1 {{cannot partially consume 'x.first' since it has a user defined deinit}}
+    // expected-error @+1 {{cannot partially consume 'x.first' when it has a deinitializer}}
     consume(x.first.fourth.0)
 }
 
 func testStructContainStructContainDeinitStructConsumeNonCopyable2a(_ x: consuming StructContainDeinitStruct) {
-    // expected-error @+1 {{cannot partially consume 'x.second.1' since it has a user defined deinit}}
+    // expected-error @+1 {{cannot partially consume 'x.second.1' when it has a deinitializer}}
     consume(x.second.1.fourth.0)
 }
 
 func testStructContainStructContainDeinitStructConsumeNonCopyable3(_ x: consuming StructContainDeinitStruct) {
-    // expected-error @+1 {{cannot partially consume 'x.first' since it has a user defined deinit}}
+    // expected-error @+1 {{cannot partially consume 'x.first' when it has a deinitializer}}
     consume(x.first.fourth.1)
 }
 
 
 func testStructContainStructContainDeinitStructConsumeNonCopyable4(_ x: consuming StructContainDeinitStruct) {
-    // expected-error @+1 {{cannot partially consume 'x.first' since it has a user defined deinit}}
+    // expected-error @+1 {{cannot partially consume 'x.first' when it has a deinitializer}}
     consume(x.first.fifth)
 }
 

test/SILOptimizer/moveonly_addresschecker_destructure_through_deinit_diagnostics.swift

@@ -103,7 +103,7 @@ bb0(%0 : $Int):
   end_access %8 : $*AggStruct
   %12 = begin_access [read] [static] %3 : $*AggStruct
   %13 = struct_element_addr %12 : $*AggStruct, #AggStruct.lhs
-  %14 = load [copy] %13 : $*Klass // expected-note {{consuming use here}}
+  %14 = load [copy] %13 : $*Klass // expected-note {{consumed here}}
   end_access %12 : $*AggStruct
   %16 = move_value [lexical] %14 : $Klass
   %17 = mark_must_check [consumable_and_assignable] %16 : $Klass
@@ -112,7 +112,7 @@ bb0(%0 : $Int):
   %20 = move_value %19 : $Klass
   destroy_value %20 : $Klass
   destroy_value %17 : $Klass
-  %23 = load [copy] %3 : $*AggStruct // expected-note {{consuming use here}}
+  %23 = load [copy] %3 : $*AggStruct // expected-note {{consumed here}}
   destroy_addr %3 : $*AggStruct
   dealloc_stack %2 : $*AggStruct
   return %23 : $AggStruct
@@ -123,14 +123,14 @@ bb0(%arg : @owned $AggStruct):
   %0 = alloc_stack [lexical] $AggStruct, var, name "x2"
   %1 = mark_must_check [consumable_and_assignable] %0 : $*AggStruct
   // expected-error @-1 {{'x2' consumed more than once}}
-  // expected-error @-2 {{'x2' consumed by a use in a loop}}
+  // expected-error @-2 {{'x2' consumed in a loop}}
   %9 = begin_access [modify] [static] %1 : $*AggStruct
   store %arg to [init] %9 : $*AggStruct
   end_access %9 : $*AggStruct
   %12 = begin_access [read] [static] %1 : $*AggStruct
   %13 = struct_element_addr %12 : $*AggStruct, #AggStruct.pair
   %14 = struct_element_addr %13 : $*KlassPair, #KlassPair.lhs
-  %15 = load [copy] %14 : $*Klass // expected-note {{consuming use here}}
+  %15 = load [copy] %14 : $*Klass // expected-note {{consumed here}}
   end_access %12 : $*AggStruct
   %17 = function_ref @classConsume : $@convention(thin) (@owned Klass) -> ()
   %18 = apply %17(%15) : $@convention(thin) (@owned Klass) -> ()
@@ -144,8 +144,8 @@ bb2(%55 : $Int):
   %57 = struct_element_addr %56 : $*AggStruct, #AggStruct.pair
   %58 = struct_element_addr %57 : $*KlassPair, #KlassPair.lhs
   %59 = load [copy] %58 : $*Klass
-  // expected-note @-1 {{consuming use here}}
-  // expected-note @-2 {{consuming use here}}
+  // expected-note @-1 {{consumed here}}
+  // expected-note @-2 {{consumed here}}
   end_access %56 : $*AggStruct
   %61 = function_ref @classConsume : $@convention(thin) (@owned Klass) -> ()
   %62 = apply %61(%59) : $@convention(thin) (@owned Klass) -> ()
@@ -208,13 +208,13 @@ bb0(%arg : @owned $NonTrivialStruct, %arg1 : @owned $NonTrivialStruct):
   end_access %12 : $*NonTrivialStruct
   %19 = begin_access [read] [static] %1 : $*NonTrivialStruct
   %20 = struct_element_addr %19 : $*NonTrivialStruct, #NonTrivialStruct.k
-  %21 = load [copy] %20 : $*Klass // expected-note {{consuming use here}}
+  %21 = load [copy] %20 : $*Klass // expected-note {{consumed here}}
   end_access %19 : $*NonTrivialStruct
   %23 = function_ref @classConsume : $@convention(thin) (@owned Klass) -> ()
   %24 = apply %23(%21) : $@convention(thin) (@owned Klass) -> ()
   %25 = begin_access [read] [static] %1 : $*NonTrivialStruct
   %26 = struct_element_addr %25 : $*NonTrivialStruct, #NonTrivialStruct.k
-  %27 = load [copy] %26 : $*Klass // expected-note {{consuming use here}}
+  %27 = load [copy] %26 : $*Klass // expected-note {{consumed here}}
   end_access %25 : $*NonTrivialStruct
   %29 = function_ref @classConsume : $@convention(thin) (@owned Klass) -> ()
   %30 = apply %29(%27) : $@convention(thin) (@owned Klass) -> ()
@@ -257,7 +257,7 @@ bb0(%0 : @owned $NonTrivialStruct):
   %4 = mark_must_check [consumable_and_assignable] %3 : $*NonTrivialStruct // expected-error {{'x2' consumed more than once}}
   store %1 to [init] %4 : $*NonTrivialStruct
   %6 = function_ref @nonConsumingUseNonTrivialStruct : $@convention(thin) (@guaranteed NonTrivialStruct) -> ()
-  %7 = load [copy] %4 : $*NonTrivialStruct // expected-note {{consuming use here}}
+  %7 = load [copy] %4 : $*NonTrivialStruct // expected-note {{consumed here}}
   %8 = partial_apply [callee_guaranteed] %6(%7) : $@convention(thin) (@guaranteed NonTrivialStruct) -> ()
   %9 = begin_borrow [lexical] %8 : $@callee_guaranteed () -> ()
   debug_value %9 : $@callee_guaranteed () -> (), let, name "f"
@@ -266,7 +266,7 @@ bb0(%0 : @owned $NonTrivialStruct):
   destroy_value %11 : $@callee_guaranteed () -> ()
   %14 = alloc_stack $NonTrivialStruct, let, name "x3"
   %15 = mark_must_check [consumable_and_assignable] %14 : $*NonTrivialStruct
-  %16 = load [copy] %4 : $*NonTrivialStruct // expected-note {{consuming use here}}
+  %16 = load [copy] %4 : $*NonTrivialStruct // expected-note {{consumed here}}
   store %16 to [init] %15 : $*NonTrivialStruct
   %18 = load [copy] %15 : $*NonTrivialStruct
   %19 = move_value %18 : $NonTrivialStruct
@@ -289,10 +289,10 @@ bb0(%0 : @owned $NonTrivialStruct):
   %2 = mark_must_check [consumable_and_assignable] %1 : $*NonTrivialStruct // expected-error {{'x' used after consume}}
   store %0 to [init] %2 : $*NonTrivialStruct
   %4 = load_borrow %2 : $*NonTrivialStruct
-  %5 = load [copy] %2 : $*NonTrivialStruct // expected-note {{consuming use here}}
+  %5 = load [copy] %2 : $*NonTrivialStruct // expected-note {{consumed here}}
   %6 = function_ref @borrow_and_consume : $@convention(thin) (@guaranteed NonTrivialStruct, @owned NonTrivialStruct) -> ()
   %7 = apply %6(%4, %5) : $@convention(thin) (@guaranteed NonTrivialStruct, @owned NonTrivialStruct) -> ()
-  end_borrow %4 : $NonTrivialStruct // expected-note {{non-consuming use here}}
+  end_borrow %4 : $NonTrivialStruct // expected-note {{used here}}
   destroy_addr %2 : $*NonTrivialStruct
   dealloc_stack %1 : $*NonTrivialStruct
   %11 = tuple ()
@@ -309,12 +309,12 @@ bb0(%0 : $*Klass):
   %3 = alloc_stack [lexical] $Klass, var, name "y2"
   %4 = mark_must_check [consumable_and_assignable] %3 : $*Klass
   %5 = begin_access [read] [static] %1 : $*Klass
-  copy_addr %5 to [init] %4 : $*Klass // expected-note {{consuming use here}}
+  copy_addr %5 to [init] %4 : $*Klass // expected-note {{consumed here}}
   end_access %5 : $*Klass
   %8 = begin_access [read] [static] %1 : $*Klass
   %9 = load [copy] %8 : $*Klass
-  // expected-note @-1 {{consuming use here}}
-  // expected-note @-2 {{consuming use here}}
+  // expected-note @-1 {{consumed here}}
+  // expected-note @-2 {{consumed here}}
   end_access %8 : $*Klass
   %11 = begin_access [modify] [static] %4 : $*Klass
   store %9 to [assign] %11 : $*Klass
@@ -407,9 +407,9 @@ bb0(%0 : @owned $NonTrivialStruct):
 
   %8 = function_ref @coroutine_callee_uses_partial_apply : $@yield_once @convention(thin) (@guaranteed @callee_guaranteed () -> ()) -> @yields ()
   (%9, %10) = begin_apply %8(%6) : $@yield_once @convention(thin) (@guaranteed @callee_guaranteed () -> ()) -> @yields ()
-  %11 = load [copy] %2 : $*NonTrivialStruct // expected-note {{consuming use here}}
+  %11 = load [copy] %2 : $*NonTrivialStruct // expected-note {{consumed here}}
   %12 = apply %7(%11) : $@convention(thin) (@owned NonTrivialStruct) -> ()
-  end_apply %10 // expected-note {{non-consuming use here}}
+  end_apply %10 // expected-note {{used here}}
   destroy_value %6 : $@callee_guaranteed () -> ()
   destroy_addr %2 : $*NonTrivialStruct
   dealloc_stack %1 : $*NonTrivialStruct
@@ -431,9 +431,9 @@ bb0(%0 : @owned $NonTrivialStruct):
 
   %8 = function_ref @coroutine_callee_uses_partial_apply : $@yield_once @convention(thin) (@guaranteed @callee_guaranteed () -> ()) -> @yields ()
   (%9, %10) = begin_apply %8(%6) : $@yield_once @convention(thin) (@guaranteed @callee_guaranteed () -> ()) -> @yields ()
-  %11 = load [copy] %2 : $*NonTrivialStruct // expected-note {{consuming use here}}
+  %11 = load [copy] %2 : $*NonTrivialStruct // expected-note {{consumed here}}
   %12 = apply %7(%11) : $@convention(thin) (@owned NonTrivialStruct) -> ()
-  abort_apply %10 // expected-note {{non-consuming use here}}
+  abort_apply %10 // expected-note {{used here}}
   destroy_value %6 : $@callee_guaranteed () -> ()
   destroy_addr %2 : $*NonTrivialStruct
   dealloc_stack %1 : $*NonTrivialStruct
@@ -489,15 +489,15 @@ bb0(%0 : @owned $NonTrivialStruct):
   cond_br undef, bb1, bb2
 
 bb1:
-  %12 = load [copy] %2 : $*NonTrivialStruct // expected-note {{consuming use here}}
+  %12 = load [copy] %2 : $*NonTrivialStruct // expected-note {{consumed here}}
   %13 = apply %7(%12) : $@convention(thin) (@owned NonTrivialStruct) -> ()
-  abort_apply %10 // expected-note {{non-consuming use here}}
+  abort_apply %10 // expected-note {{used here}}
   br bb3
 
 bb2:
-  %16 = load [copy] %2 : $*NonTrivialStruct // expected-note {{consuming use here}}
+  %16 = load [copy] %2 : $*NonTrivialStruct // expected-note {{consumed here}}
   %17 = apply %7(%16) : $@convention(thin) (@owned NonTrivialStruct) -> ()
-  end_apply %10 // expected-note {{non-consuming use here}}
+  end_apply %10 // expected-note {{used here}}
   br bb3
 
 bb3: