GenProto: drop conditional Copyable reqs from protocol conformance descriptors

lib/IRGen/GenProto.cpp

@@ -2113,17 +2113,28 @@ namespace {
       if (!normal)
         return;
 
-      std::optional<Requirement> scratchRequirement;
-      auto condReqs = normal->getConditionalRequirements();
+      SmallVector<Requirement, 2> condReqs;
+      {
+        // FIXME(kavon): probably need to emit the inverse requirements in the
+        //  metadata so the runtime knows not to check for Copyable? For now
+        //  filter them out.
+        auto origCondReqs = normal->getConditionalRequirements();
+        for (auto req : origCondReqs) {
+          if (req.getKind() == RequirementKind::Conformance &&
+              req.getProtocolDecl()->getInvertibleProtocolKind())
+            continue;
+          condReqs.push_back(req);
+        }
+      }
+
       if (condReqs.empty()) {
         // For a protocol P that conforms to another protocol, introduce a
         // conditional requirement for that P's Self: P. This aligns with
         // SILWitnessTable::enumerateWitnessTableConditionalConformances().
         if (auto selfProto = normal->getDeclContext()->getSelfProtocolDecl()) {
           auto selfType = selfProto->getSelfInterfaceType()->getCanonicalType();
-          scratchRequirement.emplace(RequirementKind::Conformance, selfType,
-                                     selfProto->getDeclaredInterfaceType());
-          condReqs = *scratchRequirement;
+          condReqs.emplace_back(RequirementKind::Conformance, selfType,
+                                selfProto->getDeclaredInterfaceType());
         }
 
         if (condReqs.empty())

test/Interpreter/moveonly_generics_casting.swift

@@ -0,0 +1,70 @@
+// RUN: %target-run-simple-swift(-Xfrontend -sil-verify-all -enable-experimental-feature NoncopyableGenerics) | %FileCheck %s
+// RUN: %target-run-simple-swift(-O -Xfrontend -sil-verify-all -enable-experimental-feature NoncopyableGenerics) | %FileCheck %s
+
+protocol P {
+  func speak()
+}
+
+extension P {
+  func speak() { print("hello") }
+}
+
+struct Noncopyable: ~Copyable {}
+struct Ordinary {}
+
+struct Dog<T: ~Copyable>: Copyable {}
+extension Dog: P where T: Copyable {}
+
+enum Cat<Left: ~Copyable, Right: ~Copyable>: Copyable {
+    case meows
+    init() { self = .meows }
+}
+extension Cat: P where Left: Copyable {}
+
+func attemptCall(_ a: Any) {
+  if let value = a as? P {
+    value.speak()
+    return
+  }
+  print("failed to cast (attemptCall)")
+}
+
+defer { main() }
+func main() {
+  // CHECK: hello
+  attemptCall(Dog<Ordinary>())
+
+  // FIXME: this is NOT suppose to succeed! (rdar://123466649)
+  // CHECK: hello
+  attemptCall(Dog<Noncopyable>())
+
+  // CHECK: hello
+  attemptCall(Cat<Ordinary, Noncopyable>())
+
+  // FIXME: this is NOT suppose to succeed! (rdar://123466649)
+  // CHECK: hello
+  attemptCall(Cat<Noncopyable, Ordinary>())
+
+  // FIXME: this should succeeed!!
+  // CHECK: failed to cast (test_radar124171788)
+  test_radar124171788(.nothing)
+}
+
+// coverage for rdar://124171788
+enum Maybe<Wrapped: ~Copyable>: ~Copyable {
+  case just(Wrapped)
+  case nothing
+}
+extension Maybe: Copyable {}
+extension Maybe: CustomStringConvertible {
+  var description: String {
+    "cast succeeded"
+  }
+}
+func test_radar124171788(_ v: Maybe<Int>) {
+  if let foo = v as? CustomDebugStringConvertible {
+    print("\(foo.debugDescription)")
+    return
+  }
+  print("failed to cast (test_radar124171788)")
+}