peachsim 0.1.1635 → 0.1.1641

package/src/swift-objc-metadata.ts

@@ -0,0 +1,204 @@
+import { spawnSync } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import fs from 'node:fs'
+import path from 'node:path'
+import { IOS_SDK_HEADERS } from './swift-objc-sdk'
+import { IOS_SDK_ID, materializeObjcSdk } from './swift-objc-standin'
+import { swiftEnvironment } from './swift-toolchain'
+import type { SwiftObjCPeerClass } from './swiftContract'
+
+export class ObjcPeerMetadataError extends Error {
+  constructor(
+    message: string,
+    readonly files: string[],
+    readonly reusable: boolean,
+  ) {
+    super(message)
+  }
+}
+
+export function validateObjcPeerClasses(
+  classes: readonly SwiftObjCPeerClass[],
+): Set<string> {
+  const names = new Set<string>()
+  for (const peer of classes) {
+    if (!/^[A-Za-z_]\w*$/.test(peer.name) || names.has(peer.name))
+      throw new Error(`invalid or duplicate Objective-C metadata class: ${peer.name}`)
+    names.add(peer.name)
+    const header = /^(\w+)\/([\w./-]+\.h)$/.exec(peer.header)
+    if (
+      !header ||
+      header[2]!.split('/').some((part) => part === '..' || part === '.') ||
+      !Object.hasOwn(
+        IOS_SDK_HEADERS,
+        `System/Library/Frameworks/${header[1]}.framework/Headers/${header[2]}`,
+      )
+    )
+      throw new Error(`Objective-C peer header is outside the shared SDK: ${peer.header}`)
+  }
+  if (names.size === 0) throw new Error('Objective-C metadata requires peer classes')
+  return names
+}
+
+/** emits class metadata and its startup registration; adapters own every method. */
+export function compileObjcPeerMetadata(args: {
+  classes: readonly SwiftObjCPeerClass[]
+  work: string
+  headerCache: string
+  toolchainBin: string
+  sysroot: string
+  minimum: number
+  descriptor?: number
+}): { object: string; registration: string; files: string[] } {
+  const names = validateObjcPeerClasses(args.classes)
+  const headers = materializeObjcSdk(args.headerCache)
+  const source = path.join(args.work, 'peer-metadata.m')
+  const object = path.join(args.work, 'peer-metadata.o')
+  const log = path.join(args.work, 'peer-metadata.log')
+  const receipt = path.join(args.work, 'peer-metadata.json')
+  const registration = path.join(args.work, 'peer-registration.swift')
+  fs.writeFileSync(
+    registration,
+    [
+      'import PeachObjC',
+      ...[...new Set(args.classes.map((peer) => peer.header.split('/')[0]!))].map(
+        (module) => `import ${module}`,
+      ),
+      '@_cdecl("_peach_objc_register_peers")',
+      'public func _peachRegisterObjcPeers() {',
+      ...[...args.classes]
+        .sort(
+          (left, right) =>
+            Number(right.name === 'NSObject') - Number(left.name === 'NSObject'),
+        )
+        .map(
+          (peer) =>
+            `  _objcRegisterPeerClass(\`${peer.name}\`.self, nativeName: "${peer.name}")`,
+        ),
+      '}',
+      '',
+    ].join('\n'),
+  )
+  fs.writeFileSync(
+    source,
+    [
+      ...[...new Set(args.classes.map((peer) => peer.header))].map(
+        (header) => `#import <${header}>`,
+      ),
+      ...args.classes.map((peer) => `@implementation ${peer.name}\n@end`),
+      'extern void _peach_objc_register_peers(void);',
+      '__attribute__((constructor)) static void peach_register_objc_peers(void) {',
+      '  _peach_objc_register_peers();',
+      '}',
+      '',
+    ].join('\n'),
+  )
+  const command = [
+    '--target=wasm32-unknown-wasip1',
+    `--sysroot=${args.sysroot}`,
+    '-fwasm-exceptions',
+    '-fexceptions',
+    '-D_WASI_EMULATED_SIGNAL',
+    '-D_WASI_EMULATED_MMAN',
+    `-D__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__=${args.minimum}`,
+    `-D__IPHONE_OS_VERSION_MIN_REQUIRED=${args.minimum}`,
+    '-fobjc-runtime=gnustep-2.2',
+    '-fobjc-exceptions',
+    '-fobjc-arc',
+    '-fblocks',
+    // empty implementations must not synthesize framework getters or storage.
+    '-Xclang',
+    '-disable-objc-default-synthesize-properties',
+    '-Werror=objc-root-class',
+    '-F',
+    path.join(headers, 'System/Library/Frameworks'),
+    '-idirafter',
+    path.join(headers, 'usr/include'),
+    '-Os',
+    '-c',
+    source,
+    '-o',
+    object,
+  ]
+  const compiler = path.join(args.toolchainBin, 'clang')
+  const result = spawnSync(compiler, command, {
+    cwd: args.work,
+    env: swiftEnvironment(),
+    encoding: 'utf8',
+    stdio: [
+      'ignore',
+      'pipe',
+      'pipe',
+      ...(args.descriptor === undefined ? [] : [args.descriptor]),
+    ],
+    timeout: 120_000,
+    maxBuffer: 16 * 1024 * 1024,
+  })
+  fs.writeFileSync(
+    log,
+    `${result.stdout ?? ''}${result.stderr ?? ''}${result.error?.message ?? ''}`,
+  )
+  const digest = (file: string) =>
+    createHash('sha256').update(fs.readFileSync(file)).digest('hex')
+  fs.writeFileSync(
+    receipt,
+    JSON.stringify(
+      {
+        classes: args.classes,
+        declarations: IOS_SDK_ID,
+        compiler: digest(compiler),
+        command,
+        source: digest(source),
+        status: result.status,
+        signal: result.signal,
+        error: result.error?.message,
+        ...(result.status === 0 && !result.error ? { object: digest(object) } : {}),
+      },
+      null,
+      2,
+    ),
+  )
+  const files = [source, registration, log, receipt]
+  if (result.error || result.status !== 0)
+    throw new ObjcPeerMetadataError(
+      `Objective-C peer metadata compilation failed: ${log}`,
+      files,
+      !result.error && !result.signal && result.status !== null,
+    )
+  files.push(object)
+  const symbols = spawnSync(
+    path.join(args.toolchainBin, 'llvm-nm'),
+    ['--format=posix', object],
+    {
+      encoding: 'utf8',
+      env: swiftEnvironment(),
+      timeout: 120_000,
+      maxBuffer: 16 * 1024 * 1024,
+    },
+  )
+  fs.appendFileSync(
+    log,
+    `${symbols.stdout ?? ''}${symbols.stderr ?? ''}${symbols.error?.message ?? ''}`,
+  )
+  if (symbols.error || symbols.status !== 0)
+    throw new ObjcPeerMetadataError(
+      `could not inspect Objective-C peer metadata: ${log}`,
+      files,
+      !symbols.error && !symbols.signal && symbols.status !== null,
+    )
+  const emitted = [...symbols.stdout.matchAll(/^\._OBJC_CLASS_(\w+) [^U] /gm)].map(
+    (match) => match[1]!,
+  )
+  if (
+    emitted.length !== names.size ||
+    !emitted.every((name) => names.has(name)) ||
+    /^\._OBJC_CLASS_\w+ U(?: |$)/m.test(symbols.stdout) ||
+    /^_[ic]_\w+/m.test(symbols.stdout)
+  )
+    throw new ObjcPeerMetadataError(
+      `Objective-C peer metadata contains unexpected classes or methods: ${receipt}`,
+      files,
+      true,
+    )
+  return { object, registration, files }
+}