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.

Three metadata-shape fixes complete the erased shape:

  - `SignatureType.classification` now treats a `VAR`/`MVAR` generic type
    variable as a REFERENCE, so `abi(…)` erases a type-variable slot to the
    opaque interface pointer rather than spelling its declared name. The ABI
    protocol is non-generic and declares no associated type, so a requirement
    `-> Element` would name an undeclared type; the wrapper casts the typed
    value across the boundary as it does for any reference slot.

  - The base-ABI rewrite distinguishes a CLR arity backtick (a `` ` `` followed
    by a DIGIT, the raw `` IVector`1 `` spelling) from a Swift keyword-ESCAPING
    backtick, which `SANITIZE` wraps around a keyword base (`` `protocol` ``).
    Only the arity form marks a generic base to rewrite, so an escaped keyword
    base is inherited unchanged instead of becoming a broken `` `protocolABI` ``.

  - `bases.sql` resolves a TypeSpec-recorded base: a generic interface
    inheriting another (`IVector`1 : IIterable`1`) records the base through a
    `TypeSpec` GENERICINST row, which the plain `Interface_TypeRef`/`_TypeDef`
    arms miss. A new `GENERICBASE` scalar UDF (over `WinMD.base(decoding:)`)
    decodes the spec's signature to the base coded-index token; the view splits
    its tag (`BITAND(token, 3)`) and 1-based row (`token / 4`) to join the base
    `TypeRef`/`TypeDef` by `Id`, so the ABI rewrite emits `IIterableABI`.

Author: compnerd

Sources/WinMD/Signature.swift

@@ -525,3 +525,30 @@ extension Row where Schema == Metadata.Tables.PropertyDef {
     }
   }
 }
+
+// MARK: - TypeSpec generic base
+
+/// The `TypeDefOrRef` coded-index token naming the GENERIC BASE a `TypeSpec`
+/// GENERICINST signature instantiates — the row-linkable value the raw `bytes`
+/// of a `TypeSpec.Signature` `#Blob` carry — or `nil` when the signature is not
+/// a generic instantiation (its base is not a named type).
+///
+/// This is the escapable, value → value form the SQL adapter's `GENERICBASE`
+/// scalar function reads: a caller that has copied a `TypeSpec.Signature` blob
+/// out of the borrowed scan decodes it here, returning the base's `rawValue` so
+/// SQL can split its tag/row and join to the base `TypeRef`/`TypeDef` by `Id`.
+/// A WinRT generic interface inheriting another (`IVector`1 : IIterable`1`)
+/// records the base through a `TypeSpec`, so its `bases` row is otherwise
+/// empty; this recovers the base name.
+///
+/// A `TypeSpec` whose signature is not a `GENERICINST` over a named base — a
+/// bare array/pointer spec, or a malformed blob — yields `nil` rather than
+/// throwing, so the SQL join simply produces no base row for it.
+public func base(decoding bytes: Array<UInt8>) -> TypeDefOrRef? {
+  var decoder = SignatureDecoder(bytes.span.bytes)
+  guard let type = try? decoder.type(),
+      case let .instance(.named(_, reference), _) = type else {
+    return nil
+  }
+  return reference
+}

Sources/WinMDSynthesis/Decode.swift

@@ -195,8 +195,11 @@ extension SignatureType {
   /// or matrix classifies as its (recursively unwrapped) ELEMENT, so a byref or
   /// array of a class reference is itself a reference (its element erases),
   /// while a pointer or array of a value stays a value. A `VAR`/`MVAR` generic
-  /// variable stands for an as-yet-unknown argument and is conservatively a
-  /// value (its erased spelling falls through to `decode`).
+  /// variable is a REFERENCE: the ABI protocol is non-generic and declares no
+  /// associated type, so a type-variable slot cannot keep its declared name
+  /// (`Element`) — a requirement `-> Element` names an undeclared type. It
+  /// therefore erases to the opaque interface pointer, exactly as a `CLASS`
+  /// reference does, and the wrapper casts the typed value across the boundary.
   ///
   /// This is the classification half of the ABI-erasure keystone; `abi(…)`
   /// produces the matching erased spelling.
@@ -207,7 +210,7 @@ extension SignatureType {
     case .named(kind: .value, _), .primitive, .function:
       .value
     case .variable:
-      .value
+      .reference
     case let .instance(base, _):
       base.classification
     case let .modified(inner, _),

Sources/winmd-inspect/Database+SQL.swift

@@ -195,8 +195,17 @@ extension Session {
     // — and its `[.blob]` parameter contract, which the static type-check
     // validates a `GUID(...)` call against. `try!`: the name is a compile-time
     // constant and not a protected standard routine, so it never faults.
-    try! Routines.standard.registering("guid", returns: .text,
-                                       parameters: [.blob], Session.guid)
+    //
+    // `GENERICBASE` decodes a `TypeSpec.Signature` blob to the coded-index
+    // token of the generic base it instantiates — an `.integer` over one
+    // `.blob`, NULL when the spec is not a generic instantiation — so the
+    // `bases` view can join a `TypeSpec`-recorded base (a generic interface's
+    // generic base) to its `TypeRef`/`TypeDef` by splitting the token's tag and
+    // row.
+    try! Routines.standard
+        .registering("guid", returns: .text, parameters: [.blob], Session.guid)
+        .registering("genericbase", returns: .integer, parameters: [.blob],
+                     Session.genericbase)
   }
 
   /// `GUID(blob)` — the UUID a `GuidAttribute` `CustomAttribute` value blob
@@ -219,6 +228,32 @@ extension Session {
     guard let uuid = try? WinMD.iid(decoding: bytes) else { return .null }
     return .text("\(uuid)")
   }
+
+  /// `GENERICBASE(blob)` — the `TypeDefOrRef` coded-index token naming the
+  /// generic base a `TypeSpec.Signature` GENERICINST instantiates, as an
+  /// integer, or `NULL` when the blob is not a generic instantiation over a
+  /// named base.
+  ///
+  /// A pure per-row codec over the raw `TypeSpec.Signature` `#Blob`: the
+  /// `bases` view feeds it the signature of a `TypeSpec`-recorded interface
+  /// base (a WinRT generic interface inheriting another, `IVector`1 :
+  /// IIterable`1`) and splits the returned token — `tag = BITAND(token, 3)`,
+  /// `row = token / 4` — to join the base `TypeRef` (tag 1) or `TypeDef` (tag
+  /// 0) by its `Id`. A NULL argument propagates to NULL; a non-blob argument is
+  /// `SQLError.argument`; a non-generic (or malformed) spec yields NULL, so its
+  /// join produces no base.
+  private static func genericbase(_ arguments: Array<Value>)
+      throws(SQLError) -> Value {
+    guard arguments.count == 1 else {
+      throw .argument("GENERICBASE takes one argument")
+    }
+    if case .null = arguments[0] { return .null }
+    guard case let .blob(bytes) = arguments[0] else {
+      throw .argument("GENERICBASE requires a blob argument")
+    }
+    guard let base = WinMD.base(decoding: bytes) else { return .null }
+    return .integer(base.rawValue)
+  }
 }
 
 // MARK: - Table
@@ -764,19 +799,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 +818,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 +859,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/Queries/bases.sql

@@ -14,3 +14,28 @@ FROM
   JOIN TypeDef d ON i.Interface_TypeDef = d.Id
 WHERE
   i.Class = :parent
+UNION
+-- A generic interface's base is recorded through a TypeSpec (a GENERICINST
+-- signature) rather than a TypeRef/TypeDef, so join the TypeSpec, decode its
+-- signature to the base coded-index token (GENERICBASE), and resolve that token
+-- to the base's TypeName by splitting its tag (BITAND(token, 3)) and 1-based
+-- row (token / 4): tag 1 names a TypeRef, tag 0 a TypeDef.
+SELECT
+  b.TypeName AS base
+FROM
+  InterfaceImpl i
+  JOIN TypeSpec s ON i.Interface_TypeSpec = s.Id
+  JOIN TypeRef b ON b.Id = GENERICBASE(s.Signature) / 4
+WHERE
+  i.Class = :parent
+  AND BITAND(GENERICBASE(s.Signature), 3) = 1
+UNION
+SELECT
+  d.TypeName AS base
+FROM
+  InterfaceImpl i
+  JOIN TypeSpec s ON i.Interface_TypeSpec = s.Id
+  JOIN TypeDef d ON d.Id = GENERICBASE(s.Signature) / 4
+WHERE
+  i.Class = :parent
+  AND BITAND(GENERICBASE(s.Signature), 3) = 0

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}}
 }