peachsim 0.1.1644 → 0.1.1653

package/src/swift-objc-import.ts

@@ -0,0 +1,769 @@
+import { createHash } from 'node:crypto'
+import type { GraphSymbol, SymbolFragment, SymbolGraph } from './swift-standin-emit'
+
+export interface SwiftObjCImportOptions {
+  module: string
+  /** original headers, also used by clang to apply their attributes and ownership. */
+  headers: readonly string[]
+  /** exact objective-c source classes, excluding classes exported from swift. */
+  classes: readonly string[]
+  /** clang -ast-dump=json of those headers, with their original compile settings. */
+  clangAST: unknown
+  /** exact exported swift identities, including explicit @objc names. */
+  peerTypes?: ReadonlyMap<string, string>
+}
+
+export interface SwiftObjCImport {
+  swift: string
+  objc: string
+  registration: string
+  registerFunction: string
+  classes: { name: string; nativeName: string }[]
+  /** swift type -> original objective-c class, for the swift exporter. */
+  types: ReadonlyMap<string, string>
+}
+
+export class SwiftObjCImportError extends Error {}
+
+type Node = Record<string, unknown>
+const record = (value: unknown): value is Node =>
+  typeof value === 'object' && value !== null && !Array.isArray(value)
+const nodes = (value: unknown): Node[] => {
+  if (!Array.isArray(value)) return []
+  const entries: unknown[] = value
+  return entries.filter(record)
+}
+const fragments = (value: unknown): SymbolFragment[] => {
+  if (!Array.isArray(value)) return []
+  const entries: unknown[] = value
+  return entries.filter(
+    (entry): entry is SymbolFragment =>
+      record(entry) &&
+      typeof entry.kind === 'string' &&
+      typeof entry.spelling === 'string' &&
+      (entry.preciseIdentifier === undefined ||
+        typeof entry.preciseIdentifier === 'string'),
+  )
+}
+const text = (parts: readonly SymbolFragment[]) => parts.map((p) => p.spelling).join('')
+const nativeClass = (id: string) => /^c:objc\(cs\)([A-Za-z_]\w*)$/.exec(id)?.[1]
+const identifier = (name: string) => /^[A-Za-z_]\w*$/.test(name)
+const swiftName = (name: string) => `\`${name}\``
+const hash = (value: string) =>
+  createHash('sha256').update(value).digest('hex').slice(0, 24)
+
+/** private implementation classes keep their original metadata and bodies.
+ * their opaque adapters join the same registry without importing private APIs. */
+export async function swiftObjCPrivateImports(
+  asts: AsyncIterable<string>,
+  registeredClasses: readonly string[],
+): Promise<string> {
+  const registered = new Set(registeredClasses)
+  const implemented = new Set<string>()
+  const adapters: { name: string; nativeName: string }[] = []
+  for await (const ast of asts) {
+    if (!/^TranslationUnitDecl\b/.test(ast))
+      throw new SwiftObjCImportError('expected original Objective-C implementation AST')
+    const declarations = new Map<string, { parent?: string; renamed: boolean }>()
+    const implementations: string[] = []
+    let owner: { name: string; depth: number } | undefined
+    // textual declarations avoid the json dumper's objective-c method mangling.
+    for (const line of ast.split('\n')) {
+      const node = /^([| `-]*)(\w+)\b(.*)$/.exec(line)
+      if (!node) continue
+      const depth = node[1]!.length
+      if (owner && depth <= owner.depth) owner = undefined
+      const kind = node[2]
+      const detail = node[3]!
+      if (kind === 'ObjCInterfaceDecl' || kind === 'ObjCImplementationDecl') {
+        const name = /\s([A-Za-z_]\w*)$/.exec(detail)?.[1]
+        if (!name)
+          throw new SwiftObjCImportError(
+            'unsupported Objective-C implementation identity',
+          )
+        if (kind === 'ObjCImplementationDecl') implementations.push(name)
+        else {
+          if (!declarations.has(name)) declarations.set(name, { renamed: false })
+          owner = { name, depth }
+        }
+      } else if (owner && depth === owner.depth + 2) {
+        const declaration = declarations.get(owner.name)!
+        if (kind === 'super') {
+          const parent = /^ ObjCInterface 0x[\da-f]+ '([A-Za-z_]\w*)'$/.exec(detail)?.[1]
+          if (!parent)
+            throw new SwiftObjCImportError('unsupported Objective-C superclass identity')
+          declaration.parent = parent
+        }
+        if (kind === 'ObjCRuntimeNameAttr') declaration.renamed = true
+      }
+    }
+    for (const nativeName of implementations) {
+      function fail(reason: string): never {
+        throw new SwiftObjCImportError(
+          `Objective-C implementation ${nativeName}: ${reason}`,
+        )
+      }
+      if (implemented.has(nativeName)) fail('duplicate original class implementation')
+      implemented.add(nativeName)
+      if (registered.has(nativeName)) continue
+      const declaration = declarations.get(nativeName)
+      if (!declaration || declaration.parent !== 'NSObject')
+        fail('private superclass requires a qualified foreign proxy hierarchy')
+      if (declaration.renamed) fail('private runtime class renaming is unqualified')
+      adapters.push({
+        name: `__PeachObjCPrivate_${hash(nativeName)}`,
+        nativeName,
+      })
+    }
+  }
+  adapters.sort((left, right) => left.nativeName.localeCompare(right.nativeName))
+  return [
+    '',
+    ...adapters.map(
+      (adapter) => `private final class ${adapter.name}: PeachObjC._ObjCForeignObject {}`,
+    ),
+    '@_cdecl("_peach_objc_register_private_implementations")',
+    'public func __peachRegisterPrivateImplementations() {',
+    ...adapters.map(
+      (adapter) =>
+        `  PeachObjC._objcRegisterForeignClass(${adapter.name}.self, nativeName: ${JSON.stringify(adapter.nativeName)})`,
+    ),
+    '}',
+    '',
+  ].join('\n')
+}
+
+interface ImportType {
+  swift: string
+  abi: string
+  c: string
+  object: boolean
+  optional: boolean
+  native?: string
+}
+
+/** emit calls to original clang implementations, never replacement method bodies.
+ * swift's symbol graph supplies importer names and types; clang's original AST
+ * proves membership and the construction boundary before any source is returned. */
+export function swiftObjCImports(
+  graphs: readonly SymbolGraph[],
+  options: SwiftObjCImportOptions,
+): SwiftObjCImport {
+  function fail(where: string, reason: string): never {
+    throw new SwiftObjCImportError(
+      `Objective-C import ${options.module}.${where}: ${reason}`,
+    )
+  }
+  if (!identifier(options.module)) fail('module', 'invalid module identifier')
+  if (!options.headers.length) fail('headers', 'original headers are required')
+  for (const header of options.headers)
+    if (!header || /[\r\n]/.test(header) || header.includes('\0'))
+      fail('headers', 'invalid header path')
+  const selected = new Set(options.classes)
+  if (selected.size !== options.classes.length)
+    fail('classes', 'require distinct original Objective-C class names')
+  for (const name of selected)
+    if (!identifier(name)) fail(name, 'invalid Objective-C class name')
+
+  const declarations = new Map<string, Node>()
+  const tails = new Map<string, string>()
+  const categories = new Map<string, Node[]>()
+  const functions = new Map<string, Node[]>()
+  const typedefs = new Map<string, string>()
+  const visit = (node: unknown): void => {
+    if (!record(node)) return
+    if (
+      node.kind === 'ObjCInterfaceDecl' &&
+      typeof node.name === 'string' &&
+      selected.has(node.name)
+    ) {
+      // clang repeats the superclass throughout a redeclaration chain.
+      // retain its member-bearing definition and reject invalid or separate chains.
+      if (record(node.super) && node.super.name !== undefined) {
+        const chain = declarations.get(node.name)
+        if (
+          node.isInvalid === true ||
+          (chain && node.previousDecl !== tails.get(node.name))
+        )
+          fail(node.name, 'duplicate interface definitions')
+        tails.set(node.name, String(node.id))
+        if (!chain || nodes(node.inner).length) declarations.set(node.name, node)
+      }
+    }
+    if (node.kind === 'ObjCCategoryDecl' && record(node.interface)) {
+      const name = node.interface.name
+      if (typeof name === 'string')
+        categories.set(name, [...(categories.get(name) ?? []), node])
+    }
+    if (node.kind === 'FunctionDecl' && typeof node.name === 'string')
+      functions.set(node.name, [...(functions.get(node.name) ?? []), node])
+    if (
+      node.kind === 'TypedefDecl' &&
+      typeof node.name === 'string' &&
+      record(node.type)
+    ) {
+      const canonical = node.type.desugaredQualType ?? node.type.qualType
+      if (typeof canonical === 'string') typedefs.set(node.name, canonical)
+    }
+    for (const child of nodes(node.inner)) visit(child)
+  }
+  if (!record(options.clangAST) || options.clangAST.kind !== 'TranslationUnitDecl')
+    fail('declarations', 'expected a complete Clang translation unit AST')
+  visit(options.clangAST)
+
+  const symbols = new Map<string, GraphSymbol>()
+  for (const graph of graphs) {
+    if (graph.module.name !== options.module)
+      fail('declarations', `symbol graph belongs to ${graph.module.name}`)
+    for (const symbol of graph.symbols) {
+      const previous = symbols.get(symbol.identifier.precise)
+      if (previous && JSON.stringify(previous) !== JSON.stringify(symbol))
+        fail(symbol.identifier.precise, 'ambiguous imported declaration')
+      symbols.set(symbol.identifier.precise, symbol)
+    }
+  }
+  const classes: SwiftObjCImport['classes'] = []
+  const types = new Map<string, string>([['NSObject', 'NSObject']])
+  const names = new Map<string, string>([['NSObject', 'NSObject']])
+  for (const [name, nativeName] of options.peerTypes ?? []) {
+    if (!identifier(name) || !identifier(nativeName))
+      fail('peerTypes', 'invalid exported Swift identity')
+    if (names.has(nativeName) || types.has(name) || selected.has(nativeName))
+      fail(name, 'duplicate canonical object identity')
+    names.set(nativeName, name)
+    types.set(name, nativeName)
+  }
+  for (const nativeName of [...selected].sort()) {
+    const symbol = symbols.get(`c:objc(cs)${nativeName}`)
+    const name = symbol?.pathComponents[0]
+    if (!symbol || symbol.kind.identifier !== 'swift.class' || !name || !identifier(name))
+      fail(nativeName, 'missing Swift-imported class declaration')
+    if (text(symbol.declarationFragments ?? []).trim() !== `class ${name}`)
+      fail(nativeName, 'generic, restricted or attributed classes are unqualified')
+    if (symbol.pathComponents.length !== 1 || types.has(name))
+      fail(nativeName, 'nested or duplicate Swift class identity')
+    if (symbol.availability?.length) fail(nativeName, 'class availability is unqualified')
+    if (!declarations.has(nativeName))
+      fail(nativeName, 'missing original Clang interface')
+    names.set(nativeName, name)
+    types.set(name, nativeName)
+    classes.push({ name, nativeName })
+  }
+
+  const type = (parts: readonly SymbolFragment[], where: string): ImportType => {
+    const written = text(parts).trim()
+    const optional = /[?!]$/.test(written)
+    const spelling = optional ? written.slice(0, -1) : written
+    const primitive: Record<string, string> = {
+      Void: 'void',
+      '()': 'void',
+      Bool: '_Bool',
+      Int: 'intptr_t',
+      UInt: 'uintptr_t',
+      Int8: 'int8_t',
+      UInt8: 'uint8_t',
+      Int16: 'int16_t',
+      UInt16: 'uint16_t',
+      Int32: 'int32_t',
+      UInt32: 'uint32_t',
+      Int64: 'int64_t',
+      UInt64: 'uint64_t',
+      Float: 'float',
+      Double: 'double',
+    }
+    if (
+      !optional &&
+      primitive[written] &&
+      !parts.some(
+        (part) =>
+          part.preciseIdentifier?.startsWith('c:') ||
+          (part.preciseIdentifier &&
+            symbols.get(part.preciseIdentifier)?.kind.identifier === 'swift.class'),
+      )
+    )
+      return {
+        swift: `Swift.${written === '()' ? 'Void' : written}`,
+        abi: `Swift.${written === '()' ? 'Void' : written}`,
+        c: primitive[written]!,
+        object: false,
+        optional: false,
+      }
+    const identifiers = parts.filter((part) => part.kind === 'typeIdentifier')
+    const id = identifiers.length === 1 ? identifiers[0]?.preciseIdentifier : undefined
+    const native = id && nativeClass(id)
+    const swiftClass = id ? symbols.get(id) : undefined
+    const resolved = native
+      ? names.get(native)
+      : swiftClass?.kind.identifier === 'swift.class' &&
+          swiftClass.pathComponents.length === 1 &&
+          swiftClass.pathComponents[0] === spelling &&
+          types.has(spelling)
+        ? spelling
+        : undefined
+    if (
+      !resolved ||
+      identifiers[0]?.spelling !== spelling ||
+      (spelling !== resolved && spelling !== native)
+    )
+      return fail(
+        where,
+        `unsupported imported type ${written}; canonical adapter and ABI are unqualified`,
+      )
+    return {
+      native: types.get(resolved)!,
+      swift: `${swiftName(resolved)}${optional ? written.slice(-1) : ''}`,
+      abi: 'Swift.UnsafeMutableRawPointer?',
+      c: 'void *',
+      object: true,
+      optional,
+    }
+  }
+
+  const canonical = (written: string): string => {
+    const seen = new Set<string>()
+    while (typedefs.has(written) && !seen.has(written)) {
+      seen.add(written)
+      written = typedefs.get(written)!
+    }
+    return written
+      .replace(/\bconst\b/g, '')
+      .replace(/\s+/g, ' ')
+      .trim()
+  }
+  const scalarTypes: Record<string, readonly string[]> = {
+    'Swift.Void': ['void'],
+    'Swift.Bool': ['_Bool', 'bool'],
+    'Swift.Int': ['long'],
+    'Swift.UInt': ['unsigned long'],
+    'Swift.Int8': ['signed char', 'char'],
+    'Swift.UInt8': ['unsigned char'],
+    'Swift.Int16': ['short'],
+    'Swift.UInt16': ['unsigned short'],
+    'Swift.Int32': ['int'],
+    'Swift.UInt32': ['unsigned int'],
+    'Swift.Int64': ['long long'],
+    'Swift.UInt64': ['unsigned long long'],
+    'Swift.Float': ['float'],
+    'Swift.Double': ['double'],
+  }
+
+  const checkClangType = (imported: ImportType, declaration: unknown, where: string) => {
+    if (!record(declaration) || typeof declaration.qualType !== 'string')
+      fail(where, 'missing original Clang type')
+    if (!imported.object) {
+      const original =
+        typeof declaration.desugaredQualType === 'string'
+          ? declaration.desugaredQualType
+          : declaration.qualType
+      if (!scalarTypes[imported.swift]?.includes(canonical(original)))
+        fail(where, 'original C scalar type differs from imported signature')
+      return
+    }
+    const canonicalType =
+      typeof declaration.desugaredQualType === 'string'
+        ? declaration.desugaredQualType
+        : declaration.qualType
+    const normalized = canonicalType
+      .replace(
+        /\b(?:_Nonnull|_Nullable|_Null_unspecified|__strong|__weak|__unsafe_unretained|const)\b/g,
+        '',
+      )
+      .replace(/\s+/g, '')
+      .trim()
+    if (normalized !== `${imported.native}*`)
+      fail(
+        where,
+        `Clang object type ${canonicalType} differs from imported ${imported.swift}`,
+      )
+  }
+  const membersByClass = new Map<string, GraphSymbol[]>()
+  for (const symbol of symbols.values()) {
+    const owner = /^c:objc\(cs\)([A-Za-z_]\w*)\(/.exec(symbol.identifier.precise)?.[1]
+    if (owner && selected.has(owner)) {
+      const members = membersByClass.get(owner)
+      if (members) members.push(symbol)
+      else membersByClass.set(owner, [symbol])
+    }
+  }
+
+  const external: string[] = []
+  const bodies = new Map<string, string[]>()
+  const objc = [
+    '#include <stdint.h>',
+    ...options.headers.map((header) => `#import ${JSON.stringify(header)}`),
+    '',
+  ]
+  const thunk = (
+    identity: string,
+    result: ImportType,
+    parameters: { name: string; type: ImportType }[],
+    receiver: string | null,
+    expression: string,
+  ) => {
+    const name = `_peach_objc_import_${hash(`${options.module}:${identity}`)}`
+    const cArguments = parameters.map((p) => `${p.type.c} ${p.name}`)
+    const swiftArguments = parameters.map((p) => `_ ${p.name}: ${p.type.abi}`)
+    if (receiver) {
+      cArguments.unshift('void * _receiver')
+      swiftArguments.unshift('_ _receiver: Swift.UnsafeMutableRawPointer')
+    }
+    external.push(
+      `@_extern(c, ${JSON.stringify(name)}) private func ${name}(${swiftArguments.join(', ')}) -> ${result.abi}`,
+    )
+    objc.push(`${result.c} ${name}(${cArguments.join(', ') || 'void'}) {`)
+    if (receiver)
+      objc.push(`  ${receiver} * _object = (__bridge ${receiver} *)_receiver;`)
+    objc.push(
+      result.object
+        ? `  return (__bridge_retained void *)(${expression});`
+        : result.c === 'void'
+          ? `  ${expression};`
+          : `  return ${expression};`,
+      '}',
+      '',
+    )
+    return name
+  }
+  const raw: ImportType = {
+    swift: 'Swift.UnsafeMutableRawPointer?',
+    abi: 'Swift.UnsafeMutableRawPointer?',
+    c: 'void *',
+    object: true,
+    optional: true,
+  }
+  const voidType = type([{ kind: 'typeIdentifier', spelling: 'Void' }], 'Void')
+  const call = (
+    name: string,
+    result: ImportType,
+    parameters: { name: string; type: ImportType }[],
+    instance: boolean,
+    owner: string,
+  ): string => {
+    const lines: string[] = instance
+      ? []
+      : [
+          `precondition(self == ${swiftName(owner)}.self, "Swift subclass dispatch is unqualified")`,
+        ]
+    const args: string[] = []
+    if (instance) {
+      lines.push(
+        'let _receiver = PeachObjC._objcRetainedPeer(self)',
+        'defer { PeachObjC._objcReleasePeer(_receiver) }',
+      )
+      args.push('_receiver')
+    }
+    for (const parameter of parameters) {
+      const value = swiftName(parameter.name)
+      if (parameter.type.object) {
+        lines.push(
+          `let _${parameter.name} = ${parameter.type.optional ? `${value}.map { PeachObjC._objcRetainedPeer($0) }` : `PeachObjC._objcRetainedPeer(${value})`}`,
+          `defer { ${parameter.type.optional ? `if let _${parameter.name} { PeachObjC._objcReleasePeer(_${parameter.name}) }` : `PeachObjC._objcReleasePeer(_${parameter.name})`} }`,
+        )
+        args.push(`_${parameter.name}`)
+      } else args.push(value)
+    }
+    const invocation = `${name}(${args.join(', ')})`
+    if (result.object) {
+      lines.push(`let _result = ${invocation}`)
+      if (result.optional) lines.push('guard let _result else { return nil }')
+      else
+        lines.push(
+          'precondition(_result != nil, "Objective-C nonnull result was nil")',
+          'let _value = _result!',
+        )
+      const pointer = result.optional ? '_result' : '_value'
+      lines.push(
+        `defer { PeachObjC._objcReleasePeer(${pointer}) }`,
+        `guard let _object = PeachObjC._objcObjectFromPeer(${pointer}) as? ${result.swift.replace(/[?!]$/, '')} else { preconditionFailure("Objective-C result type mismatch") }`,
+        'return _object',
+      )
+    } else lines.push(`${result.c === 'void' ? '' : 'return '}${invocation}`)
+    return lines.join('; ')
+  }
+
+  const signature = (symbol: GraphSymbol, decl: Node, returnType: unknown) => {
+    const usr = symbol.identifier.precise
+    const importedSignature = symbol.functionSignature
+    if (!importedSignature) fail(usr, 'missing imported function signature')
+    const parameterNodes = nodes(Reflect.get(importedSignature, 'parameters'))
+    const clangParameters = nodes(decl.inner).filter((n) => n.kind === 'ParmVarDecl')
+    if (parameterNodes.length !== clangParameters.length)
+      fail(usr, 'Swift and Clang parameter counts differ')
+    const labels = (symbol.declarationFragments ?? [])
+      .filter((p) => p.kind === 'externalParam')
+      .map((p) => p.spelling)
+    const parameters = parameterNodes.map((p, index) => {
+      const pparts = fragments(p.declarationFragments)
+      const colon = pparts.findIndex(
+        (p) => p.kind === 'text' && /^:\s*$/.test(p.spelling),
+      )
+      if (colon < 0) fail(usr, 'missing imported parameter type')
+      const imported = type(pparts.slice(colon + 1), usr)
+      checkClangType(imported, clangParameters[index]?.type, usr)
+      return { name: `argument${index}`, type: imported }
+    })
+    if (labels.length !== parameters.length || labels.some((label) => !identifier(label)))
+      fail(usr, 'missing imported argument labels')
+    const result = type(
+      importedSignature.returns ?? [{ kind: 'text', spelling: 'Void' }],
+      usr,
+    )
+    checkClangType(result, returnType, usr)
+    const argumentsSwift = parameters
+      .map(
+        (p, index) =>
+          `${labels[index] === '_' ? '_' : swiftName(labels[index]!)} ${swiftName(p.name)}: ${p.type.swift}`,
+      )
+      .join(', ')
+    return { parameters, result, argumentsSwift }
+  }
+
+  for (const identity of classes) {
+    const { name, nativeName } = identity
+    const declaration = declarations.get(nativeName)!
+    const parent = record(declaration.super) ? declaration.super.name : undefined
+    if (parent !== 'NSObject')
+      fail(nativeName, 'superclass requires a qualified foreign proxy hierarchy')
+    if (nodes(declaration.protocols).some((p) => p.name !== 'NSObject'))
+      fail(nativeName, 'protocol conformances require qualified witnesses')
+    const members = [declaration, ...(categories.get(nativeName) ?? [])].flatMap((n) =>
+      nodes(n.inner),
+    )
+    for (const member of members) {
+      if (
+        member.kind === 'ObjCMethodDecl' &&
+        typeof member.name === 'string' &&
+        (/^init(?:$|[^a-z])/.test(member.name.replace(/^_+/, '')) ||
+          nodes(member.inner).some(
+            (attribute) =>
+              attribute.kind === 'NSConsumesSelfAttr' ||
+              attribute.kind === 'ObjCDesignatedInitializerAttr',
+          ))
+      )
+        fail(
+          `${nativeName}.${member.name}`,
+          'explicit or designated initialization is unqualified',
+        )
+      if (member.variadic === true)
+        fail(`${nativeName}.${member.name}`, 'variadic methods are unqualified')
+    }
+    const constructor = thunk(
+      `${nativeName}:new`,
+      raw,
+      [],
+      null,
+      `[[${nativeName} alloc] init]`,
+    )
+    const body = [
+      `public required init(_objcRetained: Swift.UnsafeMutableRawPointer) { precondition(Self.self == ${swiftName(name)}.self, "Swift subclass construction is unqualified"); super.init(_objcRetained: _objcRetained) }`,
+      `public init() { precondition(Self.self == ${swiftName(name)}.self, "Swift subclass construction is unqualified"); super.init(_objcRetained: ${constructor}()!) }`,
+    ]
+    bodies.set(name, body)
+    const prefix = `c:objc(cs)${nativeName}`
+    for (const symbol of membersByClass.get(nativeName) ?? []) {
+      const usr = symbol.identifier.precise
+      if (!usr.startsWith(`${prefix}(`)) continue
+      const match = /^\((im|cm|py|cpy)\)([A-Za-z_]\w*(?::[A-Za-z_]\w*)*:?)$/.exec(
+        usr.slice(prefix.length),
+      )
+      if (!match) fail(usr, 'unsupported Objective-C member identity')
+      const kind = match[1]!
+      const selector = match[2]!
+      const property = kind === 'py' || kind === 'cpy'
+      const instance = kind === 'im' || kind === 'py'
+      const decl = members.find(
+        (m) =>
+          m.kind === (property ? 'ObjCPropertyDecl' : 'ObjCMethodDecl') &&
+          m.name === selector &&
+          (property ? (m.class !== true) === instance : m.instance === instance),
+      )
+      if (!decl) fail(usr, 'member absent from original Clang interface')
+      const parts = symbol.declarationFragments ?? []
+      const written = text(parts)
+      if (
+        symbol.availability?.length ||
+        /@|\b(?:optional|nonisolated|isolated|async|throws|rethrows)\b/.test(written)
+      )
+        fail(usr, 'availability and asynchronous or throwing imports are unqualified')
+      if (
+        nodes(decl.inner).some((a) =>
+          /^(?:Unavailable|SwiftPrivate|SwiftAsync|SwiftError|ObjCRequiresSuper|NSConsumesSelf)Attr$/.test(
+            String(a.kind),
+          ),
+        )
+      )
+        fail(usr, 'member attributes require a qualified importer path')
+      const receiver = instance ? '_object' : nativeName
+      const access = symbol.accessLevel === 'open' ? 'open' : 'public'
+      const memberName = parts.find((part) => part.kind === 'identifier')?.spelling
+      if (!memberName || !identifier(memberName))
+        fail(usr, 'missing imported member name')
+      if (property) {
+        const colon = parts.findIndex(
+          (p) => p.kind === 'text' && /^:\s*$/.test(p.spelling),
+        )
+        const end = parts.findIndex(
+          (p, index) => index > colon && p.spelling.includes('{'),
+        )
+        if (colon < 0 || end < 0) fail(usr, 'missing imported property type or accessors')
+        const last = parts[end]!
+        const result = type(
+          [
+            ...parts.slice(colon + 1, end),
+            {
+              ...last,
+              spelling: last.spelling.slice(0, last.spelling.indexOf('{')),
+            },
+          ],
+          usr,
+        )
+        checkClangType(result, decl.type, usr)
+        const getter = thunk(
+          `${usr}:get`,
+          result,
+          [],
+          instance ? nativeName : null,
+          `${receiver}.${selector}`,
+        )
+        const writable = parts.some((p) => p.kind === 'keyword' && p.spelling === 'set')
+        if (writable !== (decl.readonly !== true))
+          fail(usr, 'property mutability differs from Clang')
+        const setters: string[] = []
+        if (writable) {
+          const parameters = [{ name: 'newValue', type: result }]
+          const setter = thunk(
+            `${usr}:set`,
+            voidType,
+            parameters,
+            instance ? nativeName : null,
+            `${receiver}.${selector} = ${result.object ? '(__bridge id)newValue' : 'newValue'}`,
+          )
+          setters.push(`set { ${call(setter, voidType, parameters, instance, name)} }`)
+        }
+        body.push(
+          `${access} ${instance ? '' : 'class '}var ${swiftName(memberName)}: ${result.swift} { get { ${call(getter, result, [], instance, name)} } ${setters.join(' ')} }`,
+        )
+        continue
+      }
+      if (symbol.kind.identifier !== (instance ? 'swift.method' : 'swift.type.method'))
+        fail(usr, 'initializer or synthesized importer member is unqualified')
+      const { parameters, result, argumentsSwift } = signature(
+        symbol,
+        decl,
+        decl.returnType,
+      )
+      const components = selector.split(':')
+      if ((selector.match(/:/g) ?? []).length !== parameters.length)
+        fail(usr, 'selector and parameter counts differ')
+      const message = parameters.length
+        ? parameters
+            .map(
+              (p, index) =>
+                `${components[index]}:${p.type.object ? `(__bridge id)${p.name}` : p.name}`,
+            )
+            .join(' ')
+        : selector
+      const functionName = thunk(
+        usr,
+        result,
+        parameters,
+        instance ? nativeName : null,
+        `[${receiver} ${message}]`,
+      )
+      body.push(
+        `${access} ${instance ? '' : 'class '}func ${swiftName(memberName)}(${argumentsSwift}) -> ${result.swift} { ${call(functionName, result, parameters, instance, name)} }`,
+      )
+    }
+  }
+
+  const importedFunctions: string[] = []
+  for (const symbol of symbols.values()) {
+    if (symbol.kind.identifier !== 'swift.func') continue
+    const usr = symbol.identifier.precise
+    const native = /^c:@F@([A-Za-z_]\w*)$/.exec(usr)?.[1]
+    const parts = symbol.declarationFragments ?? []
+    const name = parts.find((p) => p.kind === 'identifier')?.spelling
+    if (!native || !name || !identifier(name) || symbol.pathComponents.length !== 1)
+      fail(usr, 'only global external C functions are qualified')
+    if (
+      symbol.availability?.length ||
+      /@|\b(?:async|throws|rethrows)\b/.test(text(parts))
+    )
+      fail(usr, 'attributed or asynchronous C functions are unqualified')
+    const original = functions.get(native)
+    if (!original?.length) fail(usr, 'function absent from original Clang declarations')
+    for (const decl of original) {
+      if (
+        decl.variadic ||
+        decl.inline ||
+        decl.storageClass === 'static' ||
+        nodes(decl.inner).some(
+          (n) =>
+            n.kind === 'CompoundStmt' ||
+            (String(n.kind).endsWith('Attr') && n.kind !== 'SwiftNameAttr'),
+        )
+      )
+        fail(usr, 'C function linkage, body or attributes are unqualified')
+      // Apple object symbols carry a leading underscore; the C source name is
+      // target independent. custom assembler names require separate qualification.
+      if (decl.mangledName !== native && decl.mangledName !== `_${native}`)
+        fail(usr, 'C assembler symbol renaming is unqualified')
+    }
+    const decl = original[0]!
+    if (!record(decl.type) || typeof decl.type.qualType !== 'string')
+      fail(usr, 'missing original C function type')
+    const clangFunctionType = decl.type.qualType
+    if (original.some((d) => !record(d.type) || d.type.qualType !== clangFunctionType))
+      fail(usr, 'conflicting original C function types')
+    const returnSpelling = /^(.+?)\s*\([^()]*\)$/.exec(clangFunctionType)?.[1]?.trim()
+    if (!returnSpelling) fail(usr, 'C function result is unqualified')
+    const { parameters, result, argumentsSwift } = signature(symbol, decl, {
+      qualType: returnSpelling,
+    })
+    if (result.object || parameters.some((p) => p.type.object))
+      fail(usr, 'only scalar C function signatures are qualified')
+    const local = `_peach_c_import_${hash(`${options.module}:${usr}`)}`
+    external.push(
+      `@_extern(c, ${JSON.stringify(native)}) private func ${local}(${parameters.map((p) => `_ ${p.name}: ${p.type.swift}`).join(', ')}) -> ${result.swift}`,
+    )
+    importedFunctions.push(
+      `public func ${swiftName(name)}(${argumentsSwift}) -> ${result.swift} { ${result.c === 'void' ? '' : 'return '}${local}(${parameters.map((p) => swiftName(p.name)).join(', ')}) }`,
+    )
+  }
+  if (!classes.length && !importedFunctions.length)
+    fail('declarations', 'no represented original Objective-C classes or C functions')
+
+  const registerFunction = `_peachRegisterObjCImports_${hash(options.module)}`
+  const registration = [
+    ...(classes.length ? ['import PeachObjC'] : []),
+    `public func ${registerFunction}() {`,
+    ...classes.map(
+      (c) =>
+        `  PeachObjC._objcRegisterForeignClass(${swiftName(c.name)}.self, nativeName: ${JSON.stringify(c.nativeName)})`,
+    ),
+    '}',
+    '',
+  ].join('\n')
+  const swift = [
+    ...(classes.length ? ['import Foundation', 'import PeachObjC'] : []),
+    '',
+    ...external,
+    '',
+    ...importedFunctions,
+    '',
+    ...classes.flatMap((c) => [
+      `open class ${swiftName(c.name)}: PeachObjC._ObjCForeignObject {`,
+      ...bodies.get(c.name)!.map((line) => `  ${line}`),
+      '}',
+      '',
+    ]),
+  ].join('\n')
+  return {
+    swift,
+    objc: objc.join('\n'),
+    registration,
+    registerFunction,
+    classes,
+    types: new Map(classes.map((c) => [c.name, c.nativeName])),
+  }
+}