reword diagnostics for partial consume of fields

also moves the error to the invalid partial consume.

rdar://109281444
(cherry picked from commit d3730d8)

Author: kavon

include/swift/AST/DiagnosticsSIL.def

@@ -775,12 +775,9 @@ ERROR(sil_moveonlychecker_notconsumable_but_assignable_was_consumed, none,
       "cannot consume noncopyable stored property '%0' %select{of a class|that is global}1",
       (StringRef, bool))
 
-ERROR(sil_moveonlychecker_cannot_destructure_deinit_nominal_type_self, none,
-      "Cannot partially consume '%0' since it has a user defined deinit",
+ERROR(sil_moveonlychecker_cannot_destructure_has_deinit, none,
+      "cannot partially consume '%0' since it has a user defined deinit",
       (StringRef))
-ERROR(sil_moveonlychecker_cannot_destructure_deinit_nominal_type_field, none,
-      "Cannot partially consume '%0' since it contains field '%1.%2' whose type %3 has a user defined deinit",
-      (StringRef, StringRef, StringRef, DeclBaseName))
 
 NOTE(sil_moveonlychecker_partial_consume_here, none,
      "partial consume here", ())

lib/SILOptimizer/Mandatory/MoveOnlyDiagnostics.cpp

@@ -683,25 +683,21 @@ void DiagnosticEmitter::emitCannotDestructureDeinitNominalError(
     MarkMustCheckInst *markedValue, StringRef pathString,
     NominalTypeDecl *deinitedNominal, SILInstruction *consumingUser) {
   auto &astContext = fn->getASTContext();
+
   SmallString<64> varName;
   getVariableNameForValue(markedValue, varName);
 
+  if (!pathString.empty())
+    varName.append(pathString);
+
+  diagnose(
+      astContext, consumingUser,
+      diag::sil_moveonlychecker_cannot_destructure_has_deinit,
+      varName);
   registerDiagnosticEmitted(markedValue);
 
-  if (pathString.empty()) {
-    diagnose(
-        astContext, markedValue,
-        diag::sil_moveonlychecker_cannot_destructure_deinit_nominal_type_self,
-        varName);
-  } else {
-    diagnose(
-        astContext, markedValue,
-        diag::sil_moveonlychecker_cannot_destructure_deinit_nominal_type_field,
-        varName, varName, pathString.drop_front(),
-        deinitedNominal->getBaseName());
-  }
-  diagnose(astContext, consumingUser,
-           diag::sil_moveonlychecker_consuming_use_here);
-  astContext.Diags.diagnose(deinitedNominal->getValueTypeDestructor(),
-                            diag::sil_moveonlychecker_deinit_here);
+  // point to the deinit if we know where it is.
+  if (auto deinitLoc =
+      deinitedNominal->getValueTypeDestructor()->getLoc(/*SerializedOK=*/false))
+    astContext.Diags.diagnose(deinitLoc, diag::sil_moveonlychecker_deinit_here);
 }

test/SILOptimizer/moveonly_addresschecker_destructure_through_deinit_diagnostics.swift

@@ -64,17 +64,7 @@ struct DeinitStruct : ~Copyable {
   var fourth: (MoveOnlyKlass, MoveOnlyKlass)
   var fifth: MoveOnlyKlass
 
-  deinit {}
-  // expected-note @-1 {{deinit declared here}}
-  // expected-note @-2 {{deinit declared here}}
-  // expected-note @-3 {{deinit declared here}}
-  // expected-note @-4 {{deinit declared here}}
-  // expected-note @-5 {{deinit declared here}}
-  // expected-note @-6 {{deinit declared here}}
-  // expected-note @-7 {{deinit declared here}}
-  // expected-note @-8 {{deinit declared here}}
-  // expected-note @-9 {{deinit declared here}}
-  // expected-note @-10 {{deinit declared here}}
+  deinit {} // expected-note 10{{deinit declared here}}
 }
 
 func testConsumeCopyable(_ x: consuming DeinitStruct) {
@@ -84,24 +74,24 @@ func testConsumeCopyable(_ x: consuming DeinitStruct) {
 }
 
 func testConsumeNonCopyable1(_ x: consuming DeinitStruct) {
-    // expected-error @-1 {{Cannot partially consume 'x' since it has a user defined deinit}}
-    consume(x.third.rhs) // expected-note {{consuming use here}}
+    // expected-error @+1 {{cannot partially consume 'x' since it has a user defined deinit}}
+    consume(x.third.rhs)
 }
 
 func testConsumeNonCopyable2(_ x: consuming DeinitStruct) {
-    // expected-error @-1 {{Cannot partially consume 'x' since it has a user defined deinit}}
-    consume(x.fourth.0) // expected-note {{consuming use here}}
+    // expected-error @+1 {{cannot partially consume 'x' since it has a user defined deinit}}
+    consume(x.fourth.0)
 }
 
 func testConsumeNonCopyable3(_ x: consuming DeinitStruct) {
-    // expected-error @-1 {{Cannot partially consume 'x' since it has a user defined deinit}}
-    consume(x.fourth.1) // expected-note {{consuming use here}}
+    // expected-error @+1 {{cannot partially consume 'x' since it has a user defined deinit}}
+    consume(x.fourth.1)
 }
 
 
 func testConsumeNonCopyable4(_ x: consuming DeinitStruct) {
-    // expected-error @-1 {{Cannot partially consume 'x' since it has a user defined deinit}}
-    consume(x.fifth) // expected-note {{consuming use here}}
+    // expected-error @+1 {{cannot partially consume 'x' since it has a user defined deinit}}
+    consume(x.fifth)
 }
 
 
@@ -129,35 +119,35 @@ func testStructContainDeinitStructConsumeCopyable1(_ x: consuming StructContainD
 }
 
 
-func testStructContainStructContainDeinitStructConsumeNonCopyable1(_ x: consuming StructContainDeinitStruct) {
-    // expected-error @-1 {{Cannot partially consume 'x' since it contains field 'x.first' whose type 'DeinitStruct' has a user defined deinit}}
-    consume(x.first.third.rhs) // expected-note {{consuming use here}}
+func testStructContainStructContainDeinitStructConsumeNonCopyable1(_ xyz: consuming StructContainDeinitStruct) {
+    // expected-error @+1 {{cannot partially consume 'xyz.first' since it has a user defined deinit}}
+    consume(xyz.first.third.rhs)
 }
 
 func testStructContainStructContainDeinitStructConsumeNonCopyable1a(_ x: consuming StructContainDeinitStruct) {
-    // expected-error @-1 {{Cannot partially consume 'x' since it contains field 'x.second.0' whose type 'DeinitStruct' has a user defined deinit}}
-    consume(x.second.0.third.rhs) // expected-note {{consuming use here}}
+    // expected-error @+1 {{cannot partially consume 'x.second.0' since it has a user defined deinit}}
+    consume(x.second.0.third.rhs)
 }
 
 func testStructContainStructContainDeinitStructConsumeNonCopyable2(_ x: consuming StructContainDeinitStruct) {
-    // expected-error @-1 {{Cannot partially consume 'x' since it contains field 'x.first' whose type 'DeinitStruct' has a user defined deinit}}
-    consume(x.first.fourth.0) // expected-note {{consuming use here}}
+    // expected-error @+1 {{cannot partially consume 'x.first' since it has a user defined deinit}}
+    consume(x.first.fourth.0)
 }
 
 func testStructContainStructContainDeinitStructConsumeNonCopyable2a(_ x: consuming StructContainDeinitStruct) {
-    // expected-error @-1 {{Cannot partially consume 'x' since it contains field 'x.second.1' whose type 'DeinitStruct' has a user defined deinit}}
-    consume(x.second.1.fourth.0) // expected-note {{consuming use here}}
+    // expected-error @+1 {{cannot partially consume 'x.second.1' since it has a user defined deinit}}
+    consume(x.second.1.fourth.0)
 }
 
 func testStructContainStructContainDeinitStructConsumeNonCopyable3(_ x: consuming StructContainDeinitStruct) {
-    // expected-error @-1 {{Cannot partially consume 'x' since it contains field 'x.first' whose type 'DeinitStruct' has a user defined deinit}}
-    consume(x.first.fourth.1) // expected-note {{consuming use here}}
+    // expected-error @+1 {{cannot partially consume 'x.first' since it has a user defined deinit}}
+    consume(x.first.fourth.1)
 }
 
 
 func testStructContainStructContainDeinitStructConsumeNonCopyable4(_ x: consuming StructContainDeinitStruct) {
-    // expected-error @-1 {{Cannot partially consume 'x' since it contains field 'x.first' whose type 'DeinitStruct' has a user defined deinit}}
-    consume(x.first.fifth) // expected-note {{consuming use here}}
+    // expected-error @+1 {{cannot partially consume 'x.first' since it has a user defined deinit}}
+    consume(x.first.fifth)
 }
 
 ////////////////////////
@@ -169,12 +159,7 @@ struct AddressOnlyDeinitStruct<T : P> : ~Copyable {
   var moveOnly = SingleIntContainingStruct()
   var moveOnlyPair = MoveOnlyPair()
 
-  deinit {}
-  // expected-note @-1 {{deinit declared here}}
-  // expected-note @-2 {{deinit declared here}}
-  // expected-note @-3 {{deinit declared here}}
-  // expected-note @-4 {{deinit declared here}}
-  // expected-note @-5 {{deinit declared here}}
+  deinit {} // expected-note 5{{deinitializer declared here}}
 }
 
 func consume<T : P>(_ x: consuming AddressOnlyDeinitStruct<T>) {}
@@ -187,10 +172,8 @@ func testAddressOnlyCanConsumeEntireType<T : P>(_ x: consuming AddressOnlyDeinit
 }
 
 func testAddressOnlyCannotPartialConsume<T : P>(_ x: consuming AddressOnlyDeinitStruct<T>) {
-  // expected-error @-1 {{Cannot partially consume 'x' since it has a user defined deinit}}
-  // expected-error @-2 {{Cannot partially consume 'x' since it has a user defined deinit}}
-  consume(x.moveOnly) // expected-note {{consuming use here}}
-  consume(x.moveOnlyPair.first) // expected-note {{consuming use here}}
+  consume(x.moveOnly) // expected-error {{cannot partially consume 'x' when it has a deinitializer}}
+  consume(x.moveOnlyPair.first) // expected-error {{cannot partially consume 'x' when it has a deinitializer}}
   consume(x.copyable)
 }
 
@@ -199,17 +182,14 @@ struct AddressOnlyContainingDeinitStruct<T : P> : ~Copyable {
 }
 
 func testAddressOnlyCannotPartialConsumeEvenIfSingleElt<T : P>(_ x: consuming AddressOnlyContainingDeinitStruct<T>) {
-  // expected-error @-1 {{Cannot partially consume 'x' since it contains field 'x.a' whose type 'AddressOnlyDeinitStruct' has a user defined deinit}}
-
   // We do not error here since we can partially consume x, but not x.a
   consume(x.a)
-  consume(x.a.moveOnlyPair) // expected-note {{consuming use here}}
+  consume(x.a.moveOnlyPair) // expected-error {{cannot partially consume 'x.a' when it has a deinitializer}}
 }
 
 struct AddressOnlyContainingDeinitSingleField<T : P> : ~Copyable {
   var moveOnly = SingleIntContainingStruct()
-  deinit {}
-  // expected-note @-1 {{deinit declared here}}
+  deinit {} // expected-note {{deinitializer declared here}}
 }
 
 struct AddressOnlyContainingDeinitStruct3<T : P> : ~Copyable {
@@ -219,11 +199,9 @@ struct AddressOnlyContainingDeinitStruct3<T : P> : ~Copyable {
 func consume<T : P>(_ x: consuming AddressOnlyContainingDeinitSingleField<T>) {}
 
 func testAddressOnlyCannotPartialConsumeEvenIfSingleElt<T : P>(_ x: consuming AddressOnlyContainingDeinitStruct3<T>) {
-  // expected-error @-1 {{Cannot partially consume 'x' since it contains field 'x.a' whose type 'AddressOnlyContainingDeinitSingleField' has a user defined deinit}}
-
   // We do not error here since we can partially consume x, but not x.a
   consume(x.a)
-  consume(x.a.moveOnly) // expected-note {{consuming use here}}
+  consume(x.a.moveOnly) // expected-error {{cannot partially consume 'x.a' when it has a deinitializer}}
 }
 
 
@@ -235,9 +213,7 @@ struct AddressOnlyContainingDeinitStructPair<T : P> : ~Copyable {
 // Make sure that if the deinit is in an intermediate element of the path that
 // we still handle it appropriately.
 func testAddressOnlyDeinitInMiddlePath<T : P>(_ x: consuming AddressOnlyContainingDeinitStructPair<T>) {
-  // expected-error @-1 {{Cannot partially consume 'x' since it contains field 'x.first' whose type 'AddressOnlyDeinitStruct' has a user defined deinit}}
-  // expected-error @-2 {{Cannot partially consume 'x' since it contains field 'x.first' whose type 'AddressOnlyDeinitStruct' has a user defined deinit}}
-  consume(x.first.moveOnly) // expected-note {{consuming use here}}
-  consume(x.first.moveOnlyPair.first) // expected-note {{consuming use here}}
+  consume(x.first.moveOnly) // expected-error {{cannot partially consume 'x.first' when it has a deinitializer}}
+  consume(x.first.moveOnlyPair.first) // expected-error {{cannot partially consume 'x.first' when it has a deinitializer}}
   consume(x.first.copyable)
 }