[SwiftBindings] Added TypeMetadata, removed SwiftTypeInfo

src/Swift.Bindings/src/Emitter/StringCSharpEmitter/Handler/TypeHandler.cs

@@ -69,6 +69,7 @@ public void Emit(IndentedTextWriter writer, IEnvironment env, Conductor conducto
                 unsafe
                 {
                     // Apply struct layout attributes
+                    // TODO: refactor to use type metadata
                     writer.WriteLine($"[StructLayout(LayoutKind.Sequential, Size = {swiftTypeInfo.Value.ValueWitnessTable->Size})]");
                 }
             }

src/Swift.Bindings/src/Parser/SwiftABIParser.cs

@@ -280,6 +280,7 @@ private List<BaseDecl> CollectDeclarations(IEnumerable<Node> nodes, BaseDecl par
             {
                 case "Struct":
                 case "Enum":
+                    // TODO: fix this code to not use static metadata objects if possible
                     metadataPtr = DynamicLibraryLoader.invoke(_dylibPath, GetMetadataAccessor(node));
                     var swiftTypeInfo = new SwiftTypeInfo { MetadataPtr = metadataPtr };
 
@@ -292,7 +293,7 @@ private List<BaseDecl> CollectDeclarations(IEnumerable<Node> nodes, BaseDecl par
                     {
                         decl = CreateClassDecl(node, parentDecl, moduleDecl);
                     }
-                    typeRecord.SwiftTypeInfo = swiftTypeInfo;
+                   typeRecord.SwiftTypeInfo = swiftTypeInfo;
                     break;
 
                 case "Class":

src/Swift.Runtime/src/Metadata/TypeMetadata.cs

@@ -0,0 +1,199 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Collections.Generic;
+
+namespace Swift.Runtime;
+
+/// <summary>
+/// Flags used to describe types
+/// </summary>
+[Flags]
+public enum TypeMetadataFlags {
+    /// <summary>
+    /// The metadata is not an actual type
+    /// </summary>
+    MetadataKindIsNonType = 0x400,
+    /// <summary>
+    /// The metadata doesn't live on the heap
+    /// </summary>
+    MetadataKindIsNonHeap = 0x200,
+    /// <summary>
+    /// The type is private to the runtime
+    /// </summary>
+    MetadataKindIsRuntimePrivate = 0x100,
+}
+
+/// <summary>
+/// The type represented by the metadata
+/// </summary>
+public enum TypeMetadataKind {
+    /// <summary>
+    /// None - errror
+    /// </summary>
+    None = 0,
+    /// <summary>
+    /// The metadata represents a struct
+    /// </summary>
+    Struct = 0 | TypeMetadataFlags.MetadataKindIsNonHeap,
+    /// <summary>
+    /// The metadata represents an enum
+    /// </summary>
+    Enum = 1 | TypeMetadataFlags.MetadataKindIsNonHeap,
+    /// <summary>
+    /// The metadata represents an optional type
+    /// </summary>
+    Optional = 2 | TypeMetadataFlags.MetadataKindIsNonHeap,
+    /// <summary>
+    /// The metadata represents an non-swift class
+    /// </summary>
+    ForeignClass = 3 | TypeMetadataFlags.MetadataKindIsNonHeap,
+    /// <summary>
+    /// The metadata represents an opaque type
+    /// </summary>
+    Opaque = 0 | TypeMetadataFlags.MetadataKindIsRuntimePrivate | TypeMetadataFlags.MetadataKindIsNonHeap,
+    /// <summary>
+    /// The metadata represents a tuple
+    /// </summary>
+    Tuple = 1 | TypeMetadataFlags.MetadataKindIsRuntimePrivate | TypeMetadataFlags.MetadataKindIsNonHeap,
+    /// <summary>
+    /// The metadata represents a closure/function
+    /// </summary>
+    Function = 2 | TypeMetadataFlags.MetadataKindIsRuntimePrivate | TypeMetadataFlags.MetadataKindIsNonHeap,
+    /// <summary>
+    /// The metadata represents a protocol
+    /// </summary>
+    Protocol = 3 | TypeMetadataFlags.MetadataKindIsRuntimePrivate | TypeMetadataFlags.MetadataKindIsNonHeap,
+    /// <summary>
+    /// The metadata represents a type of a TypeMetadata type
+    /// </summary>
+    Metatype = 4 | TypeMetadataFlags.MetadataKindIsRuntimePrivate | TypeMetadataFlags.MetadataKindIsNonHeap,
+    /// <summary>
+    /// The metadata represents an Objective C wrapper
+    /// </summary>
+    ObjCClassWrapper = 5 | TypeMetadataFlags.MetadataKindIsRuntimePrivate | TypeMetadataFlags.MetadataKindIsNonHeap,
+    /// <summary>
+    /// The metadata represents a type of an existential container
+    /// </summary>
+    ExistentialMetatype = 6 | TypeMetadataFlags.MetadataKindIsRuntimePrivate | TypeMetadataFlags.MetadataKindIsNonHeap,
+    /// <summary>
+    /// The metadata represents a heap local variable
+    /// </summary>
+    HeapLocalVariable = 0 | TypeMetadataFlags.MetadataKindIsNonType,
+    /// <summary>
+    /// The metadata represents a generic heap local variable
+    /// </summary>
+    HeapGenericLocalVariable = 0 | TypeMetadataFlags.MetadataKindIsNonType | TypeMetadataFlags.MetadataKindIsRuntimePrivate,
+    /// <summary>
+    /// The metadata represents an error
+    /// </summary>
+    ErrorObject = 1 | TypeMetadataFlags.MetadataKindIsNonType | TypeMetadataFlags.MetadataKindIsRuntimePrivate,
+    // Swift source code says that for fixed values, this will never exceed 0x7ff,
+    // but all class types will be 0x800 and above
+    /// <summary>
+    /// The metadata represents a class
+    /// </summary>
+    Class = 0x800 
+}
+
+
+/// <summary>
+/// Represents the type metadata for a Swift type
+/// </summary>
+public readonly struct TypeMetadata : IEquatable<TypeMetadata> {
+    readonly IntPtr handle;
+
+    /// <summary>
+    /// An empty/invalid TypeMetadata object
+    /// </summary>
+    public readonly static TypeMetadata Zero = default (TypeMetadata);
+
+    /// <summary>
+    /// Construct a TypeMetadata object
+    /// </summary>
+    /// <param name="handle">The handle for the type</param>
+    TypeMetadata (IntPtr handle)
+    {
+        this.handle = handle;
+    }
+
+    /// <summary>
+    /// Returns true if and only if the TypeMetadata is valid.
+    /// </summary>
+    public bool IsValid => handle != IntPtr.Zero;
+
+    /// <summary>
+    /// Throws a NotSupportedException if the TypeMetadata is invalid
+    /// </summary>
+    /// <exception cref="NotSupportedException"></exception>
+    void ThrowOnInvalid ()
+    {
+        if (!IsValid)
+            throw new NotSupportedException ();
+    }
+
+    // This comes from the Swift ABI documentation - https://github.com/swiftlang/swift/blob/23e3f5f5de2ed046f3183264589be1f9a54f7e1e/include/swift/ABI/MetadataValues.h#L117
+    const long kMaxDiscriminator = 0x7ff;
+
+    /// <summary>
+    /// Returns the kind of this TypeMetadata
+    /// </summary>
+    public TypeMetadataKind Kind {
+        get {
+            ThrowOnInvalid ();
+			long val = ReadPointerSizedInt (handle);
+			if (val == 0)
+				return TypeMetadataKind.None;
+			if (val > kMaxDiscriminator)
+				return TypeMetadataKind.Class;
+			return (TypeMetadataKind)val;
+        }
+    }
+
+    /// <summary>
+    /// Reads a pointer sized integer from the location supplied
+    /// </summary>
+    /// <param name="p">a pointer to memory</param>
+    /// <returns></returns>
+    unsafe static nint ReadPointerSizedInt (IntPtr p)
+    {
+        // Check for debug only. This calling code should always do the null
+        // checking.
+#if DEBUG
+        if (p == IntPtr.Zero)
+            throw new ArgumentOutOfRangeException (nameof (p));
+#endif
+        return *((nint*)p);
+    }
+
+    /// <summary>
+    /// Returns true if other is the same as this
+    /// </summary>
+    /// <param name="other">a TypeMetadata object to compare</param>
+    /// <returns>true if the other is the same, false otherwise</returns>
+    public bool Equals(TypeMetadata other)
+    {
+        return other.handle == handle;
+    }
+
+    /// <summary>
+    /// Returns true if and only if o is a TypeMetadata object and is equal to this
+    /// </summary>
+    /// <param name="o">an object to compare</param>
+    /// <returns>true if the other is the same, false otherwise</returns>
+    public override bool Equals (object? o)
+    {
+        if (o is TypeMetadata tm)
+            return tm.handle == this.handle;
+        return false;
+    }
+
+    /// <summary>
+    /// Returns a hashcode for this TypeMetadata object
+    /// </summary>
+    /// <returns>A hashcode for this TypeMetadata object</returns>
+    public override int GetHashCode ()
+    {
+        return handle.GetHashCode ();
+    }
+}