Allow type metadata to be incomplete.

Most of the work of this patch is just propagating metadata states
throughout the system, especially local-type-data caching and
metadata-path resolution.  It took a few design revisions to get both
DynamicMetadataRequest and MetadataResponse to a shape that felt
right and seemed to make everything easier.

The design is laid out pretty clearly (I hope) in the comments on
DynamicMetadataRequest and MetadataResponse, so I'm not going to
belabor it again here.  Instead, I'll list out the work that's still
outstanding:

- I'm sure there are places we're asking for complete metadata where
  we could be asking for something weaker.

- I need to actually test the runtime behavior to verify that it's
  breaking the cycles it's supposed to, instead of just not regressing
  anything else.

- I need to add something to the runtime to actually force all the
  generic arguments of a generic type to be complete before reporting
  completion.  I think we can get away with this for now because all
  existing types construct themselves completely on the first request,
  but there might be a race condition there if another asks for the
  type argument, gets an abstract metadata, and constructs a type with
  it without ever needing it to be completed.

- Non-generic resilient types need to be switched over to an IRGen
  pattern that supports initialization suspension.

- We should probably space out the MetadataStates so that there's some
  space between Abstract and Complete.

- The runtime just calmly sits there, never making progress and
  permanently blocking any waiting threads, if you actually form an
  unresolvable metadata dependency cycle.  It is possible to set up such
  a thing in a way that Sema can't diagnose, and we should detect it at
  runtime.  I've set up some infrastructure so that it should be
  straightforward to diagnose this, but I haven't actually implemented
  the diagnostic yet.

- It's not clear to me that swift_checkMetadataState is really cheap
  enough that it doesn't make sense to use a cache for type-fulfilled
  metadata in associated type access functions.  Fortunately this is not
  ABI-affecting, so we can evaluate it anytime.

- Type layout really seems like a lot of code now that we sometimes
  need to call swift_checkMetadataState for generic arguments.  Maybe
  we can have the runtime do this by marking low bits or something, so
  that a TypeLayoutRef is actually either (1) a TypeLayout, (2) a known
  layout-complete metadata, or (3) a metadata of unknown state.  We could
  do that later with a flag, but we'll need to at least future-proof by
  allowing the runtime functions to return a MetadataDependency.

Author: rjmccall

lib/IRGen/Fulfillment.cpp

@@ -19,6 +19,7 @@
 #include "IRGenModule.h"
 
 #include "GenericRequirement.h"
+#include "MetadataRequest.h"
 #include "ProtocolInfo.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/ProtocolConformance.h"
@@ -109,6 +110,7 @@ static bool isLeafTypeMetadata(CanType type) {
 ///   metadata for the given type, false if it might be a subtype
 bool FulfillmentMap::searchTypeMetadata(IRGenModule &IGM, CanType type,
                                         IsExact_t isExact,
+                                        MetadataState metadataState,
                                         unsigned source, MetadataPath &&path,
                                         const InterestingKeysCallback &keys) {
 
@@ -118,26 +120,31 @@ bool FulfillmentMap::searchTypeMetadata(IRGenModule &IGM, CanType type,
     // If the type isn't a leaf type, also check it as an inexact match.
     bool hadFulfillment = false;
     if (!isLeafTypeMetadata(type)) {
-      hadFulfillment |= searchTypeMetadata(IGM, type, IsInexact, source,
-                                           MetadataPath(path), keys);
+      hadFulfillment |= searchTypeMetadata(IGM, type, IsInexact, metadataState,
+                                           source, MetadataPath(path), keys);
     }
 
     // Add the fulfillment.
-    hadFulfillment |= addFulfillment({type, nullptr}, source, std::move(path));
+    hadFulfillment |= addFulfillment({type, nullptr},
+                                     source, std::move(path), metadataState);
     return hadFulfillment;
   }
 
-  if (keys.isInterestingType(type)) {
+  // Search the superclass fields.  We can only do this if the metadata
+  // is complete.
+  if (metadataState == MetadataState::Complete &&
+      keys.isInterestingType(type)) {
     if (auto superclassTy = keys.getSuperclassBound(type)) {
-      return searchNominalTypeMetadata(IGM, superclassTy, source,
-                                       std::move(path), keys);
+      return searchNominalTypeMetadata(IGM, superclassTy, metadataState,
+                                       source, std::move(path), keys);
     }
   }
 
   // Inexact metadata will be a problem if we ever try to use this
   // to remember that we already have the metadata for something.
   if (isa<NominalType>(type) || isa<BoundGenericType>(type)) {
-    return searchNominalTypeMetadata(IGM, type, source, std::move(path), keys);
+    return searchNominalTypeMetadata(IGM, type, metadataState,
+                                     source, std::move(path), keys);
   }
 
   // TODO: tuples
@@ -218,7 +225,8 @@ bool FulfillmentMap::searchWitnessTable(
   // If we're not limiting the set of interesting conformances, or if
   // this is an interesting conformance, record it.
   if (!interestingConformances || interestingConformances->count(protocol)) {
-    hadFulfillment |= addFulfillment({type, protocol}, source, std::move(path));
+    hadFulfillment |= addFulfillment({type, protocol}, source,
+                                     std::move(path), MetadataState::Complete);
   }
 
   return hadFulfillment;
@@ -227,6 +235,7 @@ bool FulfillmentMap::searchWitnessTable(
 
 bool FulfillmentMap::searchNominalTypeMetadata(IRGenModule &IGM,
                                                CanType type,
+                                               MetadataState metadataState,
                                                unsigned source,
                                                MetadataPath &&path,
                                          const InterestingKeysCallback &keys) {
@@ -254,10 +263,12 @@ bool FulfillmentMap::searchNominalTypeMetadata(IRGenModule &IGM,
 
     // If the fulfilled value is type metadata, refine the path.
     if (!conf) {
+      auto argState = getPresumedMetadataStateForTypeArgument(metadataState);
       MetadataPath argPath = path;
       argPath.addNominalTypeArgumentComponent(reqtIndex);
       hadFulfillment |=
-        searchTypeMetadata(IGM, arg, IsExact, source, std::move(argPath), keys);
+        searchTypeMetadata(IGM, arg, IsExact, argState, source,
+                           std::move(argPath), keys);
       return;
     }
 
@@ -280,33 +291,54 @@ bool FulfillmentMap::searchNominalTypeMetadata(IRGenModule &IGM,
 
 /// Testify that there's a fulfillment at the given path.
 bool FulfillmentMap::addFulfillment(FulfillmentKey key,
-                                    unsigned source, MetadataPath &&path) {
+                                    unsigned source,
+                                    MetadataPath &&path,
+                                    MetadataState metadataState) {
   // Only add a fulfillment if we don't have any previous
   // fulfillment for that value or if it 's cheaper than the existing
   // fulfillment.
   auto it = Fulfillments.find(key);
   if (it != Fulfillments.end()) {
-    if (path.cost() >= it->second.Path.cost()) {
+    // If the new fulfillment is worse than the existing one, ignore it.
+    auto existingState = it->second.getState();
+    if (!isAtLeast(metadataState, existingState)) {
+      return false;
+    }
+
+    // Consider cost only if the fulfillments are equivalent in state.
+    // TODO: this is potentially suboptimal, but it generally won't matter.
+    if (metadataState == existingState && 
+        path.cost() >= it->second.Path.cost()) {
       return false;
     }
 
     it->second.SourceIndex = source;
     it->second.Path = std::move(path);
     return true;
   } else {
-    Fulfillments.insert({ key, Fulfillment(source, std::move(path)) });
+    Fulfillments.insert({ key, Fulfillment(source, std::move(path),
+                                           metadataState) });
     return true;
   }
 }
 
+static StringRef getStateName(MetadataState state) {
+  switch (state) {
+  case MetadataState::Complete: return "complete";
+  case MetadataState::LayoutComplete: return "layout-complete";
+  case MetadataState::Abstract: return "abstract";
+  }
+}
+
 void FulfillmentMap::dump() const {
   auto &out = llvm::errs();
   for (auto &entry : Fulfillments) {
     out << "(" << entry.first.first;
     if (auto proto = entry.first.second) {
       out << ", " << proto->getNameStr();
     }
-    out << ") => sources[" << entry.second.SourceIndex
+    out << ") => " << getStateName(entry.second.getState())
+        << " at sources[" << entry.second.SourceIndex
         << "]." << entry.second.Path << "\n";
   }
 }

lib/IRGen/Fulfillment.h

@@ -32,14 +32,19 @@ namespace irgen {
 /// path from the given source.
 struct Fulfillment {
   Fulfillment() = default;
-  Fulfillment(unsigned sourceIndex, MetadataPath &&path)
-    : SourceIndex(sourceIndex), Path(std::move(path)) {}
+  Fulfillment(unsigned sourceIndex, MetadataPath &&path, MetadataState state)
+    : SourceIndex(sourceIndex), State(unsigned(state)), Path(std::move(path)) {}
 
   /// The source index.
-  unsigned SourceIndex;
+  unsigned SourceIndex : 30;
+
+  /// The state of the metadata at the fulfillment.
+  unsigned State : 2;
 
   /// The path from the source metadata.
   MetadataPath Path;
+
+  MetadataState getState() const { return MetadataState(State); }
 };
 
 class FulfillmentMap {
@@ -90,6 +95,7 @@ class FulfillmentMap {
   ///
   /// \return true if any fulfillments were added by this search.
   bool searchTypeMetadata(IRGenModule &IGM, CanType type, IsExact_t isExact,
+                          MetadataState metadataState,
                           unsigned sourceIndex, MetadataPath &&path,
                           const InterestingKeysCallback &interestingKeys);
 
@@ -109,7 +115,8 @@ class FulfillmentMap {
   ///
   /// \return true if the fulfillment was added, which won't happen if there's
   ///   already a fulfillment that was at least as good
-  bool addFulfillment(FulfillmentKey key, unsigned source, MetadataPath &&path);
+  bool addFulfillment(FulfillmentKey key, unsigned source,
+                      MetadataPath &&path, MetadataState state);
 
   const Fulfillment *getTypeMetadata(CanType type) const {
     auto it = Fulfillments.find({type, nullptr});
@@ -139,7 +146,8 @@ class FulfillmentMap {
 
 private:
   bool searchNominalTypeMetadata(IRGenModule &IGM, CanType type,
-                                 unsigned source, MetadataPath &&path,
+                                 MetadataState metadataState, unsigned source,
+                                 MetadataPath &&path,
                                  const InterestingKeysCallback &keys);
 
   /// Search the given witness table for useful fulfillments.

lib/IRGen/GenArchetype.cpp

@@ -73,7 +73,7 @@ irgen::emitArchetypeTypeMetadataRef(IRGenFunction &IGF,
 
   setTypeMetadataName(IGF.IGM, response.getMetadata(), archetype);
 
-  IGF.setScopedLocalTypeMetadata(archetype, request, response);
+  IGF.setScopedLocalTypeMetadata(archetype, response);
 
   return response;
 }
@@ -279,12 +279,15 @@ llvm::Value *irgen::emitArchetypeWitnessTableRef(IRGenFunction &IGF,
   }
   assert(lastProtocol == protocol);
 
-  auto rootWTable = IGF.getLocalTypeData(rootArchetype,
+  auto rootWTable = IGF.tryGetLocalTypeData(rootArchetype,
               LocalTypeDataKind::forAbstractProtocolWitnessTable(rootProtocol));
+  assert(rootWTable && "root witness table not bound in local context!");
 
   wtable = path.followFromWitnessTable(IGF, rootArchetype,
                                        ProtocolConformanceRef(rootProtocol),
-                                       rootWTable, nullptr);
+                                       MetadataResponse::forComplete(rootWTable),
+                                       /*request*/ MetadataState::Complete,
+                                       nullptr).getMetadata();
 
   return wtable;
 }
@@ -300,7 +303,7 @@ irgen::emitAssociatedTypeMetadataRef(IRGenFunction &IGF,
 
   // Find the origin's type metadata.
   llvm::Value *originMetadata =
-    emitArchetypeTypeMetadataRef(IGF, origin, MetadataState::Complete)
+    emitArchetypeTypeMetadataRef(IGF, origin, MetadataState::Abstract)
       .getMetadata();
 
   return emitAssociatedTypeMetadataRef(IGF, originMetadata, wtable,
@@ -378,11 +381,11 @@ const TypeInfo *TypeConverter::convertArchetypeType(ArchetypeType *archetype) {
 
 static void setMetadataRef(IRGenFunction &IGF,
                            ArchetypeType *archetype,
-                           llvm::Value *metadata) {
+                           llvm::Value *metadata,
+                           MetadataState metadataState) {
   assert(metadata->getType() == IGF.IGM.TypeMetadataPtrTy);
-  IGF.setUnscopedLocalTypeData(CanType(archetype),
-                               LocalTypeDataKind::forFormalTypeMetadata(),
-                               metadata);
+  IGF.setUnscopedLocalTypeMetadata(CanType(archetype),
+                         MetadataResponse::forBounded(metadata, metadataState));
 }
 
 static void setWitnessTable(IRGenFunction &IGF,
@@ -401,10 +404,11 @@ static void setWitnessTable(IRGenFunction &IGF,
 /// witness value within this scope.
 void IRGenFunction::bindArchetype(ArchetypeType *archetype,
                                   llvm::Value *metadata,
+                                  MetadataState metadataState,
                                   ArrayRef<llvm::Value*> wtables) {
   // Set the metadata pointer.
   setTypeMetadataName(IGM, metadata, CanType(archetype));
-  setMetadataRef(*this, archetype, metadata);
+  setMetadataRef(*this, archetype, metadata, metadataState);
 
   // Set the protocol witness tables.
 

lib/IRGen/GenCast.cpp

@@ -115,6 +115,7 @@ FailableCastResult irgen::emitClassIdenticalCast(IRGenFunction &IGF,
     targetMetadata
       = emitClassHeapMetadataRef(IGF, toType.getSwiftRValueType(),
                                  MetadataValueType::ObjCClass,
+                                 MetadataState::Complete,
                                  /*allowUninitialized*/ allowConservative);
   }
 
@@ -248,7 +249,8 @@ void irgen::emitMetatypeDowncast(IRGenFunction &IGF,
 
     // Get the ObjC metadata for the type we're checking.
     toMetadata = emitClassHeapMetadataRef(IGF, toMetatype.getInstanceType(),
-                                          MetadataValueType::ObjCClass);
+                                          MetadataValueType::ObjCClass,
+                                          MetadataState::Complete);
     switch (mode) {
     case CheckedCastMode::Unconditional:
       castFn = IGF.IGM.getDynamicCastObjCClassMetatypeUnconditionalFn();

lib/IRGen/GenClass.cpp

@@ -757,13 +757,15 @@ llvm::Value *irgen::emitClassAllocation(IRGenFunction &IGF, SILType selfType,
   if (objc) {
     llvm::Value *metadata =
       emitClassHeapMetadataRef(IGF, classType, MetadataValueType::ObjCClass,
+                               MetadataState::Complete,
                                /*allow uninitialized*/ true);
     StackAllocSize = -1;
     return emitObjCAllocObjectCall(IGF, metadata, selfType);
   }
 
   llvm::Value *metadata =
-    emitClassHeapMetadataRef(IGF, classType, MetadataValueType::TypeMetadata);
+    emitClassHeapMetadataRef(IGF, classType, MetadataValueType::TypeMetadata,
+                             MetadataState::Complete);
 
   // FIXME: Long-term, we clearly need a specialized runtime entry point.
   llvm::Value *size, *alignMask;
@@ -2440,15 +2442,17 @@ FunctionPointer irgen::emitVirtualMethodValue(IRGenFunction &IGF,
       // dynamically.
 
       metadata = emitClassHeapMetadataRef(IGF, instanceTy.getSwiftRValueType(),
-                                          MetadataValueType::TypeMetadata);
+                                          MetadataValueType::TypeMetadata,
+                                          MetadataState::Complete);
       auto superField = emitAddressOfSuperclassRefInClassMetadata(IGF, metadata);
       metadata = IGF.Builder.CreateLoad(superField);
     } else {
       // Otherwise, we can directly load the statically known superclass's
       // metadata.
       auto superTy = instanceTy.getSuperclass();
       metadata = emitClassHeapMetadataRef(IGF, superTy.getSwiftRValueType(),
-                                          MetadataValueType::TypeMetadata);
+                                          MetadataValueType::TypeMetadata,
+                                          MetadataState::Complete);
     }
   } else {
     if ((isa<FuncDecl>(methodDecl) && cast<FuncDecl>(methodDecl)->isStatic()) ||