WebAssembly: add a ton of logging when looking up metadata

Not sure what's going on here:

https://gist.github.com/zhuowei/beff646ebc09bed4458421cf7aba210b

Author: zhuowei

stdlib/public/runtime/MetadataLookup.cpp

@@ -276,19 +276,47 @@ _findExtendedTypeContextDescriptor(const ExtensionContextDescriptor *extension,
 /// buildContextDescriptorMangling in MetadataReader.
 bool swift::_isCImportedTagType(const TypeContextDescriptor *type,
                                 const ParsedTypeIdentity &identity) {
+  fprintf(stderr, "trying to dump type %p\n", type);
+  fprintf(stderr, "name: %s\n", type->Name.get());
+  fprintf(stderr, "trying to dump identity %p\n", &identity);
+  fprintf(stderr, "User facing name: %s\n", identity.UserFacingName.str().c_str());
+  fprintf(stderr, "ok, let's go\n");
   // Tag types are always imported as structs or enums.
   if (type->getKind() != ContextDescriptorKind::Enum &&
       type->getKind() != ContextDescriptorKind::Struct)
     return false;
 
+  fprintf(stderr, "is it a c typedef\n");
+
   // Not a typedef imported as a nominal type.
   if (identity.isCTypedef())
     return false;
 
+  fprintf(stderr, "is related entity\n");
+
   // Not a related entity.
   if (identity.isAnyRelatedEntity())
     return false;
 
+  fprintf(stderr, "is c imported context\n");
+  fprintf(stderr, "type's parent, raw: %x\n", *((unsigned int*)&type->Parent));
+  fprintf(stderr, "type's parent: %p\n", type->Parent.get());
+//  fprintf(stderr, "type's parent name: %s\n", type->Parent->Name.get());
+  fprintf(stderr, "trying to get module context\n");
+
+  for (auto cur = type->Parent.get(); true; cur = cur->Parent.get()) {
+    fprintf(stderr, "cur %p\n", cur);
+    fprintf(stderr, "cur %x\n", (unsigned int)cur->getKind());
+    if (auto module = dyn_cast<ModuleContextDescriptor>(cur)) {
+      fprintf(stderr, "found\n");
+      break;
+    }
+  }
+
+  fprintf(stderr, "type's parent module context: %p\n", type->Parent->getModuleContext());
+  fprintf(stderr, "trying to get name\n");
+  fprintf(stderr, "type's parent module context name: %s\n", type->Parent->getModuleContext()->Name.get());
+
   // Imported from C.
   return type->Parent->isCImportedContext();
 }

stdlib/public/runtime/ProtocolConformance.cpp

@@ -545,6 +545,7 @@ static const ProtocolConformanceDescriptor *
 swift_conformsToSwiftProtocolImpl(const Metadata * const type,
                                   const ProtocolDescriptor *protocol,
                                   StringRef module) {
+  fprintf(stderr, "in impl2\n");
   auto &C = Conformances.get();
 
   // See if we have a cached conformance. The ConcurrentMap data structure
@@ -571,17 +572,25 @@ swift_conformsToSwiftProtocolImpl(const Metadata * const type,
     C.cacheFailure(type, protocol, snapshot.count());
     return nullptr;
   }
-
+  fprintf(stderr, "got to really scan\n");
   // Really scan conformance records.
   for (size_t i = startIndex; i < endIndex; i++) {
+    fprintf(stderr, "index = %lx\n", (unsigned long)i);
     auto &section = snapshot.Start[i];
     // Eagerly pull records for nondependent witnesses into our cache.
     for (const auto &record : section) {
-      auto &descriptor = *record.get();
+      fprintf(stderr, "got a record\n");
+      auto descriptorPtr = record.get();
+      auto &descriptor = *descriptorPtr;
+      fprintf(stderr, "got the descriptor: %p\n", descriptorPtr);
+      fprintf(stderr, "got the protocol: %p\n", descriptor.getProtocol());
+      descriptor.getProtocol()->dump();
+      fprintf(stderr, "got it\n");
 
       // We only care about conformances for this protocol.
       if (descriptor.getProtocol() != protocol)
         continue;
+      fprintf(stderr, "about to get matching type\n");
 
       // If there's a matching type, record the positive result.
       ConformanceCandidate candidate(descriptor);
@@ -596,6 +605,7 @@ swift_conformsToSwiftProtocolImpl(const Metadata * const type,
   }
 
   // Conformance scan is complete.
+  fprintf(stderr, "about to update cache\n");
 
   // Search the cache once more, and this time update the cache if necessary.
   FoundConformance = searchInConformanceCache(type, protocol);
@@ -610,12 +620,21 @@ swift_conformsToSwiftProtocolImpl(const Metadata * const type,
 static const WitnessTable *
 swift_conformsToProtocolImpl(const Metadata * const type,
                              const ProtocolDescriptor *protocol) {
+  // WebAssembly: logging pls
+  fprintf(stderr, "swift_conformsToProtocolImpl: %p %p\n", type, protocol);
+  protocol->dump();
+  fprintf(stderr, "trying to dump the type now\n");
+  type->dump();
+  fprintf(stderr, "dumped the type\n");
+  // end WebAssembly
   auto description =
     swift_conformsToSwiftProtocol(type, protocol, StringRef());
   if (!description)
     return nullptr;
+  description->getProtocol()->dump();
 
-  return description->getWitnessTable(type);
+  auto retval = description->getWitnessTable(type);
+  return retval;
 }
 
 const ContextDescriptor *