winmd-inspect: render WinRT generic interfaces ABI-erased

The generic-interface rendering previously projected a generic ABI protocol
(`protocol Name<T…>` with `associatedtype`s) plus a wrapper forwarding own
methods — the shape-1 foundation, which the non-generic-closed-base wall made
a dead end for base inheritance. Pivot the rendering onto the ABI-erased shape
windows-rs draws, reusing the merged `SignatureType.abi(…)`/`classification`
keystone:

  - The ABI protocol is now NON-generic. Each method requirement reads every
    parameter/return through its ABI-erased spelling: a reference-typed slot
    (an interface, runtime class, delegate, generic-interface instantiation, or
    `System.Object`) is the opaque interface pointer, a value-typed slot keeps
    its own ABI. No generic parameters, no associated types.

  - The public generic `struct` wrapper `Name<T…>` keeps the typed Swift
    surface: each method takes/returns the decoded typed parameters and casts
    the typed value to the erased pointer (and the erased result back) as it
    forwards through `base` — `unsafeBitCast`, the text analogue of
    windows-rs's `transmute_copy` across the vtable. A value slot needs no cast
    (its typed and erased spellings coincide), so it forwards unchanged.

  - Base inheritance becomes trivial and is INCLUDED: a non-generic ABI
    protocol inherits its base's non-generic ABI protocol by plain protocol
    inheritance — a generic base inherits `<stripped>ABI` (no arguments, no
    `where`-constraints), a non-generic base (`IInspectable`) is inherited
    unchanged. The non-generic-closed-base wall cannot occur.

The `Database+SQL` decode layer gains erased-ABI (`abi(return:)`/
`abi(parameter:)`) and classification (`reference(return:)`/
`reference(parameter:)`) accessors beside the existing typed `decode(…)`, all
sharing the extracted signature-navigation. `Shell` composes the per-slot
erased/typed spellings and the forwarding cast into the render context; the
`com.mustache` `{{#generic}}` arm emits the erased protocol + casting wrapper.
The non-generic `{{^generic}}` path is byte-identical.

The generated Swift is swiftc-typecheck-verified for a simple generic
interface (erased/cast element return), a generic interface with a generic
base (plain non-generic ABI inheritance, wrapper casts), an out/interface-array
method (erased element under the pointer), and a keyword-named generic
parameter.

Author: compnerd

Sources/winmd-inspect/Database+SQL.swift

@@ -764,19 +764,17 @@ extension WinMD.Storage {
     return nil
   }
 
-  /// The decoded type spelling of the return of the `MethodDef` at 1-based
-  /// `method` `Id`, in `dialect`, or `nil` when the row or its signature
-  /// does not decode.
+  /// The `SignatureType` of the return of the `MethodDef` at 1-based `method`
+  /// `Id`, paired with a `Resolver` over the storage — or `nil` when the row or
+  /// its signature does not decode.
   ///
-  /// This is the signature-navigation the adapter once baked as the
-  /// `ReturnType` virtual column, relocated so the render can spell a return at
-  /// render time with a target `Dialect`: it opens the `MethodDef` row, decodes
-  /// its `prototype` signature, builds a `Resolver` over the storage, and
-  /// decodes the return. `nil` mirrors the old NULL — an absent row, an
-  /// undecodable signature, or an unresolvable one.
-  internal borrowing func decode(return method: Int,
-                                 generics: Array<String>? = nil,
-                                 in dialect: Dialect) -> String? {
+  /// This is the shared signature-navigation the render's return spellings
+  /// (`decode(return:)` for the typed surface, `abi(return:)` for the erased
+  /// ABI) build on: it opens the `MethodDef` row, decodes its `prototype`
+  /// signature, and builds the `Resolver`. `nil` mirrors the old NULL — an
+  /// absent row, an undecodable signature, or an unresolvable one.
+  private borrowing func returned(_ method: Int)
+      -> (type: SignatureType, resolver: Resolver)? {
     guard let table = opened("MethodDef") else { return nil }
     let cursor = WinMD.Cursor(copy self, table)
     guard let tuple = cursor[method - 1],
@@ -785,27 +783,24 @@ extension WinMD.Storage {
         let resolver = try? Resolver(of: signature, with: self) else {
       return nil
     }
-    return signature.returns.decode(generics: generics, with: resolver,
-                                    dialect: dialect)
+    return (signature.returns, resolver)
   }
 
-  /// The decoded type spelling of the `Param` at 1-based `parameter` `Id`, in
-  /// `dialect`, navigated through its owning method's signature — or `nil` when
-  /// it does not decode.
+  /// The `SignatureType` of the `Param` at 1-based `parameter` `Id`, navigated
+  /// through its owning method's signature, paired with a `Resolver` and the
+  /// parameter's own `Name` (the `System.Guid` `IID`/`CLSID` hint) — or `nil`
+  /// when it does not decode.
   ///
-  /// This is the signature-navigation the adapter once baked as the `ParamType`
-  /// virtual column, relocated so the render can spell a parameter at render
-  /// time. The `Param.Sequence` cell is the 1-based parameter position:
-  /// `Sequence == 0` is the return pseudo-parameter and `Sequence >
+  /// This is the shared signature-navigation the render's parameter spellings
+  /// (`decode(parameter:)` for the typed surface, `abi(parameter:)` for the
+  /// erased ABI) build on. The `Param.Sequence` cell is the 1-based parameter
+  /// position: `Sequence == 0` is the return pseudo-parameter and `Sequence >
   /// parameters.count` is out of range, both `nil`. The owning `MethodDef` is
   /// found through the `Param` list link — an owner of zero is no parent
   /// (malformed/partial metadata), so the parameter is unowned and yields `nil`
-  /// rather than indexing a negative row. The parameter's own `Name` is the
-  /// `System.Guid` `IID`/`CLSID` hint; for any other type the decoder ignores
-  /// it, so threading it is always safe.
-  internal borrowing func decode(parameter: Int,
-                                 generics: Array<String>? = nil,
-                                 for dialect: Dialect) -> String? {
+  /// rather than indexing a negative row.
+  private borrowing func parametered(_ parameter: Int)
+      -> (type: SignatureType, resolver: Resolver, name: String?)? {
     guard let table = opened("Param") else { return nil }
     let params = WinMD.Cursor(copy self, table)
     guard let param = params[parameter - 1],
@@ -829,8 +824,79 @@ extension WinMD.Storage {
       return nil
     }
     let name = param.ordinal(for: "Name").flatMap { try? param.string($0) }
-    return signature.parameters[position - 1]
-        .decode(parameter: name, generics: generics, with: resolver,
-                dialect: dialect)
+    return (signature.parameters[position - 1], resolver, name)
+  }
+
+  /// The typed type spelling of the return of the `MethodDef` at 1-based
+  /// `method` `Id`, in `dialect` — the wrapper's typed surface — or `nil` when
+  /// the row or its signature does not decode.
+  ///
+  /// This is the signature-navigation the adapter once baked as the
+  /// `ReturnType` virtual column, relocated so the render can spell a return at
+  /// render time with a target `Dialect`.
+  internal borrowing func decode(return method: Int,
+                                 generics: Array<String>? = nil,
+                                 in dialect: Dialect) -> String? {
+    returned(method).map {
+      $0.type.decode(generics: generics, with: $0.resolver, dialect: dialect)
+    }
+  }
+
+  /// The ABI-erased type spelling of the return of the `MethodDef` at 1-based
+  /// `method` `Id`, in `dialect` — the non-generic ABI protocol's return, a
+  /// reference erased to the opaque interface pointer — or `nil` when the row
+  /// or its signature does not decode.
+  internal borrowing func abi(return method: Int,
+                              generics: Array<String>? = nil,
+                              in dialect: Dialect) -> String? {
+    returned(method).map {
+      $0.type.abi(generics: generics, with: $0.resolver, dialect: dialect)
+    }
+  }
+
+  /// Whether the return of the `MethodDef` at 1-based `method` `Id` crosses the
+  /// ABI as an erased interface pointer (a reference) — so the wrapper casts
+  /// the erased result back to its typed spelling — or `nil` when the row does
+  /// not decode. A value return needs no cast.
+  internal borrowing func reference(return method: Int) -> Bool? {
+    returned(method).map { $0.type.classification == .reference }
+  }
+
+  /// The typed type spelling of the `Param` at 1-based `parameter` `Id`, in
+  /// `dialect`, navigated through its owning method's signature — the wrapper's
+  /// typed surface — or `nil` when it does not decode. The parameter's own
+  /// `Name` is the `System.Guid` `IID`/`CLSID` hint; for any other type the
+  /// decoder ignores it, so threading it is always safe.
+  ///
+  /// This is the signature-navigation the adapter once baked as the `ParamType`
+  /// virtual column, relocated so the render can spell a parameter at render
+  /// time.
+  internal borrowing func decode(parameter: Int,
+                                 generics: Array<String>? = nil,
+                                 for dialect: Dialect) -> String? {
+    parametered(parameter).map {
+      $0.type.decode(parameter: $0.name, generics: generics,
+                     with: $0.resolver, dialect: dialect)
+    }
+  }
+
+  /// The ABI-erased type spelling of the `Param` at 1-based `parameter` `Id`,
+  /// in `dialect` — the non-generic ABI protocol's parameter, a reference
+  /// erased to the opaque interface pointer — or `nil` when it does not decode.
+  internal borrowing func abi(parameter: Int,
+                              generics: Array<String>? = nil,
+                              for dialect: Dialect) -> String? {
+    parametered(parameter).map {
+      $0.type.abi(parameter: $0.name, generics: generics,
+                  with: $0.resolver, dialect: dialect)
+    }
+  }
+
+  /// Whether the `Param` at 1-based `parameter` `Id` crosses the ABI as an
+  /// erased interface pointer (a reference) — so the wrapper casts the typed
+  /// argument to the erased pointer before forwarding — or `nil` when it does
+  /// not decode. A value parameter needs no cast.
+  internal borrowing func reference(parameter: Int) -> Bool? {
+    parametered(parameter).map { $0.type.classification == .reference }
   }
 }

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

@@ -1,23 +1,28 @@
 {{! language: swift }}
 {{#generic}}
-// A WinRT 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 on the ABI protocol
-// or the generic wrapper — the runtime projection supplies it.
-internal protocol {{{abi}}}<{{#generics}}{{{name}}}{{^last}}, {{/last}}{{/generics}}>{{#base}}: {{{.}}}{{/base}} {
-{{#generics}}
-    associatedtype {{{name}}}
-{{/generics}}
+// A WinRT parameterised interface erases to a NON-generic ABI protocol:
+// every reference-typed slot crosses the vtable as the opaque interface
+// pointer, so the protocol carries no generic parameters and no
+// associated types, and a generic base is inherited by PLAIN protocol
+// inheritance. It has no static IID: a parameterised interface's IID is a
+// per-instantiation PIID computed at runtime from the type arguments, so
+// no `@com(interface:)` is emitted on the ABI protocol or the wrapper —
+// the runtime projection supplies it.
+internal protocol {{{abi}}}{{#base}}: {{{.}}}{{/base}} {
 {{#methods}}
     func {{{name}}}({{#params}}_ {{{name}}}: {{{type}}}{{^last}}, {{/last}}{{/params}}){{#returns}} -> {{{.}}}{{/returns}}
 {{/methods}}
 }
 
+// The public generic wrapper keeps the typed Swift surface: each method
+// takes and returns the decoded typed parameters, casting between the
+// typed value and the erased interface pointer when it forwards through
+// `base` to the non-generic ABI protocol.
 public struct {{{name}}}<{{#generics}}{{{name}}}{{^last}}, {{/last}}{{/generics}}> {
-    internal let base: any {{{abi}}}<{{#generics}}{{{name}}}{{^last}}, {{/last}}{{/generics}}>
+    internal let base: any {{{abi}}}
 {{#methods}}
-    public func {{{name}}}({{#params}}_ {{{local}}}: {{{type}}}{{^last}}, {{/last}}{{/params}}){{#returns}} -> {{{.}}}{{/returns}} {
-        base.{{{name}}}({{#params}}{{{local}}}{{^last}}, {{/last}}{{/params}})
+    public func {{{name}}}({{#params}}_ {{{local}}}: {{{typed}}}{{^last}}, {{/last}}{{/params}}){{#typed}} -> {{{.}}}{{/typed}} {
+        {{{call}}}
     }
 {{/methods}}
 }