[Distributed] Runtime: Add a way to fetch witness tables for given generic env/arguments

Author: xedin

stdlib/public/Distributed/DistributedActorSystem.swift

@@ -176,8 +176,10 @@ extension DistributedActorSystem {
     }
 
     var substitutionsBuffer: UnsafeMutablePointer<Any.Type>? = nil
+    var witnessTablesBuffer: UnsafeRawPointer? = nil
+    var numWitnessTables: Int = 0
 
-    if genericEnv != nil {
+    if let genericEnv = genericEnv {
       let subs = try invocationDecoder.decodeGenericSubstitutions()
 
       if subs.isEmpty {
@@ -191,6 +193,17 @@ extension DistributedActorSystem {
         let element = substitutionsBuffer?.advanced(by: offset)
         element?.initialize(to: substitution)
       }
+
+      (witnessTablesBuffer, numWitnessTables) = _getWitnessTablesFor(environment: genericEnv,
+                                                                     genericArguments: substitutionsBuffer!)
+      defer {
+        witnessTablesBuffer?.deallocate()
+      }
+
+      if numWitnessTables < 0 {
+        throw ExecuteDistributedTargetError(
+          message: "Generic substitutions \(subs) do not satisfy generic requirements of \(mangledTargetName)")
+      }
     }
 
     let paramCount = nameUTF8.withUnsafeBufferPointer { nameUTF8 in

stdlib/public/Distributed/DistributedMetadata.swift

@@ -100,3 +100,11 @@ func _getGenericEnvironmentOfDistributedTarget(
     _ targetNameStart: UnsafePointer<UInt8>,
     _ targetNameLength: UInt
 ) -> UnsafeRawPointer?
+
+@available(SwiftStdlib 5.6, *)
+@_silgen_name("swift_distributed_getWitnessTables")
+public // SPI _Distributed
+func _getWitnessTablesFor(
+  environment: UnsafeRawPointer,
+  genericArguments: UnsafeRawPointer
+) -> (UnsafeRawPointer, Int)

stdlib/public/runtime/MetadataLookup.cpp

@@ -2092,6 +2092,40 @@ swift_func_getParameterTypeInfo(
   return typesLength;
 }
 
+SWIFT_CC(swift)
+SWIFT_RUNTIME_STDLIB_SPI
+BufferAndSize
+swift_distributed_getWitnessTables(GenericEnvironmentDescriptor *genericEnv,
+                                   const void *const *genericArguments) {
+  assert(genericEnv);
+  assert(genericArguments);
+
+  llvm::SmallVector<const void *, 4> witnessTables;
+  SubstGenericParametersFromMetadata substFn(genericEnv, genericArguments);
+
+  auto error = _checkGenericRequirements(
+      genericEnv->getGenericRequirements(), witnessTables,
+      [&substFn](unsigned depth, unsigned index) {
+        return substFn.getMetadata(depth, index);
+      },
+      [&substFn](const Metadata *type, unsigned index) {
+        return substFn.getWitnessTable(type, index);
+      });
+
+  if (error) {
+    return {/*ptr=*/nullptr, -1};
+  }
+
+  if (witnessTables.empty())
+    return {/*ptr=*/nullptr, 0};
+
+  void **tables = (void **)malloc(witnessTables.size() * sizeof(void *));
+  for (unsigned i = 0, n = witnessTables.size(); i != n; ++i)
+    tables[i] = const_cast<void *>(witnessTables[i]);
+
+  return {tables, static_cast<intptr_t>(witnessTables.size())};
+}
+
 // ==== End of Function metadata functions ---------------------------------------
 
 SWIFT_CC(swift) SWIFT_RUNTIME_EXPORT

stdlib/public/runtime/Private.h

@@ -58,6 +58,13 @@ class TypeReferenceOwnership {
   bool isStrong() const { return Data == 0; }
 };
 
+/// A struct to return pointer and its size back to Swift
+/// as `(UnsafePointer<UInt8>, Int)`.
+struct BufferAndSize {
+  const void *buffer;
+  intptr_t length; // negative length means error.
+};
+
 /// Type information consists of metadata and its ownership info,
 /// such information is used by `_typeByMangledName` accessor
 /// since we don't represent ownership attributes in the metadata