peachsim 0.1.1640 → 0.1.1644

package/src/swift-root-lock.ts

@@ -0,0 +1,302 @@
+import {
+  spawn,
+  spawnSync,
+  type ChildProcess,
+  type ChildProcessByStdio,
+  type SpawnOptions,
+} from 'node:child_process'
+import { createHash, randomUUID } from 'node:crypto'
+import {
+  linkSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
+import path from 'node:path'
+import { rnxHomeDir } from './home-paths'
+import { terminateProcessGroup } from './process-group'
+import type { Readable, Writable } from 'node:stream'
+
+const POLL_MS = 250
+// ps derives a start time from the boot time, which drifts by a second or two
+// on linux; a reused pid starts later than this.
+const START_TOLERANCE_MS = 2_000
+
+interface ProcessRow {
+  pid: number
+  pgid: number
+  zombie: boolean
+  start: number
+}
+
+interface Identity {
+  pid: number
+  start: number
+}
+
+interface Generation {
+  number: number
+  holder: Identity
+  released: boolean
+}
+
+function errorCode(error: unknown): string | undefined {
+  return error instanceof Error && 'code' in error && typeof error.code === 'string'
+    ? error.code
+    : undefined
+}
+
+// ps prints start times without a zone, so every reader asks for utc: a
+// holder and a waiter then agree whatever their own time zones are.
+function parseStart(text: string): number {
+  const start = Date.parse(`${text} UTC`)
+  if (Number.isNaN(start)) throw new Error(`unreadable process start time "${text}"`)
+  return start
+}
+
+// the whole table in one read. an unreadable table throws: a lock that cannot
+// tell whether its holder is gone must not guess.
+function processTable(): ProcessRow[] {
+  const result = spawnSync('ps', ['-A', '-o', 'pid=,pgid=,stat=,lstart='], {
+    encoding: 'utf8',
+    env: { ...process.env, LC_ALL: 'C', TZ: 'UTC' },
+    stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: 10_000,
+    killSignal: 'SIGKILL',
+  })
+  if (result.error || result.status !== 0) {
+    throw new Error(
+      `swift root lock cannot read the process table: ${
+        result.error?.message || result.stderr.trim() || `ps exited ${result.status}`
+      }`,
+    )
+  }
+  return result.stdout
+    .split('\n')
+    .filter((line) => line.trim())
+    .map((line) => {
+      const match = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.+?)\s*$/.exec(line)
+      if (!match)
+        throw new Error(`swift root lock cannot parse a process table row: ${line}`)
+      return {
+        pid: Number(match[1]),
+        pgid: Number(match[2]),
+        zombie: match[3]!.startsWith('Z'),
+        start: parseStart(match[4]!),
+      }
+    })
+}
+
+function sameProcess(row: ProcessRow, identity: Identity): boolean {
+  return (
+    row.pid === identity.pid && Math.abs(row.start - identity.start) <= START_TOLERANCE_MS
+  )
+}
+
+function ownIdentity(pid: number): Identity {
+  const row = processTable().find(
+    (candidate) => candidate.pid === pid && !candidate.zombie,
+  )
+  if (!row) throw new Error(`swift root lock cannot find process ${pid}`)
+  return { pid, start: row.start }
+}
+
+function parseIdentity(text: string): Identity {
+  const value: unknown = JSON.parse(text)
+  if (
+    value &&
+    typeof value === 'object' &&
+    'pid' in value &&
+    typeof value.pid === 'number' &&
+    'start' in value &&
+    typeof value.start === 'number'
+  )
+    return { pid: value.pid, start: value.start }
+  throw new Error(`swift root lock record is not a process identity: ${text}`)
+}
+
+function pause(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve) => {
+    const done = () => {
+      clearTimeout(timer)
+      signal?.removeEventListener('abort', done)
+      resolve()
+    }
+    const timer = setTimeout(done, ms)
+    signal?.addEventListener('abort', done, { once: true })
+  })
+}
+
+const name = (number: number, suffix: string) =>
+  `${String(number).padStart(12, '0')}.${suffix}`
+
+function generationNumbers(directory: string): number[] {
+  const numbers = new Set<number>()
+  for (const entry of readdirSync(directory)) {
+    const match = /^(\d{12})\./.exec(entry)
+    if (match) numbers.add(Number(match[1]))
+  }
+  return [...numbers].sort((a, b) => a - b)
+}
+
+function readGeneration(directory: string, number: number): Generation | null {
+  let owner: string
+  try {
+    owner = readFileSync(path.join(directory, name(number, 'owner')), 'utf8')
+  } catch (error) {
+    // a newer holder cleaned this generation after it was listed.
+    if (errorCode(error) === 'ENOENT') return null
+    throw error
+  }
+  return {
+    number,
+    holder: parseIdentity(owner),
+    released: readdirSync(directory).includes(name(number, 'released')),
+  }
+}
+
+// children are registered before they run and only while the holder lives, so
+// reading them after the holder is seen dead lists every one it started.
+function readChildren(directory: string, number: number): Identity[] {
+  const prefix = name(number, 'child.')
+  return readdirSync(directory)
+    .filter((entry) => entry.startsWith(prefix))
+    .map((entry) => parseIdentity(readFileSync(path.join(directory, entry), 'utf8')))
+}
+
+// a child leads its own session, so its group is its pid; a group id stays
+// taken while any member lives, so a leader started later is another process.
+function groupAlive(table: ProcessRow[], leader: Identity): boolean {
+  const row = table.find((candidate) => candidate.pid === leader.pid)
+  if (row && !sameProcess(row, leader)) return false
+  return table.some((candidate) => candidate.pgid === leader.pid && !candidate.zombie)
+}
+
+/** compiler processes whose lifetime the root lock covers. */
+export interface SwiftRootLease {
+  /** starts `command` in its own process group, recorded under the lock before
+   *  it runs, so the root stays held while that group lives even if this
+   *  process dies. */
+  spawn(
+    command: string,
+    args: string[],
+    options: SpawnOptions,
+  ): ChildProcessByStdio<Writable, Readable, Readable>
+}
+
+/** runs `work` as the only process using a swift build root. the in-process
+ *  queue orders one process's requests; two processes sharing a root each
+ *  rewrite its sources and manifest, and swiftpm's own build lock only orders
+ *  the builds, so a build can compile the other process's sources and then
+ *  read back that process's executable.
+ *
+ *  holders are numbered. the newest generation holds the root; claiming the
+ *  next number is one exclusive link, so exactly one claimant wins and no
+ *  record is ever moved or replaced. a generation is free once its holder
+ *  released it, or once its holder process and every compiler group it
+ *  recorded are gone. an unreadable process table or an unkillable compiler
+ *  keeps the root held. the lock lives beside the root's tree, never inside
+ *  it: a write sweeps every file of the tree it does not name. */
+export async function withSwiftRootLock<T>(
+  root: string,
+  work: (lease: SwiftRootLease) => Promise<T>,
+  signal?: AbortSignal,
+): Promise<T> {
+  const directory = path.join(
+    rnxHomeDir(),
+    'cache',
+    'swift-root-locks',
+    createHash('sha256').update(root).digest('hex').slice(0, 32),
+  )
+  mkdirSync(directory, { recursive: true })
+  const token = randomUUID()
+  const owner = JSON.stringify(ownIdentity(process.pid))
+  const pending = path.join(directory, `pending.${token}`)
+  let held = 0
+  for (;;) {
+    signal?.throwIfAborted()
+    const newest = generationNumbers(directory).at(-1) ?? 0
+    const current = newest > 0 ? readGeneration(directory, newest) : null
+    if (newest > 0 && !current) continue
+    if (current && !current.released) {
+      const table = processTable()
+      if (table.some((row) => !row.zombie && sameProcess(row, current.holder))) {
+        await pause(POLL_MS, signal)
+        continue
+      }
+      const children = readChildren(directory, newest)
+      if (children.some((child) => groupAlive(table, child))) {
+        await pause(POLL_MS, signal)
+        continue
+      }
+    }
+    // the record is complete before it takes the number, so a waiter never
+    // reads half a record.
+    writeFileSync(pending, owner)
+    try {
+      linkSync(pending, path.join(directory, name(newest + 1, 'owner')))
+    } catch (error) {
+      if (errorCode(error) === 'EEXIST') continue
+      throw error
+    } finally {
+      rmSync(pending, { force: true })
+    }
+    // a claimant that listed the directory before older generations were
+    // cleaned can take a number below the newest; it never held the root.
+    const numbers = generationNumbers(directory)
+    if (numbers.at(-1) !== newest + 1) {
+      rmSync(path.join(directory, name(newest + 1, 'owner')), { force: true })
+      continue
+    }
+    held = newest + 1
+    for (const number of numbers)
+      if (number < held)
+        for (const entry of readdirSync(directory))
+          if (entry.startsWith(name(number, '')))
+            rmSync(path.join(directory, entry), { force: true })
+    break
+  }
+  const children: ChildProcess[] = []
+  const lease: SwiftRootLease = {
+    spawn(command, args, options) {
+      // the child waits for its registration before it runs, and exits without
+      // running if this process dies first.
+      const child = spawn(
+        '/bin/sh',
+        ['-c', 'IFS= read -r go || exit 1; exec "$@" </dev/null', 'sh', command, ...args],
+        { ...options, detached: true, stdio: ['pipe', 'pipe', 'pipe'] },
+      )
+      child.stdin!.on('error', () => {})
+      children.push(child)
+      try {
+        if (child.pid === undefined) {
+          child.once('error', () => {})
+          throw new Error(`could not start ${command}`)
+        }
+        const childPending = `${pending}.child.${child.pid}`
+        try {
+          // publish a complete identity before opening the compiler gate. a
+          // crash or failed write leaves only an ignored pending file.
+          writeFileSync(childPending, JSON.stringify(ownIdentity(child.pid)))
+          linkSync(childPending, path.join(directory, name(held, `child.${child.pid}`)))
+        } finally {
+          rmSync(childPending, { force: true })
+        }
+      } catch (error) {
+        child.stdin!.destroy()
+        throw error
+      }
+      child.stdin!.end('go\n')
+      return child
+    },
+  }
+  try {
+    return await work(lease)
+  } finally {
+    // a compiler that outlives its caller would still read the root.
+    await Promise.all(children.map((child) => terminateProcessGroup(child, 'SIGKILL', 0)))
+    writeFileSync(path.join(directory, name(held, 'released')), '')
+  }
+}

package/src/swift-submit.ts

@@ -154,8 +154,10 @@ export type SwiftCompileOutcome =
    * the build is running; poll the same source set again. One build is tens of
    * seconds and a service-binding request is cancelled at about four, so the
    * container answers this before the connection dies and the caller polls.
+   * `stage` is the latest stage the compiler reported for this build, absent
+   * before it reports one.
    */
-  | { status: 'compiling'; hash: string }
+  | { status: 'compiling'; hash: string; stage?: string }
   /** refused before any work: no entry, too many files, over a cap, over a rate limit. */
   | { status: 'refused'; detail: string }
   /** the compiler ran and failed; detail carries its diagnostic verbatim. */
@@ -333,7 +335,11 @@ function isSwiftCompileOutcome(value: unknown): value is SwiftCompileOutcome {
         (value.native === undefined || isSwiftNativeModules(value.native))
       )
     case 'compiling':
-      return typeof value.hash === 'string' && /^[a-f0-9]{64}$/.test(value.hash)
+      return (
+        typeof value.hash === 'string' &&
+        /^[a-f0-9]{64}$/.test(value.hash) &&
+        (value.stage === undefined || typeof value.stage === 'string')
+      )
     case 'refused':
     case 'failed':
       return typeof value.detail === 'string'
@@ -405,7 +411,10 @@ export async function compileSwiftProject(
   },
   origin: string,
   signal?: AbortSignal,
+  /** called when a poll reports a compiler stage the previous poll did not. */
+  onStage?: (stage: string) => void,
 ): Promise<SwiftModuleAddress> {
+  let lastStage: string | undefined
   while (true) {
     signal?.throwIfAborted()
     const outcome = await submit(work)
@@ -431,6 +440,10 @@ export async function compileSwiftProject(
           ...(outcome.native === undefined ? {} : { native: outcome.native }),
         }
       case 'compiling':
+        if (outcome.stage !== undefined && outcome.stage !== lastStage) {
+          lastStage = outcome.stage
+          onStage?.(outcome.stage)
+        }
         await new Promise<void>((resolve, reject) => {
           const finish = () => {
             signal?.removeEventListener('abort', abort)

package/src/swiftContract.ts

@@ -17,6 +17,18 @@ export interface SwiftResourceBundle {
   path: string
 }
 
+export interface SwiftObjCPeerClass {
+  name: string
+  header: string
+}
+
+export interface SwiftObjCImplementationPreparation {
+  receipt: string
+  objects: { target: string; source: string; file: string }[]
+  metadata?: string
+  registration?: string
+}
+
 export interface SwiftMetalLibrarySource extends SwiftMetalSource {
   bundlePath: string
 }

package/src/xcode-project.ts

@@ -399,15 +399,22 @@ function targetSettings(
     if (!config) return []
     const name = str(config.name) ?? configuration
     const base = str(config.baseConfigurationReference)
+    const anchor = str(config.baseConfigurationReferenceAnchor)
+    const relative = str(config.baseConfigurationReferenceRelativePath)
     const own = isDict(config.buildSettings) ? config.buildSettings : {}
-    const baseFile = base ? project.resolvePath(base) : null
+    const directory = anchor ? project.resolvePath(anchor) : null
+    const baseFile = base
+      ? project.resolvePath(base)
+      : directory && relative
+        ? path.resolve(directory, relative)
+        : null
     if (
       options.requireSources !== false &&
-      base &&
+      (base || anchor || relative) &&
       (!baseFile || !fs.existsSync(baseFile))
     )
       throw new Error(
-        `Unable to open base configuration reference file '${baseFile ?? base}'`,
+        `Unable to open base configuration reference file '${baseFile ?? base ?? relative ?? anchor}'`,
       )
     const read: string[] = []
     const fromFile = baseFile ? readXcconfig(baseFile, read) : {}
@@ -458,6 +465,9 @@ function targetSettings(
         return applyOperator(get('PRODUCT_NAME'), 'c99extidentifier')
       case 'EXECUTABLE_NAME':
         return get('PRODUCT_NAME')
+      // the native default of CoreBuildSystem.xcspec
+      case 'EXCLUDED_RECURSIVE_SEARCH_PATH_SUBDIRECTORIES':
+        return '*.nib *.lproj *.framework *.gch *.xcode* *.xcassets *.icon (*) .DS_Store CVS .svn .git .hg *.pbproj *.pbxproj'
       case 'AppIdentifierPrefix':
       case 'TeamIdentifierPrefix': {
         // only a signed build has a team prefix
@@ -485,6 +495,65 @@ function settingList(value: string): string[] {
   return items
 }
 
+// xcode expands a trailing `/**` into the directory and every directory below
+// it, skipping subdirectories whose name matches EXCLUDED_RECURSIVE_SEARCH_PATH_SUBDIRECTORIES
+// unless INCLUDED_RECURSIVE_SEARCH_PATH_SUBDIRECTORIES matches it too, and following
+// links unless RECURSIVE_SEARCH_PATHS_FOLLOW_SYMLINKS is NO; a missing base names nothing.
+function expandSearchPath(
+  directory: string,
+  rules: { excluded: RegExp[]; included: RegExp[]; followLinks: boolean },
+): string[] {
+  if (path.basename(directory) !== '**') return [directory]
+  const expanded: string[] = []
+  const seen = new Set<string>()
+  // native lists each level before the next, entries sorted by name.
+  const queue = [path.dirname(directory)]
+  for (let at = 0; at < queue.length; at++) {
+    const current = queue[at]!
+    let real: string
+    try {
+      real = fs.realpathSync(current)
+    } catch {
+      continue
+    }
+    if (!fs.statSync(real).isDirectory() || seen.has(real)) continue
+    seen.add(real)
+    expanded.push(current)
+    for (const entry of fs
+      .readdirSync(real, { withFileTypes: true })
+      .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))) {
+      if (entry.isSymbolicLink() ? !rules.followLinks : !entry.isDirectory()) continue
+      if (
+        rules.excluded.some((pattern) => pattern.test(entry.name)) &&
+        !rules.included.some((pattern) => pattern.test(entry.name))
+      )
+        continue
+      queue.push(path.join(current, entry.name))
+    }
+  }
+  return expanded
+}
+
+// the recursive search path rules a target's build settings select.
+function recursiveSearchRules(settings: (key: string) => string) {
+  const glob = (pattern: string) =>
+    new RegExp(
+      `^${pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replaceAll('*', '.*')
+        .replaceAll('?', '.')}$`,
+    )
+  return {
+    excluded: settingList(settings('EXCLUDED_RECURSIVE_SEARCH_PATH_SUBDIRECTORIES')).map(
+      glob,
+    ),
+    included: settingList(settings('INCLUDED_RECURSIVE_SEARCH_PATH_SUBDIRECTORIES')).map(
+      glob,
+    ),
+    followLinks: settings('RECURSIVE_SEARCH_PATHS_FOLLOW_SYMLINKS') !== 'NO',
+  }
+}
+
 // the conditions swift compiles a target with: its active compilation
 // conditions and each `-D` in its other swift flags, as xcode passes them.
 function compilationConditions(settings: (key: string) => string): string[] {
@@ -1035,6 +1104,7 @@ export function readXcodeAppTarget(
     for (const file of read) xcconfigs.add(file)
     const swiftVersion = Number.parseFloat(settings('SWIFT_VERSION') || '5')
     const members = targetMembers(ref, settings, options, keys, xcconfigs)
+    const searchRules = recursiveSearchRules(settings)
     const implementations = members.allSources.filter((file) =>
       /\.(c|cc|cpp|cxx|m|mm)$/.test(file),
     )
@@ -1085,10 +1155,10 @@ export function readXcodeAppTarget(
                 headerSearchPaths: [
                   ...settingList(settings('HEADER_SEARCH_PATHS')),
                   ...settingList(settings('USER_HEADER_SEARCH_PATHS')),
-                ].map(absolute),
-                frameworkSearchPaths: settingList(settings('FRAMEWORK_SEARCH_PATHS')).map(
-                  absolute,
-                ),
+                ].flatMap((raw) => expandSearchPath(absolute(raw), searchRules)),
+                frameworkSearchPaths: settingList(
+                  settings('FRAMEWORK_SEARCH_PATHS'),
+                ).flatMap((raw) => expandSearchPath(absolute(raw), searchRules)),
                 flags: [
                   ...(settings('CLANG_ENABLE_OBJC_ARC') === 'YES' ? ['-fobjc-arc'] : []),
                   ...(settings('CLANG_ENABLE_OBJC_WEAK') === 'YES'