Extend runtime checking for suppressible protocols

Add more runtime support for checking suppressible protocol requirements:
* Parameter packs now check all of the arguments appropriately
* Most structural types now implement checking (these are hard to test).

Author: DougGregor

stdlib/public/runtime/MetadataLookup.cpp

@@ -3238,7 +3238,14 @@ SubstGenericParametersFromMetadata::getMetadata(
 
 MetadataOrPack
 SubstGenericParametersFromMetadata::getMetadataOrdinal(unsigned ordinal) const {
-  return MetadataOrPack(genericArgs[ordinal]);
+  // Don't attempt anything if we have no generic parameters.
+  if (genericArgs == nullptr)
+    return MetadataOrPack();
+
+  // On first access, compute the descriptor path.
+  setup();
+
+  return MetadataOrPack(genericArgs[numShapeClasses + ordinal]);
 }
 
 const WitnessTable *

stdlib/public/runtime/ProtocolConformance.cpp

@@ -1632,16 +1632,96 @@ checkGenericPackRequirement(
                                (unsigned)req.getKind());
 }
 
+static std::optional<TypeLookupError>
+checkSuppressibleRequirements(const Metadata *type,
+                              SuppressibleProtocolSet ignored);
+
 static std::optional<TypeLookupError>
 checkSuppressibleRequirementsStructural(const Metadata *type,
                                         SuppressibleProtocolSet ignored) {
-  // FIXME: Implement me!
+  switch (type->getKind()) {
+  case MetadataKind::Class:
+  case MetadataKind::Struct:
+  case MetadataKind::Enum:
+  case MetadataKind::Optional:
+  case MetadataKind::ForeignClass:
+  case MetadataKind::ForeignReferenceType:
+  case MetadataKind::ObjCClassWrapper:
+    // All handled via context descriptor in the caller.
+    return std::nullopt;
+
+  case MetadataKind::HeapLocalVariable:
+  case MetadataKind::Opaque:
+  case MetadataKind::HeapGenericLocalVariable:
+  case MetadataKind::ErrorObject:
+  case MetadataKind::Task:
+  case MetadataKind::Job:
+    // Not part of the user-visible type system; assumed to handle all
+    // suppressible requirements.
+    return std::nullopt;
+
+  case MetadataKind::Tuple: {
+    // Check every element type in the tuple.
+    auto tupleMetadata = cast<TupleTypeMetadata>(type);
+    for (unsigned i = 0, n = tupleMetadata->NumElements; i != n; ++i) {
+      if (auto error =
+              checkSuppressibleRequirements(&*tupleMetadata->getElement(i).Type,
+                                            ignored))
+        return error;
+    }
+    return std::nullopt;
+  }
+
+  case MetadataKind::Function: {
+    // FIXME: Implement me
+    return std::nullopt;
+  }
+
+  case MetadataKind::ExtendedExistential: {
+    auto existential = cast<ExtendedExistentialTypeMetadata>(type);
+    auto &shape = *existential->Shape;
+    llvm::ArrayRef<GenericRequirementDescriptor> reqs(
+        shape.getReqSigRequirements(), shape.getNumReqSigRequirements());
+    // Look for any suppressed protocol requirements. If the existential
+    // has suppressed a protocol that is not ignored, then the existential
+    // does not meet the specified requirements.
+    for (const auto& req : reqs) {
+      if (req.getKind() != GenericRequirementKind::SuppressedProtocols)
+        continue;
+
+      auto suppressed = req.getSuppressedProtocols();
+      auto missing = suppressed - ignored;
+      if (!missing.empty()) {
+        return TYPE_LOOKUP_ERROR_FMT(
+            "existential type missing suppresible protocols %x",
+            missing.rawBits());
+      }
+    }
+
+    return std::nullopt;
+  }
+
+  case MetadataKind::Metatype:
+  case MetadataKind::ExistentialMetatype:
+    // Metatypes themselves can't have suppressible protocols.
+    return std::nullopt;
+
+  case MetadataKind::Existential:
+    // The existential representation has no room for specifying any
+    // suppressed requirements, so it always succeeds.
+    return std::nullopt;
+
+  case MetadataKind::LastEnumerated:
+    break;
+  }
+
+  // Just accept any unknown types.
   return std::nullopt;
 }
 
 /// Check that the given `type` meets all suppressible protocol requirements
 /// that haven't been explicitly suppressed by `ignored`.
-static std::optional<TypeLookupError>
+std::optional<TypeLookupError>
 checkSuppressibleRequirements(const Metadata *type, 
                               SuppressibleProtocolSet ignored) {
   auto contextDescriptor = type->getTypeContextDescriptor();
@@ -1763,32 +1843,47 @@ std::optional<TypeLookupError> swift::_checkGenericRequirements(
     if (index < allSuppressed.size())
       suppressed = allSuppressed[index];
 
+    MetadataOrPack metadataOrPack(substGenericParamOrdinal(index));
     switch (genericParams[index].getKind()) {
-    case GenericParamKind::Type:
-      break;
+    case GenericParamKind::Type: {
+      if (!metadataOrPack || metadataOrPack.isMetadataPack()) {
+        return TYPE_LOOKUP_ERROR_FMT(
+            "unexpected pack for generic parameter %u", index);
+      }
 
-    case GenericParamKind::TypePack:
-      // FIXME: variadic generics
-      continue;
+      auto metadata = metadataOrPack.getMetadata();
+      if (auto error = checkSuppressibleRequirements(metadata, suppressed))
+        return error;
 
-    default:
-      return TYPE_LOOKUP_ERROR_FMT("unknown generic parameter kind %u",
-                                   index);
+      break;
     }
 
-    MetadataOrPack metadataOrPack(substGenericParamOrdinal(index));
-    if (!metadataOrPack)
-      return TYPE_LOOKUP_ERROR_FMT("unable to find generic argument %u",
-                                   index);
+    case GenericParamKind::TypePack: {
+      // NULL can be used to indicate an empty pack.
+      if (!metadataOrPack)
+        break;
 
-    if (metadataOrPack.isMetadataPack()) {
-      // FIXME: variadic generics
-      continue;
+      if (metadataOrPack.isMetadata()) {
+        return TYPE_LOOKUP_ERROR_FMT(
+            "unexpected metadata for generic pack parameter %u", index);
+      }
+
+      auto pack = metadataOrPack.getMetadataPack();
+      if (pack.getElements() != 0) {
+        llvm::ArrayRef<const Metadata *> elements(
+            pack.getElements(), pack.getNumElements());
+        for (auto element : elements) {
+          if (auto error = checkSuppressibleRequirements(element, suppressed))
+            return error;
+        }
+      }
+      break;
     }
 
-    auto metadata = metadataOrPack.getMetadata();
-    if (auto error = checkSuppressibleRequirements(metadata, suppressed))
-      return error;
+    default:
+      return TYPE_LOOKUP_ERROR_FMT("unknown generic parameter kind %u",
+                                   index);
+    }
   }
 
   // Success!

test/Interpreter/moveonly_generics_casting.swift

@@ -28,6 +28,10 @@ struct ConditionallyCopyable<T: ~Copyable>: ~Copyable {
 }
 extension ConditionallyCopyable: Copyable where T: Copyable { }
 
+// FIXME: Not yet supported
+// struct VariadicCopyable<each T: ~Copyable>: Copyable { }
+// extension VariadicCopyable: P where repeat each T: Copyable { }
+
 func attemptCall(_ a: Any) {
   if let value = a as? P {
     value.speak()
@@ -56,6 +60,46 @@ func main() {
    // CHECK: failed to cast (attemptCall)
   attemptCall(Cat<Noncopyable, ConditionallyCopyable<Ordinary>>())
 
+  // CHECK-FIXME: hello
+  // attemptCall(VariadicCopyable<Ordinary, ConditionallyCopyable<Ordinary>>())
+
+  // CHECK-FIXME: failed to cast (attemptCall)
+  // attemptCall(VariadicCopyable<Ordinary, ConditionallyCopyable<Noncopyable>>())
+
+  // CHECK: tuple types
+  print("tuple types")
+
+  // CHECK: hello
+  attemptCall(Dog<(Ordinary, Ordinary)>())
+
+  // CHECK-FIXME: failed to cast (attemptCall)
+  // FIXME: Requires the ability to create such tuple types
+  // attemptCall(Dog<(Ordinary, Noncopyable)>())
+
+  // CHECK: metatype types
+  print("metatype types")
+
+  // CHECK: hello
+  attemptCall(Dog<Ordinary.Type>())
+
+  // CHECK: hello
+  attemptCall(Dog<Noncopyable.Type>())
+
+  // CHECK: function types
+  print("function types")
+
+  attemptCall(Dog<(Ordinary) -> Noncopyable>())
+
+  // CHECK: existential types
+  print("existential types")
+
+  // CHECK: hello
+  attemptCall(Dog<Any>())
+
+  // CHECK-FIXME: failed to cast (attemptCall)
+  typealias NoncopyableAny = ~Copyable
+  // FIXME crashes: attemptCall(Dog<any NoncopyableAny>())
+
   // CHECK: cast succeeded
   test_radar124171788(.nothing)
 }