Add a runtime function to query the current runtime state of a metadata.

This functions returns the metadata purely for liveness purposes.

Author: rjmccall

include/swift/Runtime/Metadata.h

@@ -3981,6 +3981,11 @@ swift_allocateGenericValueMetadata(const ValueTypeDescriptor *description,
                                    const GenericValueMetadataPattern *pattern,
                                    size_t extraDataSize);
 
+/// \brief Check that the given metadata has the right state.
+SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
+MetadataResponse swift_checkMetadataState(MetadataRequest request,
+                                          const Metadata *type);
+
 /// Instantiate a resilient or generic protocol witness table.
 ///
 /// \param genericTable - The witness table template for the

include/swift/Runtime/RuntimeFunctions.def

@@ -826,6 +826,13 @@ FUNCTION(AllocateGenericValueMetadata, swift_allocateGenericValueMetadata,
          ARGS(TypeContextDescriptorPtrTy, Int8PtrPtrTy, Int8PtrPtrTy, SizeTy),
          ATTRS(NoUnwind))
 
+// MetadataResponse swift_checkMetadataState(MetadataRequest request,
+//                                           cosnt Metadata *type);
+FUNCTION(CheckMetadataState, swift_checkMetadataState, SwiftCC,
+         RETURNS(TypeMetadataResponseTy),
+         ARGS(SizeTy, TypeMetadataPtrTy),
+         ATTRS(NoUnwind, ReadOnly))
+
 // const ProtocolWitnessTable *
 // swift_getGenericWitnessTable(GenericProtocolWitnessTable *genericTable,
 //                              const Metadata *type,

stdlib/public/runtime/Metadata.cpp

@@ -3233,13 +3233,16 @@ static Result performOnMetadataCache(const Metadata *metadata,
   const TypeContextDescriptor *description;
   if (auto classMetadata = dyn_cast<ClassMetadata>(metadata)) {
     description = classMetadata->getDescription();
-  } else {
-    auto valueMetadata = cast<ValueMetadata>(metadata);
+  } else if (auto valueMetadata = dyn_cast<ValueMetadata>(metadata)) {
     description = valueMetadata->getDescription();
+  } else {
+    return std::move(callbacks).forOtherMetadata(metadata);
+  }
+
+  if (!description->isGeneric()) {
+    return std::move(callbacks).forOtherMetadata(metadata);
   }
 
-  assert(description->isGeneric() &&
-         "only generic metadata can delay evaluation for now");
   auto &generics = description->getFullGenericContextHeader();
 
   auto genericArgs =
@@ -3265,6 +3268,10 @@ bool swift::addToMetadataQueue(
                             MetadataCacheKey key) && {
       return cache.enqueue(key, std::move(QueueEntry));
     }
+
+    bool forOtherMetadata(const Metadata *metadata) && {
+      swift_runtime_unreachable("metadata should always be complete");
+    }
   } callbacks = { std::move(queueEntry) };
 
   // Set the requirement.
@@ -3295,12 +3302,38 @@ void swift::resumeMetadataCompletion(
                                  // non-key arguments.
                                  key.KeyData.begin());
     }
+
+    void forOtherMetadata(const Metadata *metadata) && {
+      swift_runtime_unreachable("metadata should always be complete");
+    }
   } callbacks = { std::move(queueEntry) };
 
   auto metadata = queueEntry->Value;
   performOnMetadataCache<void>(metadata, std::move(callbacks));
 }
 
+MetadataResponse swift::swift_checkMetadataState(MetadataRequest request,
+                                                 const Metadata *type) {
+  struct CheckStateCallbacks {
+    MetadataRequest Request;
+
+    /// Generic types just need to be awaited.
+    MetadataResponse forGenericMetadata(const Metadata *type,
+                                      const TypeContextDescriptor *description,
+                                      GenericMetadataCache &cache,
+                                      MetadataCacheKey key) && {
+      return cache.await(key, Request);
+    }
+
+    /// All other type metadata are always complete.
+    MetadataResponse forOtherMetadata(const Metadata *type) && {
+      return MetadataResponse{type, MetadataState::Complete};
+    }
+  } callbacks = { request };
+
+  return performOnMetadataCache<MetadataResponse>(type, std::move(callbacks));
+}
+
 /***************************************************************************/
 /*** Allocator implementation **********************************************/
 /***************************************************************************/

stdlib/public/runtime/MetadataCache.h

@@ -176,6 +176,15 @@ class LockingConcurrentMap {
 
     return entry->enqueue(*Concurrency, std::forward<ArgTys>(args)...);
   }
+
+  /// Given that an entry already exists, await it.
+  template <class KeyType, class... ArgTys>
+  Status await(KeyType key, ArgTys &&...args) {
+    auto entry = Map.find(key);
+    assert(entry && "entry doesn't already exist!");
+
+    return entry->await(*Concurrency, std::forward<ArgTys>(args)...);
+  }
 };
 
 /// A base class for metadata cache entries which supports an unfailing

validation-test/stdlib/MicroStdlib/Inputs/RuntimeStubs.c

@@ -6,6 +6,7 @@ int $SBi64_WV;
 int $SBi8_WV;
 void swift_getEnumCaseSinglePayload(void) {}
 void swift_getGenericMetadata(void) {}
+void swift_checkMetadataState(void) {}
 void swift_slowAlloc(void) {}
 void swift_slowDealloc(void) {}
 void swift_storeEnumTagSinglePayload(void) {}