describe more cases of noncopyable in a tuple; also improve existing message a bit.

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -5514,7 +5514,9 @@ ERROR(tuple_pack_element_label,none,
       "cannot use label with pack expansion tuple element",
       ())
 ERROR(tuple_move_only_not_supported,none,
-      "tuples with noncopyable elements are not supported", ())
+      "tuple with noncopyable element type %0 is not supported", (Type))
+ERROR(tuple_containing_move_only_not_supported,none,
+      "type %0 containing noncopyable element is not supported", (Type))
 ERROR(vararg_not_allowed,none,
       "variadic parameter cannot appear outside of a function parameter list",
       ())

lib/Sema/CSDiagnostics.cpp

@@ -6156,6 +6156,13 @@ bool NotCopyableFailure::diagnoseAsError() {
 
   case NoncopyableMatchFailure::CopyableConstraint: {
     auto *loc = getLocator();
+
+    if (loc->isLastElement<LocatorPathElt::AnyTupleElement>()) {
+      assert(!noncopyableTy->is<TupleType>() && "will use poor wording");
+      emitDiagnostic(diag::tuple_move_only_not_supported, noncopyableTy);
+      return true;
+    }
+
     // a bit paranoid of nulls and such...
     if (auto *genericParam = loc->getGenericParameter()) {
       if (auto *paramDecl = genericParam->getDecl()) {

lib/Sema/MiscDiagnostics.cpp

@@ -329,7 +329,11 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
         // Diagnose attempts to form a tuple with any noncopyable elements.
         if (E->getType()->isPureMoveOnly()
             && !Ctx.LangOpts.hasFeature(Feature::MoveOnlyTuples)) {
-          Ctx.Diags.diagnose(E->getLoc(), diag::tuple_move_only_not_supported);
+          auto noncopyableTy = E->getType();
+          assert(noncopyableTy->is<TupleType>() && "will use poor wording");
+          Ctx.Diags.diagnose(E->getLoc(),
+                             diag::tuple_containing_move_only_not_supported,
+                             noncopyableTy);
         }
       }
 

lib/Sema/TypeCheckType.cpp

@@ -4794,8 +4794,10 @@ NeverNullType TypeResolver::resolveTupleType(TupleTypeRepr *repr,
   if (moveOnlyElementIndex.has_value()
       && !options.contains(TypeResolutionFlags::SILType)
       && !ctx.LangOpts.hasFeature(Feature::MoveOnlyTuples)) {
-    diagnose(repr->getElementType(*moveOnlyElementIndex)->getLoc(),
-             diag::tuple_move_only_not_supported);
+    auto noncopyableTy = elements[*moveOnlyElementIndex].getType();
+    auto loc = repr->getElementType(*moveOnlyElementIndex)->getLoc();
+    assert(!noncopyableTy->is<TupleType>() && "will use poor wording");
+    diagnose(loc, diag::tuple_move_only_not_supported, noncopyableTy);
   }
 
   return TupleType::get(elements, ctx);

test/Constraints/moveonly_constraints.swift

@@ -88,8 +88,9 @@ func testBasic(_ mo: borrowing MO) {
   genericVarArg(5)
   genericVarArg(mo) // expected-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'genericVarArg'}}
 
-  takeGeneric( (mo, 5) ) // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
-  takeGenericSendable((mo, mo)) // expected-error 2{{noncopyable type 'MO' cannot be used with generics yet}}
+  takeGeneric( (mo, 5) ) // expected-error {{tuple with noncopyable element type 'MO' is not supported}}
+  takeGeneric( ((mo, 5), 19) ) // expected-error {{tuple with noncopyable element type 'MO' is not supported}}
+  takeGenericSendable((mo, mo)) // expected-error 2{{tuple with noncopyable element type 'MO' is not supported}}
 
   let singleton : (MO) = (mo)
   takeGeneric(singleton) // expected-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'takeGeneric'}}
@@ -235,7 +236,7 @@ func checkStdlibTypes(_ mo: borrowing MO) {
   let _: [MO] = // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Array<Element>' yet}}
       []
   let _: [String: MO] = // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Dictionary<Key, Value>' yet}}
-      ["hello" : MO()]  // expected-error{{tuples with noncopyable elements are not supported}}
+      ["hello" : MO()]  // expected-error{{type '(String, MO)' containing noncopyable element is not supported}}
 
   _ = [MO()] // expected-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'Element' in 'Array'}}
 

test/Constraints/moveonly_tuples.swift

@@ -9,18 +9,18 @@
 
 @_moveOnly
 struct Foo {
-    var t: (Int, Butt) // expected-error{{tuples with noncopyable elements are not supported}}
+    var t: (Int, Butt) // expected-error{{tuple with noncopyable element type 'Butt' is not supported}}
 }
 @_moveOnly
 struct Bar<T> {
-    var t: (T, Butt) // expected-error{{tuples with noncopyable elements are not supported}}
-    var u: (Int, (T, Butt)) // expected-error{{tuples with noncopyable elements are not supported}}
+    var t: (T, Butt) // expected-error{{tuple with noncopyable element type 'Butt' is not supported}}
+    var u: (Int, (T, Butt)) // expected-error{{tuple with noncopyable element type 'Butt' is not supported}}
 }
 
 func inferredTuples<T>(x: Int, y: borrowing Butt, z: T) {
-    let a = (x, y) // expected-error{{tuples with noncopyable elements are not supported}}
-    let b = (y, z) // expected-error{{tuples with noncopyable elements are not supported}}
-    let c = (x, y, z) // expected-error{{tuples with noncopyable elements are not supported}}
+    let a = (x, y) // expected-error{{type '(Int, Butt)' containing noncopyable element is not supported}}
+    let b = (y, z) // expected-error{{type '(Butt, T)' containing noncopyable element is not supported}}
+    let c = (x, y, z) // expected-error{{type '(Int, Butt, T)' containing noncopyable element is not supported}}
     _ = a
     _ = b
     _ = c