NCGenerics: restrict conditional Copyable reqs

It doesn't really make sense for a conditional conformance requirement
for `Copyable` to depend on any other requirement other than other
`Copyable` conformance requirements.

resolves rdar://124967739

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -7644,6 +7644,9 @@ ERROR(inverse_extension, none,
 ERROR(copyable_illegal_deinit, none,
       "deinitializer cannot be declared in %kind0 that conforms to 'Copyable'",
       (const ValueDecl *))
+ERROR(inverse_cannot_be_conditional_on_requirement, none,
+      "conditional conformance to suppressible %kind0 cannot depend on '%1%select{:|:| ==|:}2 %3'",
+      (const ProtocolDecl *, StringRef, unsigned, StringRef))
 ERROR(inverse_type_member_in_conforming_type,none,
       "%select{stored property %2|associated value %2}1 of "
       "'%4'-conforming %kind3 has non-%4 type %0",

lib/Sema/TypeCheckInvertible.cpp

@@ -140,10 +140,45 @@ static void checkInvertibleConformanceCommon(DeclContext *dc,
   if (conformance.isConcrete()) {
     auto concrete = conformance.getConcrete();
     if (auto *normalConf = dyn_cast<NormalProtocolConformance>(concrete)) {
-      hasUnconditionalConformance =
-          normalConf->getConditionalRequirements().empty();
       conformanceLoc = normalConf->getLoc();
       assert(conformanceLoc);
+
+      auto condReqs = normalConf->getConditionalRequirements();
+      hasUnconditionalConformance = condReqs.empty();
+      auto *thisProto = normalConf->getProtocol();
+
+      // Ensure that conditional conformance to an invertible protocol IP only
+      // depends conformance requirements involving IP.
+      //
+      // In theory, it could depend on any invertible protocol, but it may be
+      // confusing if we permitted that and this simplifies the model a bit.
+      for (auto req : condReqs) {
+        std::optional<StringRef> illegalSecondTypeStr;
+
+        // If we are diagnosing, fill-in the second-type string of this req.
+        switch (req.getKind()) {
+        case RequirementKind::Layout:
+          illegalSecondTypeStr = req.getLayoutConstraint().getString();
+          break;
+        case RequirementKind::Conformance:
+          if (req.getProtocolDecl() == thisProto)
+            break; // permitted, don't fill-in.
+        LLVM_FALLTHROUGH;
+        case RequirementKind::Superclass:
+        case RequirementKind::SameType:
+        case RequirementKind::SameShape:
+          illegalSecondTypeStr = req.getSecondType().getString();
+          break;
+        }
+
+        if (illegalSecondTypeStr)
+          ctx.Diags.diagnose(conformanceLoc,
+                             diag::inverse_cannot_be_conditional_on_requirement,
+                             thisProto,
+                             req.getFirstType().getString(),
+                             static_cast<unsigned>(req.getKind()),
+                             *illegalSecondTypeStr);
+      }
     }
   }
   assert(!conformance.isPack() && "not handled");

test/Generics/inverse_conditional_conformance_restriction.swift

@@ -0,0 +1,33 @@
+// RUN: %target-typecheck-verify-swift \
+// RUN:   -enable-experimental-feature NoncopyableGenerics \
+// RUN:   -enable-experimental-feature NonescapableTypes
+
+protocol P {}
+protocol Q {}
+class DoggoClass {}
+
+struct Blah<T: ~Copyable & ~Escapable>: ~Copyable, ~Escapable {}
+extension Blah: Copyable {} // expected-error {{conditional conformance to suppressible protocol 'Copyable' cannot depend on 'T: Escapable'}}
+extension Blah: Escapable {} // expected-error {{conditional conformance to suppressible protocol 'Escapable' cannot depend on 'T: Copyable'}}
+
+struct Yuck<T: ~Copyable & ~Escapable>: ~Copyable, ~Escapable {}
+extension Yuck: Copyable where T: ~Escapable {}
+extension Yuck: Escapable where T: ~Copyable {}
+
+struct TryConformance<Whatever: ~Copyable>: ~Copyable {}
+extension TryConformance: Copyable
+    where Whatever: P, Whatever: Q, Whatever: Sendable {}
+// expected-error@-2 {{conditional conformance to suppressible protocol 'Copyable' cannot depend on 'Whatever: P'}}
+// expected-error@-3 {{conditional conformance to suppressible protocol 'Copyable' cannot depend on 'Whatever: Q'}}
+// expected-error@-4 {{conditional conformance to suppressible protocol 'Copyable' cannot depend on 'Whatever: Sendable'}}
+
+struct TrySameType<Whatever: ~Copyable>: ~Copyable {}
+extension TrySameType: Copyable
+    where Whatever == Int {}
+// expected-error@-2 {{conditional conformance to suppressible protocol 'Copyable' cannot depend on 'Whatever == Int'}}
+
+struct TryClassAndLayoutConstraints<Whatever: ~Copyable, Heckin>: ~Copyable {}
+extension TryClassAndLayoutConstraints: Copyable
+    where Heckin: DoggoClass, Whatever: AnyObject {}
+// expected-error@-2 {{conditional conformance to suppressible protocol 'Copyable' cannot depend on 'Whatever: AnyObject'}}
+// expected-error@-3 {{conditional conformance to suppressible protocol 'Copyable' cannot depend on 'Heckin: DoggoClass'}}