peachsim 0.1.1644 → 0.1.1653

package/src/swift-objc-export.ts

@@ -0,0 +1,532 @@
+import { createHash } from 'node:crypto'
+
+interface ExportType {
+  swift: string
+  objc: string
+  c: string
+  object: boolean
+  optional: boolean
+}
+
+interface ExportParameter {
+  label: string
+  name: string
+  type: ExportType
+}
+
+interface ExportMethod {
+  name: string
+  selector: string
+  classMethod: boolean
+  parameters: ExportParameter[]
+  result: ExportType
+  property?: { name: string; setter: boolean; writable: boolean; ownership?: string }
+}
+
+interface ExportClass {
+  file: string
+  name: string
+  native: string
+  objc: string
+  base: string
+  start: number
+  end: number
+  members: ExportMethod[]
+}
+
+export interface SwiftObjCExport {
+  header: string
+  implementation: string
+  swift: Map<string, string>
+  registration: string
+  /** swift declaration name to its objective-c source name, including renames. */
+  types: Map<string, string>
+}
+
+/** one signature owns the objective-c declaration, clang method and typed swift call. */
+export function swiftObjCExports(args: {
+  module: string
+  sources: [string, string][]
+  mask: (source: string) => string
+  declarationStart: (code: string, at: number, floor: number) => number
+  selector: (name: string, labels: string[], async: boolean, throwing: boolean) => string
+  /** imported native class names whose storage remains in the original object. */
+  foreignTypes?: ReadonlyMap<string, string>
+}): SwiftObjCExport | null {
+  const classes: ExportClass[] = []
+  function fail(where: string, detail: string): never {
+    throw new Error(`Swift Objective-C export ${args.module}.${where}: ${detail}`)
+  }
+  const close = (code: string, open: number, left: string, right: string): number => {
+    let depth = 1
+    for (let at = open + 1; at < code.length; at++) {
+      if (code[at] === left) depth++
+      if (code[at] === right && --depth === 0) return at
+    }
+    return fail('declaration', `unclosed ${left}`)
+  }
+  for (const [file, source] of args.sources) {
+    const code = args.mask(source)
+    let depth = 0
+    for (const token of code.matchAll(/[{}]|\bclass\s+(?!func\b|var\b)([A-Za-z_]\w*)/g)) {
+      if (token[0] === '{') {
+        depth++
+        continue
+      }
+      if (token[0] === '}') {
+        depth--
+        continue
+      }
+      if (depth !== 0) continue
+      const start = token.index
+      const open = code.indexOf('{', start)
+      const head = code.slice(args.declarationStart(code, start, 0), open)
+      const base = /\bclass\s+\w+\s*:\s*([A-Za-z_]\w*)\s*(?:,|$)/.exec(head)?.[1]
+      if (!base) continue
+      const name = token[1]!
+      const end = close(code, open, '{', '}')
+      const explicit = /@objc\s*\(\s*([A-Za-z_]\w*)\s*\)/.exec(head)?.[1]
+      classes.push({
+        file,
+        name,
+        objc: explicit ?? name,
+        native:
+          explicit ?? `_TtC${args.module.length}${args.module}${name.length}${name}`,
+        base,
+        start: open,
+        end,
+        members: [],
+      })
+    }
+  }
+  const byName = new Map(classes.map((value) => [value.name, value]))
+  for (const owner of classes)
+    if (args.foreignTypes?.has(owner.base))
+      fail(
+        owner.name,
+        'subclassing an original Objective-C class requires its native subclass and construction ABI',
+      )
+  if (byName.size !== classes.length)
+    fail('declaration', 'ambiguous class names require semantic resolution')
+  const rooted = (value: ExportClass, seen = new Set<string>()): boolean => {
+    if (seen.has(value.name)) return fail(value.name, 'cyclic superclass declarations')
+    seen.add(value.name)
+    return (
+      value.base === 'NSObject' ||
+      (byName.has(value.base) && rooted(byName.get(value.base)!, seen))
+    )
+  }
+  const exported = classes.filter((value) => rooted(value))
+  if (!exported.length) return null
+  const names = new Set(exported.map((value) => value.name))
+  for (const [, source] of args.sources) {
+    const code = args.mask(source)
+    for (const extension of code.matchAll(/\bextension\s+([A-Za-z_]\w*)/g))
+      if (names.has(extension[1]!))
+        fail(extension[1]!, 'extension exports require semantic member resolution')
+  }
+  const type = (written: string, where: string): ExportType => {
+    const swift = written.trim()
+    const optional = /[?!]$/.test(swift)
+    const name = optional ? swift.slice(0, -1).trim() : swift
+    const primitive: Record<string, [string, string]> = {
+      Void: ['void', 'Void'],
+      '()': ['void', 'Void'],
+      Bool: ['BOOL', 'Bool'],
+      Int8: ['int8_t', 'Int8'],
+      UInt8: ['uint8_t', 'UInt8'],
+      Int16: ['int16_t', 'Int16'],
+      UInt16: ['uint16_t', 'UInt16'],
+      Int32: ['int32_t', 'Int32'],
+      UInt32: ['uint32_t', 'UInt32'],
+      Int64: ['int64_t', 'Int64'],
+      UInt64: ['uint64_t', 'UInt64'],
+      Int: ['NSInteger', 'Int'],
+      UInt: ['NSUInteger', 'UInt'],
+      Float: ['float', 'Float'],
+      Double: ['double', 'Double'],
+    }
+    if (primitive[name] && !optional)
+      return {
+        swift,
+        objc: primitive[name]![0],
+        c: primitive[name]![1],
+        object: false,
+        optional: false,
+      }
+    if (names.has(name) || name === 'NSObject' || args.foreignTypes?.has(name))
+      return {
+        swift: optional ? `${name}?` : name,
+        objc: `${byName.get(name)?.objc ?? args.foreignTypes?.get(name) ?? name} * ${optional ? '_Nullable' : '_Nonnull'}`,
+        c: optional ? 'UnsafeMutableRawPointer?' : 'UnsafeMutableRawPointer',
+        object: true,
+        optional,
+      }
+    return fail(
+      where,
+      `unsupported exported type ${swift}; its canonical adapter and ABI must be qualified first`,
+    )
+  }
+  const voidType = type('Void', 'Void')
+  const split = (text: string): string[] => {
+    const parts: string[] = []
+    let start = 0,
+      depth = 0
+    for (let at = 0; at < text.length; at++) {
+      if ('(<['.includes(text[at]!)) depth++
+      else if (')>]'.includes(text[at]!)) depth--
+      else if (text[at] === ',' && depth === 0) {
+        parts.push(text.slice(start, at))
+        start = at + 1
+      }
+    }
+    if (text.slice(start).trim()) parts.push(text.slice(start))
+    return parts
+  }
+  const ordered: ExportClass[] = []
+  const order = (owner: ExportClass) => {
+    if (ordered.includes(owner)) return
+    const parent = exported.find((value) => value.name === owner.base)
+    if (parent) order(parent)
+    ordered.push(owner)
+  }
+  for (const owner of exported) order(owner)
+  const exposure = new Map<string, Map<string, boolean>>()
+  const inheritedSelectors = new Map<string, Map<string, string>>()
+  for (const owner of ordered) {
+    const source = args.sources.find(([file]) => file === owner.file)![1]
+    const code = args.mask(source)
+    let depth = 0
+    const classHead = code.slice(
+      args.declarationStart(code, code.lastIndexOf('class', owner.start), 0),
+      owner.start,
+    )
+    if (/\b(private|fileprivate)\b/.test(classHead))
+      fail(owner.name, 'private class export requires semantic visibility qualification')
+    if (/@available\b/.test(classHead))
+      fail(owner.name, 'class availability requires semantic qualification')
+    if (classHead.includes('<') || /@(?:MainActor|globalActor)\b/.test(classHead))
+      fail(owner.name, 'generic or isolated class export needs its typed ABI')
+    if (classHead.slice(classHead.indexOf(':') + 1).includes(','))
+      fail(
+        owner.name,
+        'protocol conformance needs a canonical Objective-C protocol adapter',
+      )
+    for (const match of code
+      .slice(owner.start + 1, owner.end)
+      .matchAll(/[{}]|\b(func|var|let|init)\b/g)) {
+      if (match[0] === '{') {
+        depth++
+        continue
+      }
+      if (match[0] === '}') {
+        depth--
+        continue
+      }
+      if (depth !== 0) continue
+      const at = owner.start + 1 + match.index
+      const kind = match[1]!
+      const headStart = args.declarationStart(code, at, owner.start + 1)
+      const head = code.slice(headStart, at)
+      // objc-first construction requires genuine swift allocation before init,
+      // including destruction of an allocation that was never initialized.
+      if (kind === 'init') continue
+      const declared = /^\s*(func|var|let)\s+([A-Za-z_]\w*)/.exec(code.slice(at))
+      const classMethod = /\b(static|class)\b/.test(head)
+      let key = `${classMethod}:${kind === 'func' ? 'method' : 'property'}:${declared?.[2]}`
+      if (kind === 'func') {
+        const open = code.indexOf('(', at)
+        const end = close(code, open, '(', ')')
+        key += `(${split(source.slice(open + 1, end))
+          .map((parameter) => {
+            const typed = /^\s*([A-Za-z_]\w*)(?:\s+[A-Za-z_]\w*)?\s*:\s*(.*)$/.exec(
+              parameter,
+            )
+            return typed
+              ? `${typed[1]}:${typed[2]!.split('=')[0]!.replace(/\s/g, '')}`
+              : parameter.trim()
+          })
+          .join(',')})`
+      }
+      let exposed = /@objc\b|@IBAction\b/.test(head) || /@objcMembers\b/.test(classHead)
+      let inheritedSelector: string | undefined
+      if (/\boverride\b/.test(head)) {
+        let parent = byName.get(owner.base)
+        while (parent && inheritedSelector === undefined) {
+          inheritedSelector = inheritedSelectors.get(parent.name)?.get(key)
+          parent = byName.get(parent.base)
+        }
+      }
+      if (!exposed && /\boverride\b/.test(head) && !/@nonobjc\b/.test(head)) {
+        let parent = byName.get(owner.base)
+        let inherited: boolean | undefined
+        while (parent && inherited === undefined) {
+          inherited = exposure.get(parent.name)?.get(key)
+          parent = byName.get(parent.base)
+        }
+        if (inherited === undefined)
+          fail(
+            owner.name,
+            `override ${declared?.[2]} requires its native superclass declaration to determine Objective-C exposure`,
+          )
+        exposed = inherited
+      }
+      const members = exposure.get(owner.name) ?? new Map<string, boolean>()
+      members.set(key, exposed && !/@nonobjc\b/.test(head))
+      exposure.set(owner.name, members)
+      if (!exposed || /@nonobjc\b/.test(head)) continue
+      const where = `${owner.name} at ${owner.file}:${source.slice(0, at).split('\n').length}`
+      if (/\b(private|fileprivate)\b|@available|@MainActor|\bnonisolated\b/.test(head))
+        fail(
+          where,
+          'export visibility, availability or isolation requires semantic qualification',
+        )
+      const explicit = /@objc\s*\(\s*([^()]+)\)/.exec(head)?.[1]?.trim()
+      const selectors = inheritedSelectors.get(owner.name) ?? new Map<string, string>()
+      inheritedSelectors.set(owner.name, selectors)
+      if (kind === 'var' || kind === 'let') {
+        const property = /^(?:var|let)\s+([A-Za-z_]\w*)\s*:\s*([^=\n{]+)/.exec(
+          code.slice(at),
+        )
+        if (!property) fail(where, 'exported property requires one explicit type')
+        const name = property[1]!
+        const result = type(property[2]!, where)
+        const after = at + property[0].length
+        const access = code.slice(after).trimStart()
+        const bodyOpen = code.indexOf('{', after)
+        if (
+          bodyOpen >= 0 &&
+          bodyOpen < owner.end &&
+          !/\b(?:func|var|let|init|deinit|class|struct|enum|extension)\b/.test(
+            code.slice(after, bodyOpen),
+          ) &&
+          /\b(?:willSet|didSet)\b/.test(
+            code.slice(bodyOpen, close(code, bodyOpen, '{', '}')),
+          )
+        )
+          fail(where, 'property observers require semantic accessor qualification')
+        const writable =
+          kind === 'var' &&
+          (!access.startsWith('{') ||
+            /\bset\b/.test(
+              code.slice(
+                code.indexOf('{', after),
+                close(code, code.indexOf('{', after), '{', '}'),
+              ),
+            ))
+        const selector = explicit ?? inheritedSelector ?? name
+        selectors.set(key, selector)
+        if (selector.includes(':') || result.swift === 'Void' || result.swift === '()')
+          fail(where, 'invalid exported property signature')
+        owner.members.push({
+          name,
+          selector,
+          classMethod,
+          parameters: [],
+          result,
+          property: {
+            name,
+            setter: false,
+            writable,
+            ownership: result.object
+              ? /\bweak\b/.test(head)
+                ? 'weak'
+                : /\bunowned\b/.test(head)
+                  ? 'unsafe_unretained'
+                  : 'strong'
+              : undefined,
+          },
+        })
+        if (writable)
+          owner.members.push({
+            name,
+            selector: `set${selector[0]!.toUpperCase()}${selector.slice(1)}:`,
+            classMethod,
+            parameters: [{ label: '_', name: 'value', type: result }],
+            result: voidType,
+            property: { name, setter: true, writable },
+          })
+        continue
+      }
+      const signature = /^func\s+([A-Za-z_]\w*)\s*\(/.exec(code.slice(at))
+      if (!signature) fail(where, 'generic or unsupported function declaration')
+      const open = at + signature[0].lastIndexOf('(')
+      const end = close(code, open, '(', ')')
+      const body = code.indexOf('{', end)
+      const tail = code.slice(end + 1, body).trim()
+      if (/\b(async|throws|rethrows|where)\b/.test(tail))
+        fail(where, 'async, throwing or constrained export requires its typed ABI')
+      const parameters = split(source.slice(open + 1, end)).map((parameter, index) => {
+        const parsed = /^\s*([A-Za-z_]\w*)(?:\s+([A-Za-z_]\w*))?\s*:\s*(.*)$/.exec(
+          parameter,
+        )
+        if (!parsed) return fail(where, 'unsupported parameter declaration')
+        return {
+          label: parsed[1]!,
+          name: parsed[2] ?? (parsed[1] === '_' ? `argument${index}` : parsed[1]!),
+          type: type(parsed[3]!.split('=')[0]!, where),
+        }
+      })
+      const name = signature[1]!
+      const selector =
+        explicit ??
+        inheritedSelector ??
+        args.selector(
+          name,
+          parameters.map((parameter) => parameter.label),
+          false,
+          false,
+        )
+      selectors.set(key, selector)
+      if ((selector.match(/:/g)?.length ?? 0) !== parameters.length)
+        fail(where, 'selector arity differs from its Swift declaration')
+      owner.members.push({
+        name,
+        selector,
+        classMethod,
+        parameters,
+        result: type(tail.replace(/^->\s*/, '') || 'Void', where),
+      })
+    }
+  }
+  const swift = new Map<string, string>()
+  const headers = [
+    '#pragma once',
+    '#if defined(__OBJC__)',
+    '#import <Foundation/Foundation.h>',
+    '#ifndef PEACH_SWIFT_CLASS_RESTRICTION',
+    '#define PEACH_SWIFT_CLASS_RESTRICTION __attribute__((objc_subclassing_restricted))',
+    '#endif',
+    ...ordered.map((owner) => `@class ${owner.objc};`),
+    ...[...new Set(args.foreignTypes?.values())].map((name) => `@class ${name};`),
+  ]
+  const implementations = [
+    '#define PEACH_SWIFT_CLASS_RESTRICTION',
+    `#import "${args.module}-Swift.h"`,
+    `#include "${args.module}-Cxx.h"`,
+  ]
+  const register = `_peach_objc_exports_${args.module}`
+  const registrations: string[] = []
+  for (const owner of ordered) {
+    const selectors = new Set<string>()
+    for (const member of owner.members) {
+      if (
+        [
+          'initialize',
+          'load',
+          'alloc',
+          'allocWithZone:',
+          'new',
+          'init',
+          'dealloc',
+          'retain',
+          'release',
+          'autorelease',
+          'class',
+          'isKindOfClass:',
+        ].includes(member.selector)
+      )
+        fail(
+          owner.name,
+          `selector ${member.selector} belongs to the canonical peer lifecycle contract`,
+        )
+      const key = `${member.classMethod}:${member.selector}`
+      if (selectors.has(key))
+        fail(owner.name, `duplicate exported selector ${member.selector}`)
+      selectors.add(key)
+    }
+    const methods: string[] = []
+    const bodies: string[] = []
+    const snippets: string[] = []
+    for (const method of owner.members) {
+      const symbol = `_peach_objc_${createHash('sha256').update(`${args.module}.${owner.name}.${method.classMethod}.${method.selector}`).digest('hex').slice(0, 24)}`
+      const selector = method.selector.split(':')
+      const declaration = `${method.classMethod ? '+' : '-'} (${method.result.objc})${method.parameters.length ? method.parameters.map((parameter, i) => `${selector[i]}:(${parameter.type.objc})argument${i}`).join(' ') : method.selector}`
+      if (method.property) {
+        if (!method.property.setter) {
+          const attributes = [
+            'nonatomic',
+            ...(method.classMethod ? ['class'] : []),
+            ...(method.property.writable ? [] : ['readonly']),
+            ...(method.property.ownership ? [method.property.ownership] : []),
+          ]
+          methods.push(
+            `@property (${attributes.join(', ')}) ${method.result.objc} ${method.selector};`,
+          )
+        }
+      } else methods.push(`${declaration} __attribute__((objc_method_family(none)));`)
+      const parameters = method.parameters
+        .map((parameter, i) => `_ argument${i}: ${parameter.type.c}`)
+        .join(', ')
+      const receiver = method.classMethod
+        ? `let receiver = _objcTypeFromPeerClass(peer) as! ${owner.name}.Type\n`
+        : `let receiver = _objcObjectFromPeer(peer) as! ${owner.name}\n`
+      const arguments_ = method.parameters
+        .map((parameter, i) => {
+          const value = parameter.type.object
+            ? parameter.type.optional
+              ? `argument${i}.map { _objcObjectFromPeer($0) as! ${parameter.type.swift.slice(0, -1)} }`
+              : `(_objcObjectFromPeer(argument${i}) as! ${parameter.type.swift})`
+            : `argument${i}`
+          return `${parameter.label === '_' ? '' : `${parameter.label}: `}${value}`
+        })
+        .join(', ')
+      const call = method.property
+        ? method.property.setter
+          ? `receiver.${method.property.name} = ${arguments_.replace(/^.*?: /, '')}`
+          : `receiver.${method.property.name}`
+        : `receiver.${method.name}(${arguments_})`
+      const invocation = method.result.object
+        ? `let result = ${call}\nreturn ${method.result.optional ? 'result.map { _objcRetainedPeer($0) }' : '_objcRetainedPeer(result)'}`
+        : `${method.result.swift === 'Void' || method.result.swift === '()' ? '' : 'return '}${call}`
+      snippets.push(
+        `@_cdecl("${symbol}")\npublic func __peachObjcExport${createHash('sha256').update(symbol).digest('hex').slice(0, 16)}(_ peer: UnsafeMutableRawPointer${parameters ? `, ${parameters}` : ''}) -> ${method.result.c} {\n__peachEnsureExports()\n${receiver}${invocation}\n}`,
+      )
+      const cArguments = [
+        '(void *)self',
+        ...method.parameters.map(
+          (parameter, i) => `${parameter.type.object ? '(void *)' : ''}argument${i}`,
+        ),
+      ].join(', ')
+      const cCall = `${symbol}(${cArguments})`
+      const body = method.result.object
+        ? `return [(id)${cCall} autorelease];`
+        : method.result.c === 'Void'
+          ? `${cCall};`
+          : `return ${cCall};`
+      bodies.push(`${declaration} { ${body} }`)
+    }
+    const construction =
+      '__attribute__((unavailable("Objective-C-first Swift construction requires a qualified Swift allocation ABI")))'
+    methods.push(
+      `- (instancetype _Nonnull)init ${construction};`,
+      `+ (instancetype _Nonnull)new ${construction};`,
+      `+ (instancetype _Nonnull)alloc ${construction};`,
+      `+ (instancetype _Nonnull)allocWithZone:(struct _NSZone * _Nullable)zone ${construction};`,
+    )
+    headers.push(
+      `__attribute__((objc_runtime_name("${owner.native}"))) __attribute__((swift_name("${owner.name}"))) PEACH_SWIFT_CLASS_RESTRICTION\n@interface ${owner.objc} : ${byName.get(owner.base)?.objc ?? owner.base}`,
+      ...methods,
+      '@end',
+    )
+    implementations.push(`@implementation ${owner.objc}`, ...bodies, '@end')
+    const registration = `${register}_${owner.name}`
+    snippets.push(
+      `@_cdecl("${registration}")\npublic func __peachRegisterExport${owner.name}() {\n_objcRegisterPeerClass(${owner.name}.self, nativeName: "${owner.native}")\n}`,
+    )
+    implementations.push(`extern void ${registration}(void);`)
+    registrations.push(`${registration}();`)
+    swift.set(
+      owner.file,
+      `${swift.get(owner.file) ?? '\nimport PeachObjC\n@_extern(c, "_peach_objc_ensure_exports") private func __peachEnsureExports()\n'}${snippets.join('\n')}\n`,
+    )
+  }
+  headers.push('#else', `#include "${args.module}-Cxx.h"`, '#endif', '')
+  return {
+    header: headers.join('\n'),
+    implementation: implementations.join('\n'),
+    swift,
+    registration: registrations.join('\n'),
+    types: new Map(ordered.map((owner) => [owner.name, owner.objc])),
+  }
+}