winmd-inspect: close over signature-named value types and delegates

Extend the `--closure` walk to pull in the value-type and delegate types a
rendered interface names through its method signatures — the E3 value arm, the
E6 struct-field types, and the E7 delegate signatures — so the closure emits
everything a consumer needs to compile the projection, not the interface surface
alone. Each projected type is an ABI-faithful shape, the way the interface
projects an `@com` protocol that lowers to the COM vtable.

`emit` now dispatches on the row's kind (`found[4]`): a struct through
`structure`, an enum through `enumeration`, a delegate through `delegation`, and
an interface through `interface` (the former inline body, now its own half),
each rendered under exactly one of the template's `{{#struct}}`/`{{#enum}}`/
`{{#delegate}}`/`{{#interface}}` sections. The `walk` seeds and the `requires`
bases carry the kind at index 4 so the walk and emit dispatch on the same column
a `references` row already has.

The projected shapes match how the target language's import models them. A
struct is an `@frozen` struct, its guaranteed layout the C/C++ record it mirrors
field for field, with a public memberwise initialiser (the synthesised one is
internal, so a cross-module caller could not otherwise construct it). Only
instance fields are storage: a static or literal field (the `fdStatic` bit) is
dropped, and the dependency walk applies the same filter so a type named only by
a dropped field is not pulled in. A value type whose ABI layout `@frozen` cannot
reproduce — an explicit layout, a non-default packing, or a declared class size
— is rejected as a frontier rather than misprojected; the `layout` query returns
a row only for such a type (`ClassLayout` is an optional table the adapter now
synthesises empty when absent). An enum projects to an explicitly-stored
raw-value struct newtype, because a native `enum E: <underlying>` does not carry
its raw type's ABI width; a `[flags]` enum (a `System.FlagsAttribute`, detected
through the overridable `flags` query) is the same newtype refined to
`OptionSet`. The `value__` storage field is found by its raw metadata name, so a
`SANITIZE` override respelling it does not drop the enum to the `i4` fallback
width, and each member's value is the constant `value(field:)` already formats
per signedness. A delegate is an `@com(interface:)` protocol carrying a single
`Invoke`, decoding its runtime IID through the `guid` query.

Signature adjacency (E3/E6/E7) runs per kind — an interface over its methods, a
struct over its instance fields, a delegate over its `Invoke` — resolving each
referenced type through `references` by the exact row it was named through,
never by (namespace, name), so two same-named nested types are not conflated. A
resolved runtime `class` stays a frontier; an external `TypeRef`-only reference
resolves to nothing and drops; a nongeneric interface or delegate bearing no
`GuidAttribute` — whose `@com` shape would spell a GUID-less `""` — is dropped,
while a generic one (no static IID by design) is kept and renders through the
generic arm. A reached type the language import already provides — a
`Dialect.known` identity such as `HRESULT` — is a frontier the closure emits no
wrapper for, since the consumer has it from the import.

A signature-named value type or delegate emits at top level by its bare name.
Metadata nesting (`Outer.Inner`) and the namespace disambiguation of same-named
value types are follow-ups; this change lands the per-kind projections and the
signature closure on the unique-name path.

Integration tests over hand-built fixtures cover a struct-returning method (the
`@frozen` struct with its public initialiser, emitted before the interface), an
enum parameter (a stored newtype, a duplicate raw value as two constants, and a
`[flags]` `OptionSet`), a delegate parameter (its `@com` protocol and decoded
IID, plus a parameterised delegate kept through its generic arm and a
keyword-named generic parameter escaped), and a signature-named interface
enqueued and emitted; further tests pin an auto/explicit/packed/sized struct and
a static struct field each dropped, a GUID-less nongeneric interface and a
language-provided type each frontiered, and a unique-named value type emitted
bare with no namespace.

The `fields` render query gains `Flags` and raw-name columns so the walk and the
struct render drop a static field and the enum render finds its `value__`
storage. Render-query shadowing is a supported extension point, though, so a `-I`
override carrying the former two-column shape (`Id`, `Name`) is tolerated rather
than trapping on the absent columns: a field with no `Flags` counts as instance
storage, as it did before the columns existed, and the raw-name read falls back
to the escaped `Name`.

Author: compnerd

Sources/SQLEngineWinMD/Database+SQL.swift

@@ -65,7 +65,8 @@ extension WinMD.Storage: SQLEngine.Catalog {
   /// physically-present tables plus the referenced optionals.
   private static var optionals: Array<(name: String, schema: TableSchema.Type)> {
     [(name: "TypeSpec", schema: Metadata.Tables.TypeSpec.self),
-     (name: "NestedClass", schema: Metadata.Tables.NestedClass.self)]
+     (name: "NestedClass", schema: Metadata.Tables.NestedClass.self),
+     (name: "ClassLayout", schema: Metadata.Tables.ClassLayout.self)]
   }
 
   /// The relation named `name`, resolved case-insensitively against the

Sources/winmd-inspect/Resources/Render/fields.sql

@@ -1,10 +1,19 @@
 -- A struct's fields, in declaration order, through the `fields` view bound by
 -- the struct's `Id` — each field's `Id` (for the render to decode its type from
--- its `FieldDef` signature) and its keyword-escaped `Name`. The render spells
--- each field's type at render time from the target `Dialect`, so the query
--- projects only the identity and name, the way `params` does for a method.
+-- its `FieldDef` signature), its keyword-escaped `Name`, its `Flags`, and its
+-- raw (unsanitized) metadata name. The render spells each field's type
+-- at render time from the target `Dialect`, so the query projects the identity
+-- and name the way `params` does for a method; the `Flags` let the struct
+-- render drop a static or literal field (the `fdStatic` bit), which is not
+-- instance storage, while the enum render (which reads the same view for its
+-- members) keeps them. The raw name lets the enum render find its `value__`
+-- storage field by its metadata name, unaffected by a `SANITIZE` override that
+-- would change the escaped spelling the way a member's does.
 SELECT
-  Id,
-  SANITIZE(Name) AS Name
+  f.Id,
+  SANITIZE(f.Name) AS Name,
+  d.Flags AS Flags,
+  f.Name AS Raw
 FROM
-  fields
+  fields f
+  JOIN FieldDef d ON d.Id = f.Id

Sources/winmd-inspect/Resources/Render/flags.sql

@@ -0,0 +1,53 @@
+-- Whether the enum `TypeDef` at `:parent` bears a `System.FlagsAttribute`
+-- custom attribute — the `[flags]` marking that makes the enum a bitmask. It
+-- returns the enum's `Id` when the attribute is present and no row otherwise,
+-- so the render projects a `[flags]` enum as an `OptionSet` (its members
+-- combine) and a plain enum as a native fixed-size Swift `enum`.
+--
+-- The attribute is matched by its (namespace, name) the way `guid.sql` and the
+-- `interfaces` view match `GuidAttribute` — through the three encodings a
+-- `CustomAttribute` names its constructor by: a `MemberRef` to a `TypeRef` (an
+-- external reference, the shape real metadata uses for `System.FlagsAttribute`),
+-- a `MethodDef` on the attribute `TypeDef` (a local definition), and a
+-- `MemberRef` to a `TypeDef` (a `MemberRef` naming a local definition). Only the
+-- namespace and name differ from `guid.sql`: `System.FlagsAttribute`, not the
+-- Win32 metadata `GuidAttribute`.
+--
+-- `CustomAttribute`/`MemberRef` are present in real metadata; a fixture that
+-- omits the matching rows simply yields no row, so the enum reads as not a
+-- `[flags]` enum — the same graceful non-match the `guid` query relies on.
+SELECT
+  t.Id AS flags
+FROM
+  TypeDef t
+  JOIN CustomAttribute c ON c.Parent_TypeDef = t.Id
+  JOIN MemberRef r ON c.Type_MemberRef = r.Id
+  JOIN TypeRef g ON r.Class_TypeRef = g.Id
+WHERE
+  g.TypeNamespace = 'System'
+  AND g.TypeName = 'FlagsAttribute'
+  AND t.Id = :parent
+UNION
+SELECT
+  t.Id AS flags
+FROM
+  TypeDef t
+  JOIN CustomAttribute c ON c.Parent_TypeDef = t.Id
+  JOIN MethodDef m ON c.Type_MethodDef = m.Id
+  JOIN TypeDef g ON m.TypeDef = g.Id
+WHERE
+  g.TypeNamespace = 'System'
+  AND g.TypeName = 'FlagsAttribute'
+  AND t.Id = :parent
+UNION
+SELECT
+  t.Id AS flags
+FROM
+  TypeDef t
+  JOIN CustomAttribute c ON c.Parent_TypeDef = t.Id
+  JOIN MemberRef r ON c.Type_MemberRef = r.Id
+  JOIN TypeDef g ON r.Class_TypeDef = g.Id
+WHERE
+  g.TypeNamespace = 'System'
+  AND g.TypeName = 'FlagsAttribute'
+  AND t.Id = :parent

Sources/winmd-inspect/Resources/Render/layout.sql

@@ -0,0 +1,43 @@
+-- Whether the value type at `:parent` has an ABI layout the `@frozen` struct
+-- projection cannot faithfully reproduce: it returns the type's `Id` when the
+-- type must be rejected, no row when it renders safely.
+--
+-- Only a sequential layout is safe. The `0x18` LayoutMask (§II.23.1.15) marks a
+-- value type auto (`0x00`), sequential (`0x08` tdSequentialLayout), or explicit
+-- (`0x10` tdExplicitLayout). An auto layout lets the runtime lay the fields out
+-- in whatever order it chooses, so their declaration (FieldDef) order need not
+-- be their memory order — a Swift `struct`, which lays its stored properties out
+-- in source order, would then mismatch. An explicit layout places fields at
+-- declared offsets — an overlapping union or a hand-laid record — which a Swift
+-- `struct` cannot express. Only a sequential layout guarantees the fields lie in
+-- declaration order at their natural offsets, the one arrangement a `struct`
+-- reproduces, so the check admits `0x08` alone and rejects auto, explicit, and
+-- the reserved `0x18`.
+--
+-- A non-default packing (a `ClassLayout` row whose `PackingSize` is not zero)
+-- tightens the fields below their natural alignment, shifting every offset past
+-- the first. A declared size (a `ClassLayout` row whose `ClassSize` is not zero,
+-- §II.22.8) fixes the total in-memory extent — padding the record out to a
+-- larger size, or forcing tail padding a naturally-laid struct would not carry —
+-- which no `@frozen` `struct` reproduces either. `@frozen` only freezes the
+-- layout Swift itself chooses; it applies neither an explicit offset, a packing,
+-- nor a declared size, so such a type would decode to the wrong size and field
+-- offsets when passed to a native API. The closure walk rejects a type this
+-- query returns a row for, leaving it a frontier the consumer defines rather
+-- than an ABI-incompatible declaration. A `ClassSize` of zero is unspecified
+-- (the natural size stands), so it is safe; any non-zero declared size is
+-- rejected conservatively.
+--
+-- `ClassLayout` is an optional table (`table(named:)` resolves it to an empty
+-- relation when absent), so a database with no laid-out type reads no packing or
+-- size row and the LEFT JOIN yields NULL, which `COALESCE` treats as the default.
+SELECT
+  t.Id
+FROM
+  TypeDef t
+  LEFT JOIN ClassLayout c ON c.Parent = t.Id
+WHERE
+  t.Id = :parent
+  AND (BITAND(t.Flags, 24) <> 8
+       OR COALESCE(c.PackingSize, 0) <> 0
+       OR COALESCE(c.ClassSize, 0) <> 0)

Sources/winmd-inspect/Resources/Render/requires.sql

@@ -54,7 +54,8 @@ SELECT
   n.Id,
   n.TypeNamespace,
   n.TypeName,
-  n.iid
+  n.iid,
+  'interface' AS kind
 FROM
   InterfaceImpl i
   JOIN resolved rv ON rv.ref = i.Interface_TypeRef
@@ -66,7 +67,8 @@ SELECT
   n.Id,
   n.TypeNamespace,
   n.TypeName,
-  n.iid
+  n.iid,
+  'interface' AS kind
 FROM
   InterfaceImpl i
   JOIN interfaces n ON n.Id = i.Interface_TypeDef

Sources/winmd-inspect/Resources/Templates/com.mustache

@@ -32,3 +32,94 @@ public protocol {{{name}}}{{#base}}: {{{.}}}{{/base}} {
 }
 {{/generic}}
 {{/interface}}
+{{#struct}}
+// @frozen fixes the ABI layout, so the projected struct is the C/C++ record it
+// mirrors field for field — the transparent layout interop passes by value.
+@frozen public struct {{{name}}} {
+{{#fields}}
+    public var {{{name}}}: {{{type}}}
+{{/fields}}
+
+    // The synthesized memberwise initializer is internal even for a public
+    // struct, so an explicit public one lets a caller outside the generated
+    // module construct the value type to pass to a native API.
+    public init({{#fields}}{{{name}}}: {{{type}}}{{^last}}, {{/last}}{{/fields}}) {
+{{#fields}}
+        self.{{{name}}} = {{{name}}}
+{{/fields}}
+    }
+}
+{{/struct}}
+{{#enum}}
+{{#flags}}
+{{! A `[flags]` enum projects to an OptionSet the way ClangImporter imports an
+    NS_OPTIONS C enum: its members combine as a bitmask, which a native `enum`
+    case — a single value — cannot name. `RawValue` is the enum's `value__`
+    underlying type, so the set is the ABI-exact width of the C enum, and each
+    `@_transparent` member folds to its raw constant at the use site with no
+    static storage; a repeated raw value across members is fine here. }}
+@frozen public struct {{{name}}}: OptionSet {
+    public typealias RawValue = {{{underlying}}}
+    public let rawValue: RawValue
+    @inlinable public init(rawValue: RawValue) { self.rawValue = rawValue }
+{{#members}}
+    @_transparent public static var {{{name}}}: {{{owner}}} { {{{owner}}}(rawValue: {{{value}}}) }
+{{/members}}
+}
+{{/flags}}
+{{^flags}}
+// A regular enum projects to an explicitly-stored raw-value struct newtype, not
+// a native Swift enum: a native `enum E: {{{underlying}}}` does not carry the ABI
+// layout of its raw type — `@frozen` freezes the compact representation Swift
+// chooses, and the raw type is only a `RawRepresentable` conversion, so a
+// two-case `enum E: UInt32` is one byte, not four, and the signature would pass
+// the wrong width to native code. The newtype stores the `value__` underlying
+// type directly, so it is the ABI-exact width of the C enum; its members are
+// named constants and it holds any ABI value (an undeclared or aliased one)
+// where a native enum would be the wrong size and trap.
+@frozen public struct {{{name}}}: Hashable, Sendable {
+    public var rawValue: {{{underlying}}}
+    @inlinable public init(rawValue: {{{underlying}}}) { self.rawValue = rawValue }
+{{#members}}
+    @_transparent public static var {{{name}}}: {{{owner}}} { {{{owner}}}(rawValue: {{{value}}}) }
+{{/members}}
+}
+{{/flags}}
+{{/enum}}
+{{#delegate}}
+{{#generic}}
+// A parameterised WinRT delegate, like a parameterised interface, has no static
+// IID: its IID is a per-instantiation PIID computed at runtime from the type
+// arguments, so no `@com(interface:)` is emitted — the runtime projection
+// supplies it. Its generic parameters are declared as the protocol's primary
+// associated types so the `Invoke` signature spells them by name.
+internal protocol {{{abi}}}<{{#generics}}{{{name}}}{{^last}}, {{/last}}{{/generics}}> {
+{{#generics}}
+    associatedtype {{{name}}}
+{{/generics}}
+    func Invoke({{#params}}_ {{{name}}}: {{{type}}}{{^last}}, {{/last}}{{/params}}){{#returns}} -> {{{.}}}{{/returns}}
+}
+
+// The public wrapper a signature spells (`Handler<T>`): a parameterised delegate
+// name names this struct, not the internal ABI protocol, so the wrapper must be
+// declared for the reference to resolve. It holds the ABI existential and
+// forwards `Invoke`, the same shape the generic interface arm gives a
+// parameterised interface — a blank requirement parameter forwards through its
+// synthesized `local` name so the call passes it by name.
+public struct {{{name}}}<{{#generics}}{{{name}}}{{^last}}, {{/last}}{{/generics}}> {
+    internal let base: any {{{abi}}}<{{#generics}}{{{name}}}{{^last}}, {{/last}}{{/generics}}>
+    public func Invoke({{#params}}_ {{{local}}}: {{{type}}}{{^last}}, {{/last}}{{/params}}){{#returns}} -> {{{.}}}{{/returns}} {
+        base.Invoke({{#params}}{{{local}}}{{^last}}, {{/last}}{{/params}})
+    }
+}
+{{/generic}}
+{{^generic}}
+// A WinRT delegate is a COM interface — IUnknown plus a single `Invoke` — so
+// `@com` generates the IUnknown-based vtable from this Invoke-only protocol,
+// the same ABI-faithful shape an interface projects, not a Swift closure.
+@com(interface: "{{{iid}}}")
+public protocol {{{name}}} {
+    func Invoke({{#params}}_ {{{name}}}: {{{type}}}{{^last}}, {{/last}}{{/params}}){{#returns}} -> {{{.}}}{{/returns}}
+}
+{{/generic}}
+{{/delegate}}