describe how generic parameters implicitly require Copyable

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -7276,6 +7276,15 @@ ERROR(noncopyable_generics_erasure, none,
 ERROR(noncopyable_generics_metatype_cast, none,
       "metatype %0 cannot be cast to %1 because %2 is noncopyable",
       (Type, Type, Type))
+ERROR(noncopyable_generics_generic_param, none,
+      "noncopyable type %0 cannot be substituted for copyable %1 %2 in %3",
+      (Type, DescriptiveDeclKind, Type, DeclName))
+ERROR(noncopyable_generics_generic_param_metatype, none,
+      "metatype %4 of noncopyable type %0 cannot be substituted for copyable %1 %2 in %3",
+      (Type, DescriptiveDeclKind, Type, DeclName, Type))
+NOTE(noncopyable_generics_implicit_copyable, none,
+      "%0 %1 has an implicit Copyable requirement",
+      (DescriptiveDeclKind, Type))
 ERROR(noncopyable_effectful_getter,none,
       "%0 of noncopyable type cannot be 'async' or 'throws'", (DescriptiveDeclKind))
 ERROR(noncopyable_enums_do_not_support_indirect,none,

include/swift/Sema/CSFix.h

@@ -2084,17 +2084,41 @@ class NotCompileTimeConst final : public ContextualMismatch {
 
 /// Describes the reason why the type must be copyable
 struct NoncopyableMatchFailure {
-  enum Reason {
-    Unknown,
-    CastToExistential,
+  enum Kind {
+    CopyableConstraint,
+    ExistentialCast,
   };
 
-  Type type;
-  Reason reason;
+private:
+  Kind reason;
+  union {
+    Type type;
+  };
+
+  NoncopyableMatchFailure(Kind reason, Type type)
+      : reason(reason), type(type) {}
+
+public:
+  Kind getKind() const { return reason; }
+
+  Type getType() const {
+    switch (reason) {
+    case ExistentialCast:
+      return type;
 
-  NoncopyableMatchFailure() : type(Type()), reason(Unknown) {}
-  NoncopyableMatchFailure(Type type, Reason reason)
-      : type(type), reason(reason) {}
+    case CopyableConstraint:
+      llvm_unreachable("no type payload");
+    };
+  }
+
+  static NoncopyableMatchFailure forCopyableConstraint() {
+    return NoncopyableMatchFailure(CopyableConstraint, Type());
+  }
+
+  static NoncopyableMatchFailure forExistentialCast(Type existential) {
+    assert(existential->isAnyExistentialType());
+    return NoncopyableMatchFailure(ExistentialCast, existential);
+  }
 };
 
 class MustBeCopyable final : public ConstraintFix {

lib/Sema/CSDiagnostics.cpp

@@ -6140,27 +6140,60 @@ bool NotCompileTimeConstFailure::diagnoseAsError() {
 }
 
 bool NotCopyableFailure::diagnoseAsError() {
-  switch (failure.reason) {
-  case NoncopyableMatchFailure::CastToExistential: {
-    assert(failure.type->is<ExistentialType>());
-
+  switch (failure.getKind()) {
+  case NoncopyableMatchFailure::ExistentialCast: {
     if (noncopyableTy->is<AnyMetatypeType>())
       emitDiagnostic(diag::noncopyable_generics_metatype_cast,
                      noncopyableTy,
-                     failure.type,
+                     failure.getType(),
                      noncopyableTy->getMetatypeInstanceType());
     else
       emitDiagnostic(diag::noncopyable_generics_erasure,
                      noncopyableTy,
-                     failure.type);
-    break;
+                     failure.getType());
+    return true;
   }
-  case NoncopyableMatchFailure::Unknown:
-    emitDiagnostic(diag::noncopyable_generics,
-                   noncopyableTy);
+
+  case NoncopyableMatchFailure::CopyableConstraint: {
+    auto *loc = getLocator();
+    // a bit paranoid of nulls and such...
+    if (auto *genericParam = loc->getGenericParameter()) {
+      if (auto *paramDecl = genericParam->getDecl()) {
+        if (auto *owningDecl =
+            dyn_cast_or_null<ValueDecl>(paramDecl->getDeclContext()->getAsDecl())) {
+
+          // FIXME: these owningDecl names are kinda bad. like just `init(describing:)`
+          if (noncopyableTy->is<AnyMetatypeType>())
+            emitDiagnostic(diag::noncopyable_generics_generic_param_metatype,
+                           noncopyableTy->getMetatypeInstanceType(),
+                           paramDecl->getDescriptiveKind(),
+                           genericParam,
+                           owningDecl->getName(),
+                           noncopyableTy);
+          else
+            emitDiagnostic(diag::noncopyable_generics_generic_param,
+                           noncopyableTy,
+                           paramDecl->getDescriptiveKind(),
+                           genericParam,
+                           owningDecl->getName());
+
+          // If we have a location for the parameter, point it out in a note.
+          if (auto loc = paramDecl->getNameLoc()) {
+            emitDiagnosticAt(loc,
+                             diag::noncopyable_generics_implicit_copyable,
+                             paramDecl->getDescriptiveKind(),
+                             genericParam);
+          }
+
+          return true;
+        }
+      }
+    }
     break;
   }
+  }
 
+  emitDiagnostic(diag::noncopyable_generics, noncopyableTy);
   return true;
 }
 

lib/Sema/CSSimplify.cpp

@@ -3832,11 +3832,11 @@ ConstraintSystem::matchExistentialTypes(Type type1, Type type2,
   if (type1->getMetatypeInstanceType()->isPureMoveOnly()) {
     // tailor error message
     if (shouldAttemptFixes()) {
-      auto *fix =
-          MustBeCopyable::create(*this, type1,
-                                 {type2,
-                                  NoncopyableMatchFailure::CastToExistential},
-                                 getConstraintLocator(locator));
+      auto *fix = MustBeCopyable::create(*this,
+                                         type1,
+                                         NoncopyableMatchFailure::forExistentialCast(
+                                             type2),
+                                         getConstraintLocator(locator));
       if (!recordFix(fix))
         return getTypeMatchSuccess();
     }
@@ -8495,7 +8495,10 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
     // If this is a failure to conform to Copyable, tailor the error message.
     if (protocol->isSpecificProtocol(KnownProtocolKind::Copyable)) {
       auto *fix =
-          MustBeCopyable::create(*this, type, {}, getConstraintLocator(locator));
+          MustBeCopyable::create(*this,
+                                 type,
+                                 NoncopyableMatchFailure::forCopyableConstraint(),
+                                 getConstraintLocator(locator));
       if (!recordFix(fix))
         return SolutionKind::Solved;
     }

test/Constraints/moveonly_constraints.swift

@@ -20,13 +20,13 @@ protocol Box<T> {
   func get() -> T
 }
 
-class RefBox<T>: Box {
+class RefBox<T>: Box { // expected-note@:14 6{{generic parameter 'T' has an implicit Copyable requirement}}
   var val: T
   init(_ t: T) { val = t }
   func get() -> T { return val }
 }
 
-struct ValBox<T>: Box {
+struct ValBox<T>: Box { // expected-note@:15 6{{generic parameter 'T' has an implicit Copyable requirement}}
   var val: T
   init(_ t: T) { val = t }
   func get() -> T { return val }
@@ -37,20 +37,20 @@ class NotStoredGenerically<T> {
   func give() -> T { fatalError("todo") }
 }
 
-enum Maybe<T> {
+enum Maybe<T> { // expected-note@:12 3{{generic parameter 'T' has an implicit Copyable requirement}}
   case none
   case just(T)
 }
 
 func takeConcrete(_ m: borrowing MO) {}
-func takeGeneric<T>(_ t: T) {}
+func takeGeneric<T>(_ t: T) {} // expected-note@:18 5{{generic parameter 'T' has an implicit Copyable requirement}}
 func takeGenericSendable<T>(_ t: T) where T: Sendable {}
-func takeMaybe<T>(_ m: Maybe<T>) {}
+func takeMaybe<T>(_ m: Maybe<T>) {} // expected-note@:16 2{{generic parameter 'T' has an implicit Copyable requirement}}
 func takeAnyBoxErased(_ b: any Box) {}
-func takeAnyBox<T>(_ b: any Box<T>) {}
+func takeAnyBox<T>(_ b: any Box<T>) {} // expected-note@:17 2{{generic parameter 'T' has an implicit Copyable requirement}}
 func takeAny(_ a: Any) {}
 func takeAnyObject(_ a: AnyObject) {}
-func genericVarArg<T>(_ t: T...) {}
+func genericVarArg<T>(_ t: T...) {} // expected-note@:20 {{generic parameter 'T' has an implicit Copyable requirement}}
 
 var globalMO: MO = MO()
 
@@ -61,7 +61,7 @@ var globalMO: MO = MO()
 
 // some top-level tests
 let _: MO = globalMO
-takeGeneric(globalMO) // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
+takeGeneric(globalMO) // expected-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'takeGeneric'}}
 
 
 
@@ -75,24 +75,24 @@ func testBasic(_ mo: borrowing MO) {
   takeConcrete(globalMO)
   takeConcrete(MO())
 
-  takeGeneric(globalMO) // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
-  takeGeneric(MO()) // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
-  takeGeneric(mo) // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
+  takeGeneric(globalMO) // expected-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'takeGeneric'}}
+  takeGeneric(MO()) // expected-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'takeGeneric'}}
+  takeGeneric(mo) // expected-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'takeGeneric'}}
 
   takeAny(mo) // expected-error {{noncopyable type 'MO' cannot be erased to copyable existential type 'Any'}}
   print(mo) // expected-error {{noncopyable type 'MO' cannot be erased to copyable existential type 'Any'}}
-  _ = "\(mo)" // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
-  let _: String = String(describing: mo) // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
+  _ = "\(mo)" // expected-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'appendInterpolation'}}
+  let _: String = String(describing: mo) // expected-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'Subject' in 'init(describing:)'}}
 
   takeGeneric { () -> Int? in mo.x }
   genericVarArg(5)
-  genericVarArg(mo) // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
+  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}}
 
   let singleton : (MO) = (mo)
-  takeGeneric(singleton) // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
+  takeGeneric(singleton) // expected-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'takeGeneric'}}
 
   takeAny((mo)) // expected-error {{noncopyable type 'MO' cannot be erased to copyable existential type 'Any'}}
   takeAny((mo, mo)) // expected-error {{noncopyable type '(MO, MO)' cannot be erased to copyable existential type 'Any'}}
@@ -101,29 +101,29 @@ func testBasic(_ mo: borrowing MO) {
 func checkBasicBoxes() {
   let mo = MO()
 
-  let vb = ValBox(consume mo) // expected-error 2{{noncopyable type 'MO' cannot be used with generics yet}}
+  let vb = ValBox(consume mo) // expected-error 2{{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'ValBox'}}
   _ = vb.get()
   _ = vb.val
 
-  let rb = RefBox(MO())  // expected-error 2{{noncopyable type 'MO' cannot be used with generics yet}}
+  let rb = RefBox(MO())  // expected-error 2{{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'RefBox'}}
   _ = rb.get()
   _ = rb.val
 
   let vb2: ValBox<MO> = .init(MO())  // expected-error {{noncopyable type 'MO' cannot be used with generic type 'ValBox<T>' yet}}
 }
 
 func checkExistential() {
-  takeAnyBox( // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
-      RefBox(MO())) // expected-error 2{{noncopyable type 'MO' cannot be used with generics yet}}
+  takeAnyBox( // expected-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'takeAnyBox'}}
+      RefBox(MO())) // expected-error 2{{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'RefBox'}}
 
-  takeAnyBox( // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
-      ValBox(globalMO)) // expected-error 2{{noncopyable type 'MO' cannot be used with generics yet}}
+  takeAnyBox( // expected-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'takeAnyBox'}}
+      ValBox(globalMO)) // expected-error 2{{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'ValBox'}}
 
   takeAnyBoxErased(
-      RefBox(MO())) // expected-error 2{{noncopyable type 'MO' cannot be used with generics yet}}
+      RefBox(MO())) // expected-error 2{{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'RefBox'}}
 
   takeAnyBoxErased(
-      ValBox(globalMO)) // expected-error 2{{noncopyable type 'MO' cannot be used with generics yet}}
+      ValBox(globalMO)) // expected-error 2{{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'ValBox'}}
 }
 
 func checkMethodCalls() {
@@ -134,9 +134,13 @@ func checkMethodCalls() {
   let _: Maybe<MO> = .none // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Maybe<T>' yet}}
   let _ = Maybe<MO>.just(MO()) // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Maybe<T>' yet}}
   let _: Maybe<MO> = .just(MO()) // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Maybe<T>' yet}}
-  takeMaybe(.just(MO())) // expected-error 2{{noncopyable type 'MO' cannot be used with generics yet}}
 
-  takeMaybe(true ? .none : .just(MO())) // expected-error 3{{noncopyable type 'MO' cannot be used with generics yet}}
+  // FIXME: MO isn't logically being substituted into takeMaybe. seems like nonsense duplication?
+  takeMaybe(.just(MO())) // expected-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'Maybe'}}
+                         // expected-error@-1 {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'takeMaybe'}}
+  takeMaybe(true ? .none : .just(MO()))
+  // expected-error@-1 {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'takeMaybe'}}
+  // expected-error@-2 2{{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'Maybe'}}
 }
 
 func checkCasting(_ b: any Box, _ mo: borrowing MO, _ a: Any) {
@@ -233,13 +237,12 @@ func checkStdlibTypes(_ mo: borrowing MO) {
   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}}
 
-  // i think this one's only caught b/c of the 'Any' change
-  _ = [MO()] // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
+  _ = [MO()] // expected-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'Element' in 'Array'}}
 
   let _: Array<MO> = .init() // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Array<Element>' yet}}
   _ = [MO]() // expected-error {{noncopyable type 'MO' cannot be used with generic type 'Array<Element>' yet}}
 
-  let s: String = "hello \(mo)" // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
+  let s: String = "hello \(mo)" // expected-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'appendInterpolation'}}
 }
 
 func copyableExistentials(_ a: Any, _ e1: Error, _ e2: any Error, _ ah: AnyHashable) {
@@ -272,13 +275,18 @@ struct GenerousGuy: Gives { // expected-error {{type 'GenerousGuy' does not conf
   func give() -> Ty {}
 }
 
-func doBadMetatypeStuff<T>(_ t: T) {
+func doBadMetatypeStuff<T>(_ t: T) { // expected-note@:25 {{generic parameter 'T' has an implicit Copyable requirement}}
   let y = t as! Any.Type
   if let MO_MetaType = y as? MO.Type { // expected-warning {{cast from 'any Any.Type' to unrelated type 'MO.Type' always fails}}
     let x = MO_MetaType.init()
     let _ = x
   }
 }
 func tryToDoBadMetatypeStuff() {
-  doBadMetatypeStuff(MO.self) // expected-error {{noncopyable type 'MO.Type' cannot be used with generics yet}}
+  doBadMetatypeStuff(MO.self) // expected-error {{metatype 'MO.Type' of noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'doBadMetatypeStuff'}}
+}
+
+func packingHeat<each T>(_ t: repeat each T) {}
+func packIt() {
+  packingHeat(MO())  // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
 }

test/Sema/copyable_constraint.swift

@@ -7,8 +7,8 @@
 
 @_marker public protocol _Copyable {}
 
-func nextTime<T>(_ t: T) {}
+func nextTime<T>(_ t: T) {} // expected-note {{generic parameter 'T' has an implicit Copyable requirement}}
 
 @_moveOnly struct MO {}
 
-nextTime(MO()) // expected-error {{noncopyable type 'MO' cannot be used with generics yet}}
+nextTime(MO()) // expected-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'nextTime'}}

test/Sema/moveonly_sendable.swift

@@ -91,7 +91,7 @@ enum Wrong_NoncopyableOption<T> : Sendable { // expected-note {{consider making
 }
 
 func takeAnySendable(_ s: any Sendable) {}
-func takeSomeSendable(_ s: some Sendable) {}
+func takeSomeSendable(_ s: some Sendable) {} // expected-note {{generic parameter 'some Sendable' has an implicit Copyable requirement}}
 
 // expected-error@+1 {{noncopyable type 'FileDescriptor' cannot be erased to copyable existential type 'any Sendable'}}
 func mkSendable() -> Sendable { return FileDescriptor(id: 0) }
@@ -101,7 +101,7 @@ func tryToCastIt(_ fd: borrowing FileDescriptor) {
   let _: Sendable = fd // expected-error {{noncopyable type 'FileDescriptor' cannot be erased to copyable existential type 'any Sendable'}}
 
   takeAnySendable(fd) // expected-error {{noncopyable type 'FileDescriptor' cannot be erased to copyable existential type 'any Sendable'}}
-  takeSomeSendable(fd) // expected-error {{noncopyable type 'FileDescriptor' cannot be used with generics yet}}
+  takeSomeSendable(fd) // expected-error {{noncopyable type 'FileDescriptor' cannot be substituted for copyable generic parameter 'some Sendable' in 'takeSomeSendable'}}
 
   let _ = fd as Sendable // expected-error {{noncopyable type 'FileDescriptor' cannot be erased to copyable existential type 'any Sendable'}}
 
@@ -159,7 +159,8 @@ extension Sendable {
 }
 
 func tryToDupe(_ fd: borrowing FileDescriptor) {
-  fd.doIllegalThings() // expected-error {{noncopyable type 'FileDescriptor' cannot be used with generics yet}}
+  // FIXME: this should describe 'Self' as 'any Sendable' or something.
+  fd.doIllegalThings() // expected-error {{noncopyable type 'FileDescriptor' cannot be substituted for copyable generic parameter 'Self' in 'Sendable'}}
 }
 
 @_moveOnly