peachsim 0.1.1620 → 0.1.1635

package/src/swift-packages.ts

@@ -2,14 +2,16 @@
 // each linked product resolves through swiftpm's own reading of its package
 // (swift-package-manifest.ts) to the source targets that build it; remote
 // packages are fetched at the revision the app's Package.resolved pins, into
-// .build/peach/checkouts under the app's root. swift and c-family source
+// PEACH_HOME/cache/swift-packages, isolated by the app root. swift and c-family source
 // targets use the common compiler backend. objective-c, assembly and binary
 // targets the host built no stand-in for stay missing with their reason;
 // the targets beside them still compile.
 
 import { execFileSync } from 'node:child_process'
+import { createHash } from 'node:crypto'
 import fs from 'node:fs'
 import path from 'node:path'
+import { cacheDir } from './home-paths'
 import {
   swiftImplicitResourcePaths,
   swiftPackageIdentity,
@@ -19,7 +21,7 @@ import {
 import {
   swiftPackageManifest,
   swiftTargetFiles,
-  type SwiftManifestDefine,
+  type SwiftManifestSetting,
   type SwiftPackageManifest,
 } from './swift-package-manifest'
 
@@ -43,7 +45,8 @@ export interface SwiftPackageSourceTarget extends SwiftPackageTarget {
   packageDir: string
   remote: boolean
   /** the conditions its manifest defines, before a build configuration picks them. */
-  packageDefines: SwiftManifestDefine[]
+  packageDefines: SwiftManifestSetting[]
+  packageLibraries: SwiftManifestSetting[]
 }
 
 /** why a product or module does not compile, and where it comes from. */
@@ -74,22 +77,29 @@ export interface SwiftPackageBinary {
   dir: string
   /** a linked product's closure reaches it, so the app links it. */
   reached: boolean
+  /** a source Objective-C target: public headers relative to dir. */
+  publicHeaders?: string
+  /** dependency module public headers, relative to dir. */
+  headerDependencies?: { module: string; path: string }[]
 }
 
-/** where checkouts live, relative to the app's root. */
-export const REMOTE_CHECKOUTS = path.join('.build', 'peach', 'checkouts')
+/** dependency checkouts belong to peach, isolated by the canonical app root. */
+export function remoteSwiftCheckouts(root: string): string {
+  const key = createHash('sha256')
+    .update(fs.realpathSync(root))
+    .digest('hex')
+    .slice(0, 32)
+  fs.mkdirSync(cacheDir(), { recursive: true })
+  return path.join(fs.realpathSync(cacheDir()), 'swift-packages', key, 'checkouts')
+}
 
 // sources requiring an objective-c runtime or assembly lowering.
 const UNSUPPORTED_NATIVE = /\.(m|mm|s|S)$/
 
 const BINARY = 'is a binary framework'
-// of the reasons a target or product cannot compile, a binary framework's
-// leads: no source exists for it, while another target can retain its
-// source-specific reason
-const blocker = (reasons: (string | null)[]): string | null =>
-  reasons.find((reason) => reason?.includes(BINARY)) ??
-  reasons.find((reason) => reason !== null) ??
-  null
+// retain every independent blocker in dependency order. a product can reach
+// several unsupported targets, and fixing one must not reveal a hidden next one.
+const blockers = (reasons: readonly string[][]): string[] => [...new Set(reasons.flat())]
 
 interface Pin {
   location: string
@@ -185,7 +195,7 @@ export function resolveSwiftPackages(options: {
     binaries: [],
   }
   const pins = resolved ? readPins(resolved) : null
-  const checkouts = path.join(rootDir, REMOTE_CHECKOUTS)
+  const checkouts = remoteSwiftCheckouts(rootDir)
 
   const packages = new Map<string, LoadedPackage | string>()
   // a package by local directory or remote url, or why it cannot load
@@ -205,8 +215,6 @@ export function resolveSwiftPackages(options: {
           : 'no Package.resolved pins it; resolve packages in Xcode once'
       } else {
         fs.mkdirSync(checkouts, { recursive: true })
-        // fetched sources never show up as changes in the app's repository
-        fs.writeFileSync(path.join(path.dirname(checkouts), '.gitignore'), '*\n')
         loaded = {
           source: source.url,
           remote: true,
@@ -219,35 +227,40 @@ export function resolveSwiftPackages(options: {
   }
 
   const targets = new Map<string, SwiftPackageSourceTarget>()
-  // why each target of each package cannot compile, or null once it can
-  const targetOutcomes = new Map<string, string | null>()
-  const resolveTarget = (pkg: LoadedPackage, name: string): string | null => {
+  // every reason each target cannot compile; empty once it can
+  const targetOutcomes = new Map<string, string[]>()
+  const resolveTarget = (pkg: LoadedPackage, name: string): string[] => {
     const key = `${pkg.manifest.dir}\0${name}`
     if (targetOutcomes.has(key)) return targetOutcomes.get(key)!
     // a dependency cycle resolves as compiling; swiftpm rejects real cycles
-    targetOutcomes.set(key, null)
-    const outcome = ((): string | null => {
-      if (provided.has(name)) return null
+    targetOutcomes.set(key, [])
+    const outcome = ((): string[] => {
+      if (provided.has(name)) return []
       const target = pkg.manifest.targets.get(name)
-      if (!target) return `${path.basename(pkg.manifest.dir)} declares no target ${name}`
-      if (target.type === 'binary') {
-        const gap = options.binaryGaps?.get(name)
-        return `${name} ${BINARY}${gap ? `; ${gap}` : ''}`
-      }
-      if (target.type === 'system') return `${name} is a system C library`
-      if (target.type !== 'regular') return `${name} is a ${target.type} target`
-      const files = swiftTargetFiles(pkg.manifest, target)
-      if (files.some((file) => UNSUPPORTED_NATIVE.test(file)))
-        return `${name} is an Objective-C or assembly target`
+      if (!target)
+        return [`${path.basename(pkg.manifest.dir)} declares no target ${name}`]
+      const files =
+        target.type === 'regular' || target.type === 'system'
+          ? swiftTargetFiles(pkg.manifest, target)
+          : []
+      const gap = options.binaryGaps?.get(name)
+      const ownReason =
+        target.type === 'binary'
+          ? `${name} ${BINARY}${gap ? `; ${gap}` : ''}`
+          : target.type !== 'regular' && target.type !== 'system'
+            ? `${name} is a ${target.type} target`
+            : files.some((file) => UNSUPPORTED_NATIVE.test(file))
+              ? `${name} is an Objective-C or assembly target${gap ? `; ${gap}` : ''}`
+              : null
       // every dependency resolves, so a failing one never hides the rest
       // of the closure from the compile or from the report
       const reasons = target.dependencies.map((dependency) => {
         if (dependency.kind === 'target') return resolveTarget(pkg, dependency.name)
         const nested = resolveDependencyProduct(pkg, dependency.package, dependency.name)
-        return nested && `${dependency.name}: ${nested}`
+        return nested.map((reason) => `${dependency.name}: ${reason}`)
       })
-      const blocked = blocker(reasons)
-      if (blocked) return blocked
+      const blocked = blockers([ownReason ? [ownReason] : [], ...reasons])
+      if (blocked.length > 0) return blocked
       const relative = files.map((file) => path.relative(target.dir, file))
       targets.set(`${pkg.manifest.dir}\0${name}`, {
         name,
@@ -257,6 +270,7 @@ export function resolveSwiftPackages(options: {
         packageDir: pkg.manifest.dir,
         remote: pkg.remote,
         packageDefines: target.defines,
+        packageLibraries: target.libraries,
         dependencies: target.dependencies.flatMap((dependency) => {
           if (dependency.kind === 'target') return [dependency]
           if (provided.has(dependency.name)) return []
@@ -265,32 +279,35 @@ export function resolveSwiftPackages(options: {
             source &&
             packages.get('dir' in source ? path.resolve(source.dir) : source.url)
           return nested && typeof nested !== 'string'
-            ? (nested.manifest.products.get(dependency.name) ?? []).map((name): SwiftTargetDependency => ({
-                kind: 'target',
-                name,
-              }))
+            ? (nested.manifest.products.get(dependency.name) ?? []).map(
+                (name): SwiftTargetDependency => ({
+                  kind: 'target',
+                  name,
+                }),
+              )
             : []
         }),
         executable: false,
+        ...(target.type === 'system' ? { systemLibrary: true } : {}),
         languageMode: target.languageMode,
         mainActorIsolation: target.mainActorIsolation,
         resources:
           target.declaresResources || swiftImplicitResourcePaths(relative).length > 0,
       })
-      return null
+      return []
     })()
     targetOutcomes.set(key, outcome)
     return outcome
   }
   // products resolved anywhere in the closure, by package, with why one
   // cannot compile: a wrapper package's product is often the module name
-  const productOutcomes = new Map<string, { pkg: LoadedPackage; reason: string | null }>()
-  const resolveProduct = (pkg: LoadedPackage, product: string): string | null => {
-    if (provided.has(product)) return null
+  const productOutcomes = new Map<string, { pkg: LoadedPackage; reason: string[] }>()
+  const resolveProduct = (pkg: LoadedPackage, product: string): string[] => {
+    if (provided.has(product)) return []
     const roots = pkg.manifest.products.get(product)
     const reason = !roots
-      ? `${path.basename(pkg.manifest.dir)} has no library ${product}`
-      : blocker(roots.map((name) => resolveTarget(pkg, name)))
+      ? [`${path.basename(pkg.manifest.dir)} has no library ${product}`]
+      : blockers(roots.map((name) => resolveTarget(pkg, name)))
     productOutcomes.set(`${pkg.manifest.dir}\0${product}`, { pkg, reason })
     return reason
   }
@@ -299,18 +316,18 @@ export function resolveSwiftPackages(options: {
     pkg: LoadedPackage,
     packageName: string,
     product: string,
-  ): string | null => {
-    if (provided.has(product)) return null
+  ): string[] => {
+    if (provided.has(product)) return []
     const dependency = pkg.manifest.packages.get(packageName)
     if (!dependency)
-      return `${path.basename(pkg.manifest.dir)} names no package ${packageName}`
+      return [`${path.basename(pkg.manifest.dir)} names no package ${packageName}`]
     if ('dir' in dependency) {
       const loaded = load({ kind: 'local', dir: dependency.dir })
-      return typeof loaded === 'string' ? loaded : resolveProduct(loaded, product)
+      return typeof loaded === 'string' ? [loaded] : resolveProduct(loaded, product)
     }
-    if (!options.provided) return null
+    if (!options.provided) return []
     const loaded = load({ kind: 'remote', url: dependency.url })
-    return typeof loaded === 'string' ? loaded : resolveProduct(loaded, product)
+    return typeof loaded === 'string' ? [loaded] : resolveProduct(loaded, product)
   }
 
   const unnamed = () =>
@@ -326,11 +343,11 @@ export function resolveSwiftPackages(options: {
         : load(source)
     const reason =
       pkg === undefined
-        ? 'no package the workspace references vends it'
+        ? ['no package the workspace references vends it']
         : typeof pkg === 'string'
-          ? pkg
+          ? [pkg]
           : resolveProduct(pkg, product)
-    if (reason)
+    if (reason.length > 0)
       result.unavailable.set(product, {
         source:
           source.kind === 'remote'
@@ -340,7 +357,7 @@ export function resolveSwiftPackages(options: {
               : source.kind === 'local'
                 ? source.dir
                 : 'the workspace',
-        reason,
+        reason: reason.join('; '),
       })
   }
 
@@ -352,24 +369,35 @@ export function resolveSwiftPackages(options: {
       if (target.type === 'test' || target.type === 'plugin' || target.type === 'macro')
         continue
       if (target.type === 'executable') continue
-      if (target.type === 'binary')
+      const objc =
+        target.type === 'regular' &&
+        swiftTargetFiles(pkg.manifest, target).some((file) => /\.(m|mm)$/.test(file))
+      if (target.type === 'binary' || objc)
         result.binaries.push({
           target: name,
           source: pkg.source,
           url: target.url,
           checksum: target.checksum,
-          dir: target.dir,
+          dir: objc ? pkg.manifest.dir : target.dir,
           reached: false,
+          ...(objc
+            ? {
+                publicHeaders: path.relative(
+                  pkg.manifest.dir,
+                  path.join(target.dir, target.publicHeadersPath),
+                ),
+              }
+            : {}),
         })
       const reason = resolveTarget(pkg, name)
-      if (reason && !result.modules.has(name))
-        result.modules.set(name, { source: pkg.source, reason })
+      if (reason.length > 0 && !result.modules.has(name))
+        result.modules.set(name, { source: pkg.source, reason: reason.join('; ') })
     }
   }
   for (const [key, { pkg, reason }] of productOutcomes) {
     const product = key.slice(key.indexOf('\0') + 1)
-    if (reason && !result.modules.has(product))
-      result.modules.set(product, { source: pkg.source, reason })
+    if (reason.length > 0 && !result.modules.has(product))
+      result.modules.set(product, { source: pkg.source, reason: reason.join('; ') })
   }
   // what compiles is every buildable target in a linked product's closure,
   // decided per target: a product with one target behind a binary still
@@ -410,6 +438,37 @@ export function resolveSwiftPackages(options: {
     if (pkg && typeof pkg !== 'string')
       binary.reached = reached.has(`${pkg.manifest.dir}\0${binary.target}`)
   }
+  for (const binary of result.binaries) {
+    if (binary.publicHeaders === undefined) continue
+    const pkg = packages.get(binary.source)
+    if (!pkg || typeof pkg === 'string') continue
+    const headers = new Map<string, string>()
+    const visited = new Set<string>()
+    const visit = (owner: LoadedPackage, name: string) => {
+      const key = `${owner.manifest.dir}\0${name}`
+      if (visited.has(key)) return
+      visited.add(key)
+      const target = owner.manifest.targets.get(name)
+      if (!target) return
+      const dir = path.join(target.dir, target.publicHeadersPath)
+      for (const dependency of target.dependencies) {
+        if (dependency.kind === 'target') visit(owner, dependency.name)
+        else {
+          const source = owner.manifest.packages.get(dependency.package)
+          const nested =
+            source &&
+            packages.get('dir' in source ? path.resolve(source.dir) : source.url)
+          if (nested && typeof nested !== 'string')
+            for (const root of nested.manifest.products.get(dependency.name) ?? [])
+              visit(nested, root)
+        }
+      }
+      if (name !== binary.target && fs.existsSync(dir))
+        headers.set(name, path.relative(binary.dir, dir))
+    }
+    visit(pkg, binary.target)
+    binary.headerDependencies = [...headers].map(([module, path]) => ({ module, path }))
+  }
   result.targets = [...targets.entries()]
     .filter(([key]) => reached.has(key))
     .map(([, target]) => target)

package/src/swift-standin-emit.ts

@@ -20,6 +20,7 @@ export type GraphSymbol = {
   pathComponents: string[]
   declarationFragments?: SymbolFragment[]
   accessLevel: string
+  functionSignature?: { returns?: SymbolFragment[] }
   availability?: {
     domain?: string
     isUnconditionallyUnavailable?: boolean
@@ -43,6 +44,8 @@ export type StandinOptions = {
   module: string
   /** where the declarations came from, for the banner: sdk, version, artifact. */
   source: string
+  /** source Objective-C targets keep declarations with inert native bodies. */
+  inert?: boolean
   /** modules the source imports beside Foundation and UIKit. */
   imports?: string[]
   /** precise symbol id → swift literal for enum cases and option values. */
@@ -87,7 +90,7 @@ export type StandinResult = {
 }
 
 /** bump when emitted source changes: the stand-in cache keys on it. */
-export const STANDIN_EMIT_VERSION = '6'
+export const STANDIN_EMIT_VERSION = '10'
 
 /** the modules every stand-in source imports. */
 export const STANDIN_IMPORTS = ['Foundation', 'UIKit']
@@ -331,6 +334,47 @@ export function emitSwiftStandin(
     ])
   }
 
+  // DEGRADED(swift-objc-runtime): source objc targets retain their api with inert native bodies.
+  // return values follow the imported declaration, never the app's call sites.
+  const inertValue = (type: string): string => {
+    const value = type.trim().replace(/!$/, '?')
+    if (value.endsWith('?')) return 'nil'
+    if (value === 'Void' || value === '()') return '()'
+    if (value === 'Bool') return 'false'
+    if (
+      /^(?:U?Int(?:8|16|32|64)?|Float|Double|CGFloat|TimeInterval|NSTimeInterval)$/.test(
+        value,
+      )
+    )
+      return '0'
+    if (value === 'String') return '""'
+    if (value.startsWith('[')) return value.includes(':') ? '[:]' : '[]'
+    if (value === 'Any' || value === 'AnyObject') return 'NSObject()'
+    const typeId = typeByPath.get(value.replace(`${options.module}.`, ''))
+    const symbol = typeId && byId.get(typeId)
+    if (typeId && symbol && symbol.kind.identifier === 'swift.enum') {
+      const first = membersOf(typeId).find(
+        (member) => member.kind.identifier === 'swift.enum.case',
+      )
+      if (first) return `.${leaf(first).replace(/\(.*/, '')}`
+    }
+    return `${value}()`
+  }
+  const inertBody = (symbol: GraphSymbol): string => {
+    const declaration = text(symbol)
+    if (symbol.kind.identifier === 'swift.init') {
+      if (/\bconvenience\b/.test(declaration)) return 'self.init()'
+      const parent = owner.get(symbol.identifier.precise)
+      return parent && superclass.has(parent) ? 'super.init()' : ''
+    }
+    const type =
+      symbol.kind.identifier.includes('property') ||
+      symbol.kind.identifier === 'swift.var'
+        ? /:\s*(.*?)\s*(?:\{|$)/.exec(declaration)?.[1]
+        : symbol.functionSignature?.returns?.map((fragment) => fragment.spelling).join('')
+    return type ? `return ${inertValue(type)}` : ''
+  }
+
   const lines: string[] = []
   const owners: string[] = []
   const omit = options.omit ?? new Map<string, string>()
@@ -426,7 +470,8 @@ export function emitSwiftStandin(
         : /\bResult</.test(core)
           ? measured?.resultBody
           : undefined
-      const body = overloadBody ?? measured?.body ?? trap(path)
+      const body =
+        overloadBody ?? measured?.body ?? (options.inert ? inertBody(member) : trap(path))
       switch (member.kind.identifier) {
         case 'swift.property':
         case 'swift.type.property':
@@ -452,7 +497,7 @@ export function emitSwiftStandin(
             return
           }
           emit(
-            `${head}${computed} { get${effects} { ${body} }${settable && !effects ? ` ${parsed.nonmutating ? 'nonmutating ' : ''}set { ${measured?.set ?? trap(path)} }` : ''} }`,
+            `${head}${computed} { get${effects} { ${body} }${settable && !effects ? ` ${parsed.nonmutating ? 'nonmutating ' : ''}set { ${measured?.set ?? (options.inert ? '' : trap(path))} }` : ''} }`,
           )
           return
         }
@@ -646,7 +691,7 @@ export function emitSwiftStandin(
             externalRoot(id) !== null
           )
             emit(
-              `${inner}public required init?(coder: NSCoder) { ${trap(`${path}.init(coder:)`)} }`,
+              `${inner}public required init?(coder: NSCoder) { ${options.inert ? 'return nil' : trap(`${path}.init(coder:)`)} }`,
             )
           emit(`${indent}}`)
           return
@@ -814,7 +859,7 @@ export function emitSwiftStandin(
       .replace(/^(?:weak |unowned )/, '')
       .replace(/^((?:static )?)let /, '$1var ')
     const witness = `${owner}.${leaf(member)}`
-    const body = trap(witness)
+    const body = options.inert ? inertBody(member) : trap(witness)
     if (
       member.kind.identifier === 'swift.property' ||
       member.kind.identifier === 'swift.type.property'
@@ -872,7 +917,7 @@ export function emitSwiftStandin(
           ? measured?.resultBody
           : undefined
       emit(
-        `${attrs}public ${spelled} { ${overloadBody ?? measured?.body ?? trap(path)} }`,
+        `${attrs}public ${spelled} { ${overloadBody ?? measured?.body ?? (options.inert ? inertBody(symbol) : trap(path))} }`,
       )
     } else if (kind === 'swift.var') {
       const parsed = splitAccessors(text(symbol).replace(/^let /, 'var '))
@@ -882,7 +927,9 @@ export function emitSwiftStandin(
       // as `var` with no setter.
       const measured = behavior.get(path)
       if (measured) used.add(path)
-      emit(`public ${parsed.decl} { ${measured?.body ?? trap(path)} }`)
+      emit(
+        `public ${parsed.decl} { ${measured?.body ?? (options.inert ? inertBody(symbol) : trap(path))} }`,
+      )
     } else skipped.push({ path, reason: `unhandled top-level ${kind}` })
   })
 
@@ -929,8 +976,9 @@ export function emitSwiftStandin(
   const imports = [...STANDIN_IMPORTS, ...(options.imports ?? [])]
   const banner = [
     `// stand-in for the binary ${options.module} module, generated from ${options.source}.`,
-    `// do not hand-edit: unconfigured bodies trap because the vendor binary cannot run`,
-    `// in peach; app native stubs may supply configured behavior.`,
+    options.inert
+      ? '// generated from public headers; native behavior is inert in peach.'
+      : '// unconfigured bodies trap because the vendor binary cannot run in peach.',
     '',
     ...imports.map((name) => `import ${name}`),
     '',