peachsim 0.1.1625 → 0.1.1635

package/src/react-native-bridge-modules.ts

@@ -0,0 +1,416 @@
+// an app's own legacy React Native modules: the classes its Objective-C
+// sources register with RCT_EXPORT_MODULE or RCT_EXTERN_MODULE, read from the
+// app target Xcode builds. the macros' arguments are what clang records for
+// RCTBridge (RCTMethodInfo's js and objc names); the Swift host parses each
+// signature at runtime as RCTModuleMethod does (sootsim-swift React target).
+import fs from 'node:fs'
+import path from 'node:path'
+import { swiftCodeMask, swiftSourceClosure } from './swift-compile'
+import { listXcodeAppTargets, readXcodeAppTarget } from './xcode-project'
+import type { ExpoSwiftSourceUnit } from './expoSwiftContract'
+
+interface MethodInfo {
+  jsName: string
+  objcName: string
+  isSync: boolean
+}
+
+interface ModuleDeclaration {
+  className: string
+  jsName: string
+  // RCT_EXTERN_MODULE declares a class implemented elsewhere, usually Swift
+  extern: boolean
+  file: string
+}
+
+export interface ObjectiveCDeclarations {
+  modules: ModuleDeclaration[]
+  methods: Map<string, MethodInfo[]>
+  superclasses: Map<string, string>
+  // the instance selectors each class's @implementation blocks define
+  implementations: Map<string, Set<string>>
+}
+
+// Objective-C with its comments as spaces, offsets kept
+function stripComments(source: string): string {
+  let out = ''
+  let i = 0
+  while (i < source.length) {
+    const char = source[i]!
+    const next = source[i + 1]
+    if (char === '/' && next === '/') {
+      const end = source.indexOf('\n', i)
+      const stop = end === -1 ? source.length : end
+      out += ' '.repeat(stop - i)
+      i = stop
+    } else if (char === '/' && next === '*') {
+      const end = source.indexOf('*/', i + 2)
+      const stop = end === -1 ? source.length : end + 2
+      out += source.slice(i, stop).replace(/[^\n]/g, ' ')
+      i = stop
+    } else if (char === '"' || char === "'") {
+      let j = i + 1
+      while (j < source.length && source[j] !== char && source[j] !== '\n')
+        j += source[j] === '\\' ? 2 : 1
+      out += source.slice(i, j + 1)
+      i = j + 1
+    } else {
+      out += char
+      i++
+    }
+  }
+  return out
+}
+
+// a macro's arguments split at top-level commas, as the preprocessor does
+function macroArguments(
+  source: string,
+  open: number,
+): { args: string[]; end: number } | null {
+  const args: string[] = []
+  let depth = 0
+  let start = open + 1
+  for (let i = open; i < source.length; i++) {
+    const char = source[i]
+    if (char === '"' || char === "'") {
+      let j = i + 1
+      while (j < source.length && source[j] !== char) j += source[j] === '\\' ? 2 : 1
+      i = j
+    } else if (char === '(') depth++
+    else if (char === ')') {
+      depth--
+      if (depth === 0) {
+        args.push(source.slice(start, i))
+        return { args: args.map((arg) => arg.replace(/\s+/g, ' ').trim()), end: i + 1 }
+      }
+    } else if (char === ',' && depth === 1) {
+      args.push(source.slice(start, i))
+      start = i + 1
+    }
+  }
+  return null
+}
+
+// the selector a method definition's signature names, skipping its types
+function definitionSelector(signature: string): string {
+  let selector = ''
+  let rest = signature.trim()
+  for (;;) {
+    const part = /^([A-Za-z_]\w*)?\s*(:)?\s*/.exec(rest)
+    if (!part || (!part[1] && !part[2])) break
+    selector += (part[1] ?? '') + (part[2] ?? '')
+    rest = rest.slice(part[0].length)
+    if (!part[2]) break
+    if (rest.startsWith('(')) {
+      const type = macroArguments(rest, 0)
+      if (!type) break
+      rest = rest.slice(type.end).trimStart()
+    }
+    rest = rest.replace(/^[A-Za-z_]\w*\s*/, '')
+  }
+  return selector
+}
+
+const DIRECTIVE =
+  /@interface\b|@implementation\b|@end\b|\b(_RCT_EXTERN_REMAP_METHOD|RCT_EXTERN_REMAP_MODULE|RCT_EXTERN_MODULE|RCT_EXPORT_MODULE_NO_LOAD|RCT_EXPORT_MODULE|RCT_EXTERN_METHOD|RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD|RCT_EXPORT_METHOD|RCT_REMAP_METHOD|RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD|RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD|RCT_REMAP_BLOCKING_SYNCHRONOUS_METHOD)\s*\(/g
+
+export function parseObjectiveCModules(
+  sources: { file: string; text: string }[],
+): ObjectiveCDeclarations {
+  const declarations: ObjectiveCDeclarations = {
+    modules: [],
+    methods: new Map(),
+    superclasses: new Map(),
+    implementations: new Map(),
+  }
+  const addMethod = (className: string, method: MethodInfo) => {
+    const methods = declarations.methods.get(className) ?? []
+    methods.push(method)
+    declarations.methods.set(className, methods)
+  }
+  const addSelector = (className: string, selector: string) => {
+    declarations.implementations.get(className)?.add(selector)
+  }
+  for (const { file, text } of sources) {
+    const source = stripComments(text)
+    // the class whose @interface or @implementation encloses a macro
+    let owner: { className: string; implementation: boolean; start: number } | null = null
+    const closeImplementation = (end: number) => {
+      if (!owner?.implementation) return
+      // the instance methods the implementation defines: `- (type)selector {`
+      const body = source.slice(owner.start, end)
+      for (const match of body.matchAll(/^[ \t]*-\s*\(/gm)) {
+        const open = match.index + match[0].length - 1
+        const type = macroArguments(body, open)
+        if (!type) continue
+        const close = body.slice(type.end).search(/[{;]/)
+        if (close === -1) continue
+        const selector = definitionSelector(body.slice(type.end, type.end + close))
+        if (selector) addSelector(owner.className, selector)
+      }
+    }
+    for (const match of source.matchAll(DIRECTIVE)) {
+      const at = match.index
+      const directive = match[0]
+      if (directive === '@end') {
+        closeImplementation(at)
+        owner = null
+        continue
+      }
+      if (directive === '@interface' || directive === '@implementation') {
+        const rest = source.slice(at + directive.length)
+        const extern = /^\s*(RCT_EXTERN_REMAP_MODULE|RCT_EXTERN_MODULE)\s*\(/.exec(rest)
+        if (extern) {
+          const parsed = macroArguments(rest, extern[0].length - 1)
+          if (!parsed) continue
+          const [jsName, className, superclass] =
+            extern[1] === 'RCT_EXTERN_MODULE' ? ['', ...parsed.args] : parsed.args
+          if (!className) continue
+          declarations.modules.push({
+            className,
+            jsName: jsName ?? '',
+            extern: true,
+            file,
+          })
+          if (superclass) declarations.superclasses.set(className, superclass)
+          owner = { className, implementation: false, start: at }
+          continue
+        }
+        const named = /^\s*([A-Za-z_]\w*)\s*(?::\s*([A-Za-z_]\w*))?/.exec(rest)
+        if (!named) continue
+        if (named[2]) declarations.superclasses.set(named[1]!, named[2])
+        if (
+          directive === '@implementation' &&
+          !declarations.implementations.has(named[1]!)
+        )
+          declarations.implementations.set(named[1]!, new Set())
+        owner = {
+          className: named[1]!,
+          implementation: directive === '@implementation',
+          start: at + directive.length + named[0].length,
+        }
+        continue
+      }
+      if (!owner) continue
+      const parsed = macroArguments(source, at + directive.length - 1)
+      if (!parsed) continue
+      const args = parsed.args
+      switch (match[1]) {
+        case 'RCT_EXPORT_MODULE':
+          if (owner.implementation)
+            declarations.modules.push({
+              className: owner.className,
+              jsName: args[0] ?? '',
+              extern: false,
+              file,
+            })
+          break
+        case 'RCT_EXPORT_MODULE_NO_LOAD':
+          declarations.modules.push({
+            className: args[1] || owner.className,
+            jsName: args[0] ?? '',
+            extern: false,
+            file,
+          })
+          break
+        case 'RCT_EXTERN_METHOD':
+        case 'RCT_EXPORT_METHOD':
+          addMethod(owner.className, {
+            jsName: '',
+            objcName: args[0] ?? '',
+            isSync: false,
+          })
+          break
+        case 'RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD':
+        case 'RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD':
+          addMethod(owner.className, {
+            jsName: '',
+            objcName: args[0] ?? '',
+            isSync: true,
+          })
+          break
+        case 'RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD':
+          addMethod(owner.className, {
+            jsName: '',
+            objcName: args[1] ?? '',
+            isSync: true,
+          })
+          break
+        case 'RCT_REMAP_METHOD':
+          addMethod(owner.className, {
+            jsName: args[0] ?? '',
+            objcName: args[1] ?? '',
+            isSync: false,
+          })
+          break
+        case 'RCT_REMAP_BLOCKING_SYNCHRONOUS_METHOD':
+          addMethod(owner.className, {
+            jsName: args[0] ?? '',
+            objcName: args[2] ?? '',
+            isSync: true,
+          })
+          break
+        case '_RCT_EXTERN_REMAP_METHOD':
+          addMethod(owner.className, {
+            jsName: args[0] ?? '',
+            objcName: args[1] ?? '',
+            isSync: args[2] === 'YES',
+          })
+          break
+      }
+    }
+    closeImplementation(source.length)
+  }
+  return declarations
+}
+
+// the superclass Peach compiles that a class's chain reaches
+function compiledSuperclass(
+  className: string,
+  superclasses: Map<string, string>,
+): 'RCTEventEmitter' | 'NSObject' | null {
+  const seen = new Set<string>()
+  let current = superclasses.get(className)
+  while (current && !seen.has(current)) {
+    if (current === 'RCTEventEmitter' || current === 'NSObject') return current
+    seen.add(current)
+    current = superclasses.get(current)
+  }
+  return null
+}
+
+const swiftString = (value: string) => JSON.stringify(value)
+
+function methodsLiteral(methods: MethodInfo[]): string {
+  return `[${methods
+    .map(
+      (method) =>
+        `RCTMethodInfo(jsName: ${swiftString(method.jsName)}, objcName: ${swiftString(method.objcName)}, isSync: ${method.isSync})`,
+    )
+    .join(', ')}]`
+}
+
+// a Swift class exposed to Objective-C as `objcName`: `@objc(objcName)` on it,
+// else a class of that name
+function swiftClassFor(objcName: string, files: Record<string, string>): string | null {
+  const modifiers =
+    '(?:\\s*(?:@\\w+(?:\\([^)]*\\))?|public|open|final|internal|fileprivate|private))*'
+  const exposed = new RegExp(
+    `@objc\\s*\\(\\s*${objcName}\\s*\\)${modifiers}\\s*class\\s+([A-Za-z_]\\w*)`,
+  )
+  const named = new RegExp(`\\bclass\\s+${objcName}\\b`)
+  let fallback: string | null = null
+  for (const source of Object.values(files)) {
+    const code = swiftCodeMask(source)
+    const match = exposed.exec(code)
+    if (match) return match[1]!
+    if (named.test(code)) fallback = objcName
+  }
+  return fallback
+}
+
+export const BRIDGE_MODULE_FILE_PREFIX = '__peach_react_module_'
+
+/**
+ * the app target's legacy bridge modules, one compile unit each, or null
+ * when the app has no iOS project or registers none. a module the host
+ * cannot provide is a unit with a diagnostic instead of files.
+ */
+export function collectBridgeModuleSources(
+  appRoot: string,
+  signal?: AbortSignal,
+): {
+  units: ExpoSwiftSourceUnit[]
+  failures: { namespace: string; diagnostic: string }[]
+} | null {
+  signal?.throwIfAborted()
+  const iosRoot = path.join(appRoot, 'ios')
+  if (!fs.existsSync(iosRoot)) return null
+  const projects = fs
+    .readdirSync(iosRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && entry.name.endsWith('.xcodeproj'))
+    .map((entry) => path.join(iosRoot, entry.name))
+  const targets = projects.flatMap((project) =>
+    listXcodeAppTargets(project, { requireSources: false }).map((name) => ({
+      project,
+      name,
+    })),
+  )
+  // RCTRegisterModule runs in the one app binary; several targets are
+  // several apps, and nothing here says which one this bundle runs in
+  if (targets.length !== 1) return null
+  const app = readXcodeAppTarget(targets[0]!.project, targets[0]!.name, 'Release', {
+    requireSources: false,
+  })
+  const own = (file: string) =>
+    !file.split(path.sep).some((part) => part === 'Pods' || part === 'node_modules')
+  const objc = app.allSources.filter((file) => /\.mm?$/.test(file) && own(file))
+  if (objc.length === 0) return null
+  // headers declare the superclasses; they sit beside the sources that import them
+  const headers = [...new Set(objc.map((file) => path.dirname(file)))].flatMap((dir) =>
+    fs
+      .readdirSync(dir)
+      .filter((name) => name.endsWith('.h'))
+      .sort()
+      .map((name) => path.join(dir, name)),
+  )
+  const declarations = parseObjectiveCModules(
+    [...objc, ...headers].map((file) => ({ file, text: fs.readFileSync(file, 'utf8') })),
+  )
+  if (declarations.modules.length === 0) return null
+  const namespace = app.moduleName.replace(/[^A-Za-z0-9_]/g, '_')
+  const swiftFiles: Record<string, string> = {}
+  for (const file of app.sources.filter(own)) {
+    const relative = path.relative(iosRoot, file)
+    if (relative.startsWith('..') || path.isAbsolute(relative))
+      throw new Error(`${file}: app Swift source outside ${iosRoot}`)
+    swiftFiles[`Sources/${namespace}/${relative.split(path.sep).join('/')}`] =
+      `#sourceLocation(file: ${JSON.stringify(file)}, line: 1)\n${fs.readFileSync(file, 'utf8')}`
+  }
+  const units: ExpoSwiftSourceUnit[] = []
+  const failures: { namespace: string; diagnostic: string }[] = []
+  const seen = new Set<string>()
+  for (const module of declarations.modules) {
+    signal?.throwIfAborted()
+    if (seen.has(module.className)) continue
+    seen.add(module.className)
+    const moduleId = `${namespace}.${module.className}`
+    const methods = declarations.methods.get(module.className) ?? []
+    const swiftClass = module.extern ? swiftClassFor(module.className, swiftFiles) : null
+    const unit: ExpoSwiftSourceUnit = {
+      namespace,
+      moduleId,
+      classes: [],
+      bridgeModules: [],
+      files: {},
+      frameworks: [],
+      swiftLanguageMode: app.languageMode,
+    }
+    if (swiftClass) {
+      const register = `__peachReactModule_${module.className}`
+      unit.files = swiftSourceClosure(swiftFiles, [swiftClass])
+      unit.files[
+        `Sources/${namespace}/${BRIDGE_MODULE_FILE_PREFIX}${module.className}.swift`
+      ] =
+        `import React\n\n// ${module.file}: RCT_EXTERN_MODULE(${module.className})\npublic func ${register}() -> RCTModuleHost.Registration {\n  RCTModuleHost.Registration(className: ${swiftString(module.className)}, moduleName: ${swiftString(module.jsName)}, methods: ${methodsLiteral(methods)}, make: { ${swiftClass}() })\n}\n`
+      unit.bridgeModules = [`${namespace}.${register}()`]
+    } else {
+      const superclass = compiledSuperclass(module.className, declarations.superclasses)
+      const selectors = declarations.implementations.get(module.className)
+      if (!selectors || !superclass) {
+        failures.push({
+          namespace: moduleId,
+          diagnostic: !selectors
+            ? `${module.file}: no Swift class or Objective-C @implementation provides ${module.className}`
+            : `${module.file}: ${module.className}'s superclass ${declarations.superclasses.get(module.className) ?? '(none)'} is Objective-C, which Peach does not compile`,
+        })
+        continue
+      }
+      unit.bridgeModules = [
+        `RCTModuleHost.Registration(className: ${swiftString(module.className)}, moduleName: ${swiftString(module.jsName)}, methods: ${methodsLiteral(methods)}, objectiveCSelectors: ${JSON.stringify([...selectors].sort())}, superclass: { ${superclass}() })`,
+      ]
+    }
+    units.push(unit)
+  }
+  return { units, failures }
+}

package/src/react-native-host-modules.ts

@@ -18,6 +18,10 @@ export const REACT_NATIVE_PASSTHROUGH_SPECIFIERS: readonly string[] = [
   // expo's metro-runtime dials metro's message socket with this WebSocket,
   // which runs against the engine's WebSocketModule and BlobModule.
   'react-native/Libraries/WebSocket',
+  // that WebSocket extends upstream's EventTarget and builds its MessageEvent
+  // and CloseEvent from the same dom event classes; a stubbed class there is
+  // not a constructor to extend.
+  'react-native/src/private/webapis',
   'react-native/Libraries/Blob/Blob',
   'react-native/Libraries/Blob/BlobManager',
   'react-native/Libraries/Blob/BlobRegistry',

package/src/swift-binary-modules.ts

@@ -6,11 +6,11 @@
 
 import { createHash } from 'node:crypto'
 import fs from 'node:fs'
-import os from 'node:os'
 import path from 'node:path'
+import { cacheDir as peachCacheDir } from './home-paths'
 import type { SwiftPackageBinary } from './swift-packages'
 
-const cacheDir = path.join(os.tmpdir(), 'peach-swift-binary-modules')
+const cacheDir = path.join(peachCacheDir(), 'swift-binary-modules')
 
 // the first `<name>.framework` segment of each path: a framework's own
 // nested frameworks and macOS Versions/ trees are not modules of the target