[Sema] emit conditional Copyable conformance note

For containment issues, where an unconditionally or conditionally
Copyable type contains a fixed noncopyable element, remind users about
the conditional conformance in addition to the fix-it to add ~Copyable

Author: kavon

lib/Sema/TypeCheckInvertible.cpp

@@ -58,13 +58,29 @@ static void tryEmitContainmentFixits(NominalTypeDecl *enclosingNom,
   auto *module = enclosingNom->getParentModule();
   auto &ctx = enclosingNom->getASTContext();
 
-  // First and most universal suggestion, add the inverse to the enclosing type.
-  {
+  // Check the enclosing type's markings to see what to suggest.
+  assert(kp == KnownProtocolKind::Copyable);
+  auto enclosingMarking = enclosingNom->getNoncopyableMarking();
+
+  switch (enclosingMarking.getInverse().getKind()) {
+  case InverseMarking::Kind::Inferred:
+    // Note that the enclosing type is conditionally conforming to KP first.
+    ctx.Diags.diagnose(enclosingMarking.getInverse().getLoc(),
+                       diag::note_inverse_preventing_conformance_implicit,
+                       enclosingNom, getProtocolName(kp));
+    LLVM_FALLTHROUGH;
+  case InverseMarking::Kind::None: {
+    // Suggest adding ~KP to make it non-KP.
     auto diag = enclosingNom->diagnose(diag::add_inverse,
                                        enclosingNom,
                                        getProtocolName(kp));
     addConformanceFixIt(enclosingNom, diag, kp, /*inverse=*/true);
   }
+    break;
+  case InverseMarking::Kind::Explicit:
+    assert(false && "how did it become Copyable?");
+    break;
+  };
 
   // If it's a generic parameter defined in the same module, point to the
   // parameter that must have had the inverse applied to it somewhere.
@@ -83,31 +99,29 @@ static void tryEmitContainmentFixits(NominalTypeDecl *enclosingNom,
     return;
   }
 
-  if (kp == KnownProtocolKind::Copyable) {
-    // If the offending type is a nominal with a SourceLoc, explain why it's
-    // not Copyable.
-    if (auto nominal = nonConformingTy->getAnyNominal()) {
-      if (nominal->getLoc(/*SerializedOK=*/false)) {
-        auto inverse = nominal->getNoncopyableMarking().getInverse();
-        auto loc = inverse.getLoc();
-
-        switch (inverse.getKind()) {
-        case InverseMarking::Kind::None:
-          assert(false && "how did it become noncopyable then?");
-          break;
-        case InverseMarking::Kind::Inferred:
-          assert(loc);
-          ctx.Diags.diagnose(loc,
-                             diag::note_inverse_preventing_conformance_implicit,
-                             nominal, getProtocolName(kp));
-          break;
-        case InverseMarking::Kind::Explicit:
-          assert(loc);
-          ctx.Diags.diagnose(loc,
-                             diag::note_inverse_preventing_conformance_explicit,
-                             nominal, getProtocolName(kp));
-          break;
-        }
+  // If the offending type is a nominal with a SourceLoc, explain why it's
+  // not Copyable.
+  if (auto nominal = nonConformingTy->getAnyNominal()) {
+    if (nominal->getLoc(/*SerializedOK=*/false)) {
+      auto inverse = nominal->getNoncopyableMarking().getInverse();
+      auto loc = inverse.getLoc();
+
+      switch (inverse.getKind()) {
+      case InverseMarking::Kind::None:
+        assert(false && "how did it become noncopyable then?");
+        break;
+      case InverseMarking::Kind::Inferred:
+        assert(loc);
+        ctx.Diags.diagnose(loc,
+                           diag::note_inverse_preventing_conformance_implicit,
+                           nominal, getProtocolName(kp));
+        break;
+      case InverseMarking::Kind::Explicit:
+        assert(loc);
+        ctx.Diags.diagnose(loc,
+                           diag::note_inverse_preventing_conformance_explicit,
+                           nominal, getProtocolName(kp));
+        break;
       }
     }
   }
@@ -322,8 +336,6 @@ ProtocolConformance *deriveConformanceForInvertible(Evaluator &evaluator,
     return generateConformance(ext);
   };
 
-  DeclContext *conformanceDC = nominal;
-
   switch (*ip) {
   case InvertibleProtocolKind::Copyable: {
     auto marking = nominal->getNoncopyableMarking();

test/Generics/inverse_copyable_generics.swift

@@ -47,6 +47,7 @@ protocol RemovedAgain where Self: ~Copyable {
 
 struct StructContainment<T: ~Copyable> : Copyable {
     // expected-note@-1 {{consider adding '~Copyable' to generic struct 'StructContainment'}}{{50-50=, ~Copyable}}
+    // expected-note@-2 {{generic struct 'StructContainment' has '~Copyable' constraint on a generic parameter, making its 'Copyable' conformance conditional}}
 
     var storage: Maybe<T>
     // expected-error@-1 {{stored property 'storage' of 'Copyable'-conforming generic struct 'StructContainment' has noncopyable type 'Maybe<T>'}}
@@ -55,6 +56,7 @@ struct StructContainment<T: ~Copyable> : Copyable {
 enum EnumContainment<T: ~Copyable> : Copyable {
     // expected-note@-1 {{'T' has '~Copyable' constraint preventing implicit 'Copyable' conformance}}
     // expected-note@-2{{consider adding '~Copyable' to generic enum 'EnumContainment'}}{{46-46=, ~Copyable}}
+    // expected-note@-3{{generic enum 'EnumContainment' has '~Copyable' constraint on a generic parameter, making its 'Copyable' conformance conditional}}
 
     case some(T) // expected-error {{associated value 'some' of 'Copyable'-conforming generic enum 'EnumContainment' has noncopyable type 'T'}}
     case other(Int)
@@ -69,6 +71,7 @@ class ClassContainment<T: ~Copyable> {
     }
 }
 
+// expected-note@+2 {{generic struct 'ConditionalContainment' has '~Copyable' constraint on a generic parameter, making its 'Copyable' conformance conditional}}
 // expected-note@+1 {{consider adding '~Copyable' to generic struct 'ConditionalContainment'}}{{45-45=: ~Copyable}}
 struct ConditionalContainment<T: ~Copyable> {
   var x: T
@@ -116,6 +119,7 @@ extension Maybe where Self: Copyable {
   func check2(_ t: RequireCopyable<Self>) {}
 }
 
+// expected-note@+2 {{generic struct 'CornerCase' has '~Copyable' constraint on a generic parameter, making its 'Copyable' conformance conditional}}
 // expected-note@+1 {{consider adding '~Copyable' to generic struct 'CornerCase'}}{{33-33=: ~Copyable}}
 struct CornerCase<T: ~Copyable> {
   let t: T