peachsim 0.1.1641 → 0.1.1653

package/src/swift-objc-metadata.ts

@@ -3,7 +3,14 @@ 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 { IOS_SDK_TARGET } from './swift-objc-sdk'
+import {
+  IOS_SDK_ID,
+  materializeObjcSdk,
+  OBJC_IMPORT_VERSION,
+  objcView,
+  type ObjcView,
+} from './swift-objc-standin'
 import { swiftEnvironment } from './swift-toolchain'
 import type { SwiftObjCPeerClass } from './swiftContract'
 
@@ -17,6 +24,135 @@ export class ObjcPeerMetadataError extends Error {
   }
 }
 
+/** rejects application archive initializers that could use peers before the entry. */
+export function validateObjcPeerStartupLibraries(
+  libraries: Record<string, string>,
+): void {
+  function fail(name: string, detail: string): never {
+    throw new Error(`Objective-C peer startup ${name}: ${detail}`)
+  }
+  for (const [library, encoded] of Object.entries(libraries)) {
+    const archive = Buffer.from(encoded, 'base64')
+    if (archive.toString('latin1', 0, 8) !== '!<arch>\n')
+      fail(library, 'requires an ordinary archive with inspectable wasm objects')
+    for (let member = 8; member < archive.length; ) {
+      if (
+        member + 60 > archive.length ||
+        archive.toString('latin1', member + 58, member + 60) !== '`\n'
+      )
+        fail(library, 'invalid archive member')
+      const name = archive.toString('latin1', member, member + 16).trim()
+      const size = Number(archive.toString('latin1', member + 48, member + 58).trim())
+      if (!Number.isSafeInteger(size) || size < 0 || member + 60 + size > archive.length)
+        fail(library, 'invalid archive member size')
+      let object = archive.subarray(member + 60, member + 60 + size)
+      member += 60 + size + (size % 2)
+      if (name === '/' || name === '//' || name === '/SYM64/') continue
+      if (name.startsWith('#1/')) {
+        const length = Number(name.slice(3))
+        if (!Number.isSafeInteger(length) || length < 0 || length > object.length)
+          fail(library, 'invalid archive extended name')
+        const extended = object.toString('utf8', 0, length).replace(/\0+$/, '')
+        if (extended.startsWith('__.SYMDEF')) continue
+        object = object.subarray(length)
+      }
+      if (
+        object.length < 8 ||
+        object.readUInt32LE(0) !== 0x6d736100 ||
+        object.readUInt32LE(4) !== 1
+      )
+        fail(library, 'unqualified non-wasm archive member')
+      let at = 8
+      let limit = object.length
+      const byte = (): number => {
+        if (at >= limit) return fail(library, 'truncated wasm metadata')
+        return object[at++]!
+      }
+      const leb = (): number => {
+        let value = 0
+        for (let shift = 0; shift < 35; shift += 7) {
+          const next = byte()
+          value += (next & 127) * 2 ** shift
+          if (!(next & 128)) {
+            if (value > 0xffffffff) return fail(library, 'invalid wasm integer')
+            return value
+          }
+        }
+        return fail(library, 'invalid wasm integer')
+      }
+      const text = (): string => {
+        const size = leb()
+        if (at + size > limit) return fail(library, 'truncated wasm name')
+        const value = object.toString('utf8', at, at + size)
+        at += size
+        return value
+      }
+      let linking = false
+      const symbols: (string | undefined)[] = []
+      const initializers: number[] = []
+      while (at < object.length) {
+        limit = object.length
+        const section = byte()
+        const length = leb()
+        const end = at + length
+        if (end > object.length) fail(library, 'truncated wasm section')
+        limit = end
+        if (section === 0 && text() === 'linking') {
+          if (linking || leb() !== 2) fail(library, 'unqualified wasm linking metadata')
+          linking = true
+          while (at < end) {
+            const kind = byte()
+            const size = leb()
+            const next = at + size
+            if (next > end) fail(library, 'truncated linking subsection')
+            limit = next
+            if (kind === 6) {
+              for (let count = leb(); count > 0; count--) {
+                leb()
+                initializers.push(leb())
+              }
+            } else if (kind === 8) {
+              for (let count = leb(); count > 0; count--) {
+                const kind = byte(),
+                  flags = leb()
+                let name: string | undefined
+                if ([0, 2, 4, 5].includes(kind)) {
+                  leb()
+                  if (!(flags & 16) || flags & 64) name = text()
+                } else if (kind === 1) {
+                  name = text()
+                  if (!(flags & 16)) {
+                    leb()
+                    leb()
+                    leb()
+                  }
+                } else if (kind === 3) leb()
+                else fail(library, 'unknown wasm symbol kind')
+                if (name && /^_c_.*_load$/.test(name))
+                  fail(
+                    library,
+                    'Objective-C +load can use peers before runtime initialization',
+                  )
+                symbols.push(name)
+              }
+            }
+            at = next
+            limit = end
+          }
+        }
+        at = end
+      }
+      if (!linking) fail(library, 'archive member has no constructor provenance')
+      for (const initializer of initializers)
+        if (symbols[initializer] !== '.objcv2_load_function')
+          fail(
+            library,
+            `pre-main initializer ${symbols[initializer] ?? initializer} is unqualified`,
+          )
+    }
+  }
+}
+
 export function validateObjcPeerClasses(
   classes: readonly SwiftObjCPeerClass[],
 ): Set<string> {
@@ -40,6 +176,125 @@ export function validateObjcPeerClasses(
   return names
 }
 
+interface ObjcPeerType {
+  /** the runtime class the metadata defines. */
+  native: string
+  /** the Swift class the importer exposes for it: what registration names. */
+  swift: string
+  /** the sdk module whose importer graph exposes it, not the guest provider. */
+  importerModule: string
+}
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === 'object'
+
+// candidate interfaces in the compiler's header view. clang may repeat the
+// superclass on redeclarations; the semantic graph and the final metadata
+// compilation below must also accept the requested class.
+function definedInterfaces(views: readonly ObjcView[]): Set<string> {
+  const defined = new Set<string>()
+  const visit = (node: unknown): void => {
+    if (!isRecord(node)) return
+    const name = node.name
+    if (
+      node.kind === 'ObjCInterfaceDecl' &&
+      isRecord(node.super) &&
+      typeof name === 'string'
+    )
+      defined.add(name)
+    if (Array.isArray(node.inner)) for (const child of node.inner) visit(child)
+  }
+  for (const view of views) visit(view.clangAST)
+  return defined
+}
+
+/**
+ * the swift class of each peer, read from the compiler's own view of the
+ * peer header: a native @interface the clang declarations define, and the one
+ * class symbol the importer exposes under its c:objc(cs) id. the sdk's
+ * ObjectiveC module is part of every header's view, so root classes resolve
+ * there. an absent, ambiguous, non-class or nested symbol refuses; the native
+ * spelling is never assumed.
+ */
+export function resolveObjcPeerTypes(
+  classes: readonly SwiftObjCPeerClass[],
+  views: ReadonlyMap<string, ObjcView>,
+): Map<string, ObjcPeerType> {
+  const defined = definedInterfaces([...views.values()])
+  const types = new Map<string, ObjcPeerType>()
+  for (const peer of classes) {
+    if (!defined.has(peer.name))
+      throw new Error(
+        `Objective-C peer ${peer.name} has no @interface definition in ${peer.header}`,
+      )
+    const precise = `c:objc(cs)${peer.name}`
+    const symbols = [...views.values()].flatMap((view) =>
+      view.graphs.flatMap((graph) =>
+        graph.symbols
+          .filter((symbol) => symbol.identifier.precise === precise)
+          .map((symbol) => ({ symbol, module: graph.module.name })),
+      ),
+    )
+    if (symbols.length !== 1)
+      throw new Error(
+        `Objective-C peer ${peer.name} imports as ${symbols.length} Swift symbols, not one`,
+      )
+    const { symbol, module } = symbols[0]!
+    const swift = symbol.pathComponents[0]
+    if (
+      symbol.kind.identifier !== 'swift.class' ||
+      symbol.pathComponents.length !== 1 ||
+      swift === undefined ||
+      !/^[A-Za-z_]\w*$/.test(swift)
+    )
+      throw new Error(
+        `Objective-C peer ${peer.name} imports as ${symbol.kind.identifier} ${symbol.pathComponents.join('.')}, not a top-level Swift class`,
+      )
+    types.set(peer.name, { native: peer.name, swift, importerModule: module })
+  }
+  return types
+}
+
+// the importer's view of each module the peer headers name, plus the
+// ObjectiveC module every header imports, over the shared sdk.
+function objcPeerViews(args: {
+  classes: readonly SwiftObjCPeerClass[]
+  work: string
+  headerCache: string
+  toolchainBin: string
+  stdlib: string
+}): Map<string, ObjcView> {
+  const sdk = materializeObjcSdk(args.headerCache)
+  const views = new Map<string, ObjcView>()
+  const original = { flags: [], target: IOS_SDK_TARGET }
+  const modules = new Set(args.classes.map((peer) => peer.header.split('/')[0]!))
+  for (const module of ['ObjectiveC', ...modules]) {
+    const framework = path.join(sdk, 'System/Library/Frameworks', `${module}.framework`)
+    views.set(
+      module,
+      objcView(
+        module === 'ObjectiveC'
+          ? {
+              module,
+              headers: path.join(sdk, 'usr/include'),
+              modulemap: path.join(sdk, 'usr/include/module.modulemap'),
+            }
+          : {
+              module,
+              headers: path.join(framework, 'Headers'),
+              modulemap: path.join(framework, 'Modules/module.modulemap'),
+            },
+        args.toolchainBin,
+        args.stdlib,
+        args.headerCache,
+        path.join(args.work, 'peer-views', module),
+        original,
+      ),
+    )
+  }
+  return views
+}
+
 /** emits class metadata and its startup registration; adapters own every method. */
 export function compileObjcPeerMetadata(args: {
   classes: readonly SwiftObjCPeerClass[]
@@ -48,10 +303,32 @@ export function compileObjcPeerMetadata(args: {
   toolchainBin: string
   sysroot: string
   minimum: number
+  stdlib: string
   descriptor?: number
 }): { object: string; registration: string; files: string[] } {
   const names = validateObjcPeerClasses(args.classes)
   const headers = materializeObjcSdk(args.headerCache)
+  // an importer that cannot run may succeed later; a refusal is the answer.
+  let views: Map<string, ObjcView>
+  try {
+    views = objcPeerViews(args)
+  } catch (error) {
+    throw new ObjcPeerMetadataError(
+      error instanceof Error ? error.message : String(error),
+      [],
+      false,
+    )
+  }
+  let types: Map<string, ObjcPeerType>
+  try {
+    types = resolveObjcPeerTypes(args.classes, views)
+  } catch (error) {
+    throw new ObjcPeerMetadataError(
+      error instanceof Error ? error.message : String(error),
+      [],
+      true,
+    )
+  }
   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')
@@ -64,8 +341,7 @@ export function compileObjcPeerMetadata(args: {
       ...[...new Set(args.classes.map((peer) => peer.header.split('/')[0]!))].map(
         (module) => `import ${module}`,
       ),
-      '@_cdecl("_peach_objc_register_peers")',
-      'public func _peachRegisterObjcPeers() {',
+      'private let __peachPeerRegistration: Void = {',
       ...[...args.classes]
         .sort(
           (left, right) =>
@@ -73,9 +349,11 @@ export function compileObjcPeerMetadata(args: {
         )
         .map(
           (peer) =>
-            `  _objcRegisterPeerClass(\`${peer.name}\`.self, nativeName: "${peer.name}")`,
+            `  _objcRegisterPeerClass(\`${types.get(peer.name)!.swift}\`.self, nativeName: "${peer.name}")`,
         ),
-      '}',
+      '}()',
+      '@_cdecl("_peach_objc_register_peers")',
+      'public func _peachRegisterObjcPeers() { _ = __peachPeerRegistration }',
       '',
     ].join('\n'),
   )
@@ -86,10 +364,6 @@ export function compileObjcPeerMetadata(args: {
         (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'),
   )
@@ -144,8 +418,9 @@ export function compileObjcPeerMetadata(args: {
     receipt,
     JSON.stringify(
       {
-        classes: args.classes,
+        classes: args.classes.map((peer) => ({ ...peer, ...types.get(peer.name) })),
         declarations: IOS_SDK_ID,
+        importer: OBJC_IMPORT_VERSION,
         compiler: digest(compiler),
         command,
         source: digest(source),