Runtime checking for associated types conforming to invertible protocols

Emit metadata for runtime checks of conformances of associated types to
invertible protocols, e.g., `T.Assoc: Copyable`. This allows us to
correctly handle, e.g., dynamic casting involving conditional
conformances that have such constraints.

The model we use here is to emit an invertible-protocol constraint
that leaves only the specific bit clear in the invertible protocol
set.

Author: DougGregor

Diff for: lib/AST/ASTMangler.cpp

@@ -2530,8 +2530,6 @@ void ASTMangler::appendModule(const ModuleDecl *module,
 /// Mangle the name of a protocol as a substitution candidate.
 void ASTMangler::appendProtocolName(const ProtocolDecl *protocol,
                                     bool allowStandardSubstitution) {
-  assert(!protocol->getInvertibleProtocolKind() &&
-          "only inverse requirements are mangled");
   assert(AllowMarkerProtocols || !protocol->isMarkerProtocol());
 
   if (allowStandardSubstitution && tryAppendStandardSubstitution(protocol))

Diff for: lib/IRGen/GenMeta.cpp

@@ -6972,6 +6972,27 @@ GenericArgumentMetadata irgen::addGenericRequirements(
     case RequirementKind::Conformance: {
       auto protocol = requirement.getProtocolDecl();
 
+      // If this is an invertible protocol, encode it as an inverted protocol
+      // check with all but this protocol masked off.
+      if (auto invertible = protocol->getInvertibleProtocolKind()) {
+        ++metadata.NumRequirements;
+
+        InvertibleProtocolSet mask(0xFFFF);
+        mask.remove(*invertible);
+
+        auto flags = GenericRequirementFlags(
+            GenericRequirementKind::InvertedProtocols,
+            /*key argument*/ false,
+            /* is parameter pack */false);
+        addGenericRequirement(IGM, B, metadata, sig, flags,
+                              requirement.getFirstType(),
+         [&]{
+          B.addInt16(0xFFFF);
+          B.addInt16(mask.rawBits());
+        });
+        break;
+      }
+
       // Marker protocols do not record generic requirements at all.
       if (protocol->isMarkerProtocol()) {
         break;

Diff for: lib/SILOptimizer/Utils/CastOptimizer.cpp

@@ -17,6 +17,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/SILOptimizer/Utils/CastOptimizer.h"
+#include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/SubstitutionMap.h"
@@ -1472,6 +1473,10 @@ static bool optimizeStaticallyKnownProtocolConformance(
     if (Conformance.isInvalid())
       return false;
 
+    auto layout = TargetType->getExistentialLayout();
+    if (layout.getProtocols().size() != 1)
+      return false;
+
     SILBuilderWithScope B(Inst);
     SmallVector<ProtocolConformanceRef, 1> NewConformances;
     NewConformances.push_back(Conformance);

Diff for: stdlib/public/runtime/ProtocolConformance.cpp

@@ -1349,6 +1349,10 @@ bool swift::_swift_class_isSubclass(const Metadata *subclass,
   return isSubclass(subclass, superclass);
 }
 
+static std::optional<TypeLookupError>
+checkInvertibleRequirements(const Metadata *type,
+                              InvertibleProtocolSet ignored);
+
 static std::optional<TypeLookupError>
 checkGenericRequirement(
     const GenericRequirementDescriptor &req,
@@ -1445,8 +1449,10 @@ checkGenericRequirement(
   }
   case GenericRequirementKind::InvertedProtocols: {
     uint16_t index = req.getInvertedProtocolsGenericParamIndex();
-    if (index == 0xFFFF)
-      return TYPE_LOOKUP_ERROR_FMT("unable to suppress protocols");
+    if (index == 0xFFFF) {
+      return checkInvertibleRequirements(subjectType,
+                                         req.getInvertedProtocols());
+    }
 
     // Expand the suppression set so we can record these protocols.
     if (index >= suppressed.size()) {
@@ -1613,8 +1619,18 @@ checkGenericPackRequirement(
 
   case GenericRequirementKind::InvertedProtocols: {
     uint16_t index = req.getInvertedProtocolsGenericParamIndex();
-    if (index == 0xFFFF)
-      return TYPE_LOOKUP_ERROR_FMT("unable to suppress protocols");
+    if (index == 0xFFFF) {
+      // Check that each pack element meets the invertible requirements.
+      for (size_t i = 0, e = subjectType.getNumElements(); i < e; ++i) {
+        const Metadata *elt = subjectType.getElements()[i];
+
+        if (auto error = checkInvertibleRequirements(
+                elt, req.getInvertedProtocols()))
+          return error;
+      }
+
+      return std::nullopt;
+    }
 
     // Expand the suppression set so we can record these protocols.
     if (index >= suppressed.size()) {
@@ -1632,10 +1648,6 @@ checkGenericPackRequirement(
                                (unsigned)req.getKind());
 }
 
-static std::optional<TypeLookupError>
-checkInvertibleRequirements(const Metadata *type,
-                              InvertibleProtocolSet ignored);
-
 static std::optional<TypeLookupError>
 checkInvertibleRequirementsStructural(const Metadata *type,
                                         InvertibleProtocolSet ignored) {

Diff for: test/Interpreter/moveonly_generics_casting.swift

@@ -125,8 +125,7 @@ func main() {
   attemptCall(Dog<Any>())
 
   // CHECK-FIXME: failed to cast (attemptCall)
-  typealias NoncopyableAny = ~Copyable
-  // FIXME crashes: attemptCall(Dog<any NoncopyableAny>())
+  // FIXME crashes: attemptCall(Dog<any ~Copyable>())
 
   // CHECK: cast succeeded
   test_radar124171788(.nothing)

Diff for: test/Interpreter/moveonly_generics_casting_assoctypes.swift

@@ -0,0 +1,36 @@
+// RUN: %target-run-simple-swift(-Xfrontend -sil-verify-all -enable-experimental-feature NoncopyableGenerics -enable-experimental-feature SuppressedAssociatedTypes)
+// RUN: %target-run-simple-swift(-O -Xfrontend -sil-verify-all -enable-experimental-feature NoncopyableGenerics -enable-experimental-feature SuppressedAssociatedTypes)
+
+// REQUIRES: executable_test
+
+// UNSUPPORTED: use_os_stdlib
+// UNSUPPORTED: back_deployment_runtime
+
+protocol P: ~Copyable {
+  associatedtype A: ~Copyable
+}
+
+protocol Q: ~Copyable { }
+
+struct X<T: P & ~Copyable> { }
+
+extension X: Q where T: ~Copyable, T.A: Copyable { }
+
+struct NC: ~Copyable { }
+
+struct WithCopyable: P {
+  typealias A = Int
+}
+
+struct WithNonCopyable: P {
+  typealias A = NC
+}
+
+func tryCastToQ<T: P>(_: T.Type) -> Q? {
+  let x = X<T>()
+  return x as? Q
+}
+
+precondition(tryCastToQ(_: WithCopyable.self) != nil)
+precondition(tryCastToQ(_: WithNonCopyable.self) == nil)
+