How to instantiate Metadata from a ContextDescriptor for a generic type?

[ole]

Awesome library!

I want to print a list of all types, including generic types. The output should be something like this (for a program that links Foundation):

Swift.Int
Swift.Array<Element>
Swift.Dictionary<Key: Hashable, Value>
…
Foundation.Data
…

I start out with Echo.types, which returns an array of ContextDescriptors. Getting the Metadata for non-generic types such as Int is no problem, but I'm struggling with generic types. Take Dictionary as an example.

Here’s how to get the StructDescriptor for Dictionary (extracted from Echo.types):

let descriptor: TypeContextDescriptor = Echo.types
  .compactMap { ctxDesc in ctxDesc as? TypeContextDescriptor }
  .filter { structDesc in structDesc.name == "Dictionary" }
  .first!

I have to call the metadata access function to instantiate the Metadata. To do this for a generic type, I need to provide arguments for the generic parameters. If I know I'm dealing with Dictionary, this would look like this:

let metadata = descriptor.accessor(.complete, /*Key*/ String.self, /*Value*/ Int.self).metadata

But I don't know what type I'm dealing with. I'm looking for a generic (hah) solution that works for any type.

Here's where I'm struggling:

• descriptor.genericContext?.parameters returns an array of 2 GenericParameterDescriptors for the two generic parameters, Key and Value. There's very little information in a GenericParameterDescriptor, e.g. the parameter's name isn't part of the API. Q1: Are the names of a type's generic parameters not included in the type metadata?

• descriptor.genericContext?.requirements returns an array of 1 GenericRequirementDescriptor, representing the Hashable requirement for Key. Q2: How do I know which of the two generic params this requirement belongs to? From what I'm seeing, it could be either <Key: Hashable, Value> or <Key, Value: Hashable> or maybe even <Key: Hashable, Value: Hashable>. I'm not sure how to tell the difference.

• I was hoping that GenericRequirementDescriptor.paramMangledName would give me more information, but when trying to extract this name, I only get "x" for Dictionary. Is this code correct for turning the mangled name (UnsafeRawPointer) into a String?

  let paramMangledName = descriptor.genericContext!.requirements[0].paramMangledName
  let converted = String(cString: paramMangledName.assumingMemoryBound(to: CChar.self))
  print(converted) // → prints "x"

I wonder if what I want is actually possible. Thanks for any help!

[ole]

Update: I didn't make appreciable progress on my goal, but I wanted to give an update on additional things I found out.

1. I understood how to use GenericRequirementDescriptor.paramMangledName. You need to have a valid TypeMetadata value in order to pass the mangled name pointer to TypeMetadata.type(of:). This doesn’t help with my problem (how to construct the metadata value for an arbitrary generic type if all you have is the type descriptor), but it's good to know.

   Example:

   let descriptor = … (see above)
   let metadata = descriptor.accessor(.complete, /*Key*/ String.self, /*Value*/ Int.self).metadata
   let paramMangledName = metadata.type(of: descriptor.genericContext!.requirements[0].paramMangledName)!
   print(paramMangledName) // → "String" because Key == String

2. You can successfully call the metadata access function by passing Any.self for any generic parameter, even if the generic param has additional constraints. This is an improvement but it's not a complete solution because now the metadata value is invalid. Operations that access the generic parameter types fail or might crash.

   Example:

   import Echo
   
   // Get the StructDescriptor for Dictionary
   let descriptor: StructDescriptor = Echo.types
     .compactMap { ctxDesc in ctxDesc as? StructDescriptor }
     .filter { structDesc in structDesc.name == "Dictionary" }
     .first!
   // Pass Any.self for the generic params even though we know that's wrong for Key
   // Doesn't crash!
   let metadata = descriptor.accessor(.complete, Any.self, Any.self).metadata as! StructMetadata
   let fieldType = metadata.type(of: descriptor.fields.records[0].mangledTypeName)
   print(fieldType) // → nil, because fields.records[0].mangledTypeName can't be resolved
   // The real type of field 0 is `Dictionary<Key, Value>._Variant`