peachsim 0.1.1625 → 0.1.1640

package/src/swift-objc-standin.ts

@@ -13,11 +13,12 @@
 // headers import; the stand-in's own typecheck then leaves out whatever peach
 // cannot spell.
 
-import { spawnSync } from 'node:child_process'
+import { execFileSync, spawnSync } from 'node:child_process'
 import { createHash } from 'node:crypto'
 import fs from 'node:fs'
 import path from 'node:path'
 import { IOS_SDK_HEADERS, IOS_SDK_OVERLAYS, IOS_SDK_TARGET } from './swift-objc-sdk'
+import { swiftEnvironment } from './swift-toolchain'
 import type { SymbolGraph } from './swift-standin-emit'
 
 /** a module map and the headers it reaches: a framework's, or a library
@@ -26,6 +27,7 @@ export interface ObjcSurface {
   module: string
   modulemap: string
   headers: string
+  dependencies?: { module: string; headers: string }[]
 }
 
 export interface ObjcView {
@@ -36,6 +38,100 @@ export interface ObjcView {
   imports: string[]
 }
 
+/** bump when importer behavior changes the Swift view independently of SDK headers. */
+export const OBJC_IMPORT_VERSION = '3'
+
+export const NATIVE_GRAPH_SDK_VERSION = '27.1'
+
+const NATIVE_GRAPH_INPUTS = {
+  sdk: NATIVE_GRAPH_SDK_VERSION,
+  settings: 'e68503e5e534e9194af5efe8c636ca8b824e2d8237c5f38ec84aa4d155bc8418',
+  build: 'ff785237ba22f1d8f347a5c4f4c68400a387c6d935ef3a443545a72faef57e70',
+  compiler: 'Apple Swift version 6.4 (swiftlang-6.4.0.34.1 clang-2100.3.34.1)',
+  target: IOS_SDK_TARGET,
+}
+export const NATIVE_GRAPH_ID = createHash('sha256')
+  .update(JSON.stringify(NATIVE_GRAPH_INPUTS))
+  .digest('hex')
+
+/** a mixed framework's swift overlay and underlying clang module load together. */
+export function nativeInterfaceView(
+  surface: ObjcSurface,
+  frameworks: readonly string[],
+  work: string,
+): ObjcView {
+  if (process.platform !== 'darwin')
+    throw new Error('mixed framework declarations require the pinned native iOS SDK')
+  const xcrun = (args: string[]) =>
+    execFileSync('xcrun', args, {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim()
+  const sdk = xcrun(['--sdk', 'iphonesimulator', '--show-sdk-path'])
+  const compiler = xcrun(['--find', 'swiftc'])
+  const version = execFileSync(compiler, ['--version'], { encoding: 'utf8' })
+    .trim()
+    .split('\n')[0]
+  const digest = (file: string) =>
+    createHash('sha256')
+      .update(fs.readFileSync(path.join(sdk, file)))
+      .digest('hex')
+  const actual = {
+    sdk: xcrun(['--sdk', 'iphonesimulator', '--show-sdk-version']),
+    compiler: version,
+    settings: digest('SDKSettings.json'),
+    build: digest('System/Library/CoreServices/SystemVersion.plist'),
+  }
+  const mismatches = Object.entries(actual)
+    .filter(([key, value]) => Reflect.get(NATIVE_GRAPH_INPUTS, key) !== value)
+    .map(
+      ([key, value]) =>
+        `${key}: expected ${Reflect.get(NATIVE_GRAPH_INPUTS, key)}, got ${value}`,
+    )
+  if (mismatches.length)
+    throw new Error(
+      `native declaration SDK or compiler differs from ${NATIVE_GRAPH_ID}: ${mismatches.join('; ')}`,
+    )
+  const toolchainBin = path.dirname(compiler)
+  const search = ['-sdk', sdk, ...frameworks.flatMap((dir) => ['-F', dir])]
+  const out = path.join(work, 'native-graphs')
+  fs.mkdirSync(out, { recursive: true })
+  const run = spawnSync(
+    path.join(toolchainBin, 'swift-symbolgraph-extract'),
+    [
+      '-module-name',
+      surface.module,
+      '-target',
+      IOS_SDK_TARGET,
+      ...search,
+      '-minimum-access-level',
+      'public',
+      '-skip-synthesized-members',
+      '-omit-extension-block-symbols',
+      '-output-dir',
+      out,
+    ],
+    { encoding: 'utf8', maxBuffer: 256 * 1024 * 1024 },
+  )
+  if (run.error) throw run.error
+  if (run.status !== 0)
+    throw new Error(
+      `native interface extraction ${run.signal ?? `exit ${run.status}`}: ${run.stderr.trim().slice(-4000)}`,
+    )
+  const graphs = fs
+    .readdirSync(out)
+    .filter((file) => file.endsWith('.symbols.json'))
+    .sort()
+    .map((file): SymbolGraph => JSON.parse(fs.readFileSync(path.join(out, file), 'utf8')))
+  if (graphs.length === 0)
+    throw new Error('native interface extraction returned no graphs')
+  return {
+    graphs,
+    values: enumValues(graphs, surface, true, toolchainBin, search, work),
+    imports: [],
+  }
+}
+
 // the opaque declarations a failed import asks for, by name.
 type Missing = Map<string, 'class' | 'protocol' | 'struct' | 'macro'>
 
@@ -62,7 +158,7 @@ export const IOS_SDK_ID = createHash('sha256')
 
 // the sdk, written once per content under the cache directory so the module
 // cache keyed by its paths stays warm across stand-ins.
-function iosSdk(cacheDir: string): string {
+export function materializeObjcSdk(cacheDir: string): string {
   const sdk = path.join(cacheDir, 'ios-sdk', IOS_SDK_ID)
   if (fs.existsSync(sdk)) return sdk
   fs.mkdirSync(path.dirname(sdk), { recursive: true })
@@ -115,7 +211,7 @@ export function objcView(
     throw new Error(
       `this peach's Swift has no iOS simulator standard library at ${stdlib}`,
     )
-  const sdk = iosSdk(cacheDir)
+  const sdk = materializeObjcSdk(cacheDir)
   // a framework's module map sits in Modules/ beside Headers/; a library
   // slice keeps it among its headers.
   const framework = path.basename(path.dirname(surface.modulemap)) === 'Modules'
@@ -123,16 +219,16 @@ export function objcView(
   const include = path.join(work, 'include')
   const headersDir = framework
     ? path.join(frameworks, `${surface.module}.framework`, 'Headers')
-    : include
+    : path.join(include, surface.module)
   const originals = new Map(
     headerFiles(surface.headers).map((file) => [
-      file,
+      path.join(headersDir, file),
       fs.readFileSync(path.join(surface.headers, file), 'utf8'),
     ]),
   )
   for (const [file, text] of originals) {
-    fs.mkdirSync(path.dirname(path.join(headersDir, file)), { recursive: true })
-    fs.writeFileSync(path.join(headersDir, file), text)
+    fs.mkdirSync(path.dirname(file), { recursive: true })
+    fs.writeFileSync(file, text)
   }
   if (framework) {
     fs.mkdirSync(path.join(frameworks, `${surface.module}.framework`, 'Modules'), {
@@ -143,7 +239,28 @@ export function objcView(
       path.join(frameworks, `${surface.module}.framework`, 'Modules', 'module.modulemap'),
     )
   } else {
-    fs.copyFileSync(surface.modulemap, path.join(include, 'module.modulemap'))
+    fs.copyFileSync(surface.modulemap, path.join(headersDir, 'module.modulemap'))
+  }
+  // dependency headers take the same learned declarations but never become
+  // the surface's own imports.
+  const dependencyOriginals = new Map<string, string>()
+  for (const dependency of surface.dependencies ?? []) {
+    const dir = path.join(include, dependency.module)
+    fs.mkdirSync(dir, { recursive: true })
+    for (const file of headerFiles(dependency.headers)) {
+      const destination = path.join(dir, file)
+      const text = fs.readFileSync(path.join(dependency.headers, file), 'utf8')
+      dependencyOriginals.set(destination, text)
+      fs.mkdirSync(path.dirname(destination), { recursive: true })
+      fs.writeFileSync(destination, text)
+    }
+    const supplied = path.join(dependency.headers, 'module.modulemap')
+    fs.writeFileSync(
+      path.join(dir, 'module.modulemap'),
+      fs.existsSync(supplied)
+        ? fs.readFileSync(supplied, 'utf8')
+        : `module ${dependency.module} { umbrella "." export * }\n`,
+    )
   }
   const stubs = path.join(work, 'stubs')
   const stubIncludes = path.join(work, 'stub-include')
@@ -152,12 +269,25 @@ export function objcView(
   const search = [
     '-sdk',
     sdk,
+    // keep compiler support headers without importing host platform modules.
+    '-resource-dir',
+    path.join(sdk, 'usr/lib/swift'),
+    '-I',
+    path.resolve(toolchainBin, '../lib/swift/clang/include'),
+    '-I',
+    path.resolve(toolchainBin, '../lib/swift/shims'),
     '-I',
     stdlib,
     '-F',
     frameworks,
     '-I',
     include,
+    '-I',
+    headersDir,
+    ...(surface.dependencies ?? []).flatMap((dependency) => [
+      '-I',
+      path.join(include, dependency.module),
+    ]),
     '-F',
     stubs,
     '-I',
@@ -215,8 +345,8 @@ export function objcView(
       path.join(root, 'Modules', 'module.modulemap'),
       'framework module PeachMissing {\n  umbrella header "PeachMissing.h"\n  export *\n}\n',
     )
-    for (const [file, text] of originals)
-      fs.writeFileSync(path.join(headersDir, file), `${MISSING_IMPORT}${text}`)
+    for (const [file, text] of [...originals, ...dependencyOriginals])
+      fs.writeFileSync(file, `${MISSING_IMPORT}${text}`)
   }
   // the identifier a diagnostic points at, read from the header as compiled.
   const tokenAt = (file: string, line: number, column: number) => {
@@ -254,11 +384,11 @@ export function objcView(
         '-output-dir',
         out,
       ],
-      { encoding: 'utf8', maxBuffer: 256 * 1024 * 1024 },
+      { encoding: 'utf8', env: swiftEnvironment(), maxBuffer: 256 * 1024 * 1024 },
     )
     if (run.error) throw run.error
     const errors = [
-      ...run.stderr.matchAll(/^(?:(\S+?):(\d+):(\d+): )?(?:fatal )?error: (.*)$/gm),
+      ...run.stderr.matchAll(/^(?:(.+?):(\d+):(\d+): )?(?:fatal )?error: (.*)$/gm),
     ]
     if (errors.length === 0 && run.status === 0) break
     let progress = false
@@ -300,7 +430,11 @@ export function objcView(
     }
     if (!progress || round === ROUNDS)
       throw new Error(
-        `its headers do not import as Swift: ${[...new Set(errors.map((match) => match[4]!))].slice(0, 3).join('; ')}`,
+        `its headers do not import as Swift: ${
+          errors.length > 0
+            ? [...new Set(errors.map((match) => match[4]!))].slice(0, 10).join('; ')
+            : `swift-symbolgraph-extract ${run.signal ?? `exit ${run.status}`}: ${(run.stderr.trim() || run.stdout.trim() || 'no diagnostic').slice(0, 4000)}`
+        }`,
       )
     if (missing.size > 0) declareMissing()
   }
@@ -383,7 +517,7 @@ function enumValues(
       '-ast-dump=json',
       probe,
     ],
-    { encoding: 'utf8', maxBuffer: 1024 * 1024 * 1024 },
+    { encoding: 'utf8', env: swiftEnvironment(), maxBuffer: 1024 * 1024 * 1024 },
   )
   if (run.status !== 0)
     throw new Error(

package/src/swift-package-manifest.ts

@@ -8,10 +8,10 @@
 import { execFileSync } from 'node:child_process'
 import { createHash } from 'node:crypto'
 import fs from 'node:fs'
-import os from 'node:os'
 import path from 'node:path'
+import { cacheDir as peachCacheDir, swiftPackageCacheOptions } from './home-paths'
 import lock from './swift-distribution.lock.json' with { type: 'json' }
-import { swiftToolchainBin } from './swift-toolchain'
+import { swiftEnvironment, swiftToolchainBin } from './swift-toolchain'
 import type { SwiftTargetDependency } from './swift-package'
 
 const TARGET_TYPES = [
@@ -27,9 +27,9 @@ export type SwiftManifestTargetType = (typeof TARGET_TYPES)[number]
 const isTargetType = (value: string | undefined): value is SwiftManifestTargetType =>
   TARGET_TYPES.some((type) => type === value)
 
-/** a swift condition a target defines on ios, and the swiftpm build
+/** a named target setting active on ios, and the swiftpm build
  *  configuration it needs (null applies in both). */
-export interface SwiftManifestDefine {
+export interface SwiftManifestSetting {
   name: string
   configuration: 'debug' | 'release' | null
 }
@@ -47,9 +47,17 @@ export interface SwiftManifestTarget {
   dependencies: SwiftTargetDependency[]
   languageMode: number
   mainActorIsolation: boolean
-  defines: SwiftManifestDefine[]
+  defines: SwiftManifestSetting[]
+  libraries: SwiftManifestSetting[]
+  nativeSettings: {
+    tool: 'c' | 'cxx'
+    flags: string[]
+    configuration: 'debug' | 'release' | null
+  }[]
   /** true when the target declares `resources:`. */
   declaresResources: boolean
+  /** public header directory relative to the target, as SwiftPM declares it. */
+  publicHeadersPath: string
   /** a binary target's archive url; a local one's artifact is `dir`. */
   url: string | null
   /** the declared SHA-256 for a remote binary archive. */
@@ -80,7 +88,7 @@ function swiftCommand(): { file: string; args: string[] } {
     : { file: path.join(swiftToolchainBin(lock.release), 'swift'), args: [] }
 }
 
-const cacheDir = path.join(os.tmpdir(), 'peach-swift-manifests')
+const cacheDir = path.join(peachCacheDir(), 'swift-manifests')
 const evaluated = new Map<string, SwiftPackageManifest>()
 
 function dump(dir: string): { key: string; raw: Record<string, Json> } {
@@ -108,6 +116,7 @@ function dump(dir: string): { key: string; raw: Record<string, Json> } {
       [
         ...command.args,
         'package',
+        ...swiftPackageCacheOptions(),
         '--package-path',
         dir,
         // swiftpm's scratch files never land in the app's own package
@@ -117,6 +126,7 @@ function dump(dir: string): { key: string; raw: Record<string, Json> } {
       ],
       {
         encoding: 'utf8',
+        env: swiftEnvironment(),
         stdio: ['ignore', 'pipe', 'pipe'],
         maxBuffer: 64 * 1024 * 1024,
       },
@@ -249,10 +259,42 @@ export function swiftPackageManifest(dir: string): SwiftPackageManifest {
     }
     let languageMode = packageMode
     let mainActorIsolation = false
-    const defines: SwiftManifestDefine[] = []
+    const defines: SwiftManifestSetting[] = []
+    const libraries: SwiftManifestSetting[] = []
+    const nativeSettings: SwiftManifestTarget['nativeSettings'] = []
+    for (const [tool, standard] of [
+      ['c', string(raw.cLanguageStandard)],
+      ['cxx', string(raw.cxxLanguageStandard)],
+    ] satisfies ['c' | 'cxx', string | undefined][]) {
+      if (standard)
+        nativeSettings.push({ tool, flags: [`-std=${standard}`], configuration: null })
+    }
     for (const setting of array(target.settings)) {
       const { kind: rawKind, tool, condition } = record(setting)
       const settingKind = record(rawKind)
+      if ((tool === 'c' || tool === 'cxx') && linksOnIOS(condition, traits)) {
+        const config = string(record(condition).config)
+        const header = string(record(settingKind.headerSearchPath)._0)
+        const definition = string(record(settingKind.define)._0)
+        const value = string(record(settingKind.define)._1)
+        const unsafe = record(settingKind.unsafeFlags)._0
+        const flags = header
+          ? ['-I', path.resolve(targetDir, header)]
+          : definition
+            ? [`-D${definition}${value === undefined ? '' : `=${value}`}`]
+            : Array.isArray(unsafe)
+              ? unsafe.flatMap((flag) => string(flag) ?? [])
+              : null
+        if (!flags)
+          throw new Error(
+            `${name}: unsupported ${tool} compiler setting ${JSON.stringify(rawKind)}`,
+          )
+        nativeSettings.push({
+          tool,
+          flags,
+          configuration: config === 'debug' || config === 'release' ? config : null,
+        })
+      }
       const mode = string(record(settingKind.swiftLanguageMode)._0)
       if (mode)
         languageMode = Math.max(5, Number(/^(\d+)/.exec(mode)?.[1] ?? languageMode))
@@ -271,6 +313,14 @@ export function swiftPackageManifest(dir: string): SwiftPackageManifest {
           configuration: config === 'debug' || config === 'release' ? config : null,
         })
       }
+      const library = string(record(settingKind.linkedLibrary)._0)
+      if (library && string(tool) === 'linker' && linksOnIOS(condition, traits)) {
+        const config = string(record(condition).config)
+        libraries.push({
+          name: library,
+          configuration: config === 'debug' || config === 'release' ? config : null,
+        })
+      }
     }
     targets.set(name, {
       name,
@@ -285,7 +335,10 @@ export function swiftPackageManifest(dir: string): SwiftPackageManifest {
       languageMode,
       mainActorIsolation,
       defines,
+      libraries,
+      nativeSettings,
       declaresResources: array(target.resources).length > 0,
+      publicHeadersPath: string(target.publicHeadersPath) ?? 'include',
       url: string(target.url) ?? null,
       checksum: string(target.checksum) ?? null,
     })

package/src/swift-package.ts

@@ -8,6 +8,8 @@ export interface SwiftPackageTarget {
   path: string
   /** true for `.executableTarget`: the one that links the wasm artifact. */
   executable: boolean
+  /** true for a header-only `.systemLibrary` supplied by the target SDK. */
+  systemLibrary?: boolean
   /** the target's declared `.swiftLanguageMode(.vN)`; 5 when it declares none. */
   languageMode: number
   /** true when the target declares `.defaultIsolation(MainActor.self)`. */
@@ -16,6 +18,8 @@ export interface SwiftPackageTarget {
   cxxInterop?: boolean
   /** compilation conditions the target declares unconditionally with `.define`. */
   defines?: string[]
+  /** libraries the target declares unconditionally with `.linkedLibrary`. */
+  linkedLibraries?: string[]
   /** true when declared or implicit resources give the target `Bundle.module`. */
   resources: boolean
   /** declared dependencies on other targets in the same package. */
@@ -202,7 +206,11 @@ export function swiftManifestTargets(
 ): SwiftPackageTarget[] {
   const implicitResources = swiftImplicitResourcePaths(resourcePaths)
   const targets: SwiftPackageTarget[] = []
-  const declarations = manifestCalls(manifest, ['executableTarget', 'target'])
+  const declarations = manifestCalls(manifest, [
+    'executableTarget',
+    'target',
+    'systemLibrary',
+  ])
   const targetNames = new Set(
     declarations.flatMap(({ flat }) => {
       const name = /\bname\s*:\s*"([^"]+)"/.exec(flat)?.[1]
@@ -230,6 +238,9 @@ export function swiftManifestTargets(
     const defines = [
       ...call.matchAll(/\.define\(\s*"([A-Za-z_][A-Za-z0-9_]*)"\s*\)/g),
     ].map((match) => match[1]!)
+    const linkedLibraries = [...call.matchAll(/\.linkedLibrary\(\s*"([^"]+)"\s*\)/g)].map(
+      (match) => match[1]!,
+    )
     const excluded = [
       ...(/\bexclude\s*:\s*\[([^\]]*)\]/.exec(flat)?.[1] ?? '').matchAll(/"([^"]+)"/g),
     ].map((match) => match[1].replace(/^\.\//, '').replace(/\/+$/, ''))
@@ -270,10 +281,12 @@ export function swiftManifestTargets(
       name,
       path: targetPath,
       executable,
+      ...(kind === 'systemLibrary' ? { systemLibrary: true } : {}),
       languageMode,
       mainActorIsolation,
       ...(cxxInterop ? { cxxInterop: true } : {}),
       ...(defines.length === 0 ? {} : { defines }),
+      ...(linkedLibraries.length === 0 ? {} : { linkedLibraries }),
       resources,
       ...(dependencies.length === 0 ? {} : { dependencies }),
       ...(excluded.length === 0 ? {} : { exclude: excluded }),
@@ -380,6 +393,7 @@ export function swiftPackagePartition(
     targets[0].languageMode === 5 &&
     !targets[0].mainActorIsolation &&
     !targets[0].defines?.length &&
+    !targets[0].linkedLibraries?.length &&
     !targets[0].cxxInterop &&
     !swiftManifestCxxLanguageStandard(manifest)
     ? []