peachsim 0.1.1620 → 0.1.1635

package/src/swift-icu.ts

@@ -4,6 +4,7 @@ import { existsSync, readFileSync } from 'node:fs'
 import path from 'node:path'
 import { promisify } from 'node:util'
 import { gzip } from 'node:zlib'
+import { swiftSdkOptions } from './swift-toolchain.ts'
 
 /**
  * the icu common data a swift artifact reserves and its host fills
@@ -49,15 +50,21 @@ function memo<T>(
 
 /** the raw blob, for a harness that fills an artifact in node. */
 export function swiftIcuData(toolchainBin: string, sdk: string): Promise<Buffer> {
-  return memo(raw, `${toolchainBin}\0${sdk}`, () => load(toolchainBin, sdk))
+  return memo(raw, JSON.stringify([toolchainBin, sdk, swiftSdkOptions()]), () =>
+    load(toolchainBin, sdk),
+  )
 }
 
 /** the served form: gzipped and content-addressed. */
 export function swiftIcuAsset(toolchainBin: string, sdk: string): Promise<SwiftIcuAsset> {
-  return memo(assets, `${toolchainBin}\0${sdk}`, async () => {
-    const zipped = await deflate(await swiftIcuData(toolchainBin, sdk))
-    return { sha256: createHash('sha256').update(zipped).digest('hex'), gzip: zipped }
-  })
+  return memo(
+    assets,
+    JSON.stringify([toolchainBin, sdk, swiftSdkOptions()]),
+    async () => {
+      const zipped = await deflate(await swiftIcuData(toolchainBin, sdk))
+      return { sha256: createHash('sha256').update(zipped).digest('hex'), gzip: zipped }
+    },
+  )
 }
 
 async function load(toolchainBin: string, sdk: string): Promise<Buffer> {
@@ -66,12 +73,13 @@ async function load(toolchainBin: string, sdk: string): Promise<Buffer> {
   // missing piece instead of shelling out to sdk configure.
   if (!existsSync(swift))
     throw new Error(`swift-icu: no swift at ${swift} for the ${sdk} SDK's icu data`)
-  const { stdout: listed } = await run(swift, ['sdk', 'list'])
+  const { stdout: listed } = await run(swift, ['sdk', 'list', ...swiftSdkOptions()])
   if (!listed.split('\n').some((line) => line.trim() === sdk))
     throw new Error(`swift-icu: ${sdk} is not installed for ${swift}`)
   const { stdout } = await run(swift, [
     'sdk',
     'configure',
+    ...swiftSdkOptions(),
     '--show-configuration',
     sdk,
     'wasm32-unknown-wasip1',

package/src/swift-objc-sdk.ts

@@ -11,6 +11,129 @@ export const IOS_SDK_TARGET = 'arm64-apple-ios16.0-simulator'
 
 /** the clang headers and module maps, by path under the sdk root. */
 export const IOS_SDK_HEADERS: Record<string, string> = {
+  // darwin pointer and mach port identities used in public native headers.
+  'usr/include/pthread.h': `#pragma once
+struct _opaque_pthread_t;
+typedef struct _opaque_pthread_t *pthread_t;
+`,
+  'usr/include/mach/mach_types.h': `#pragma once
+#include <stdint.h>
+typedef unsigned int natural_t;
+typedef int integer_t;
+typedef int vm_prot_t;
+typedef integer_t cpu_type_t;
+typedef integer_t cpu_subtype_t;
+typedef natural_t *thread_state_t;
+typedef int thread_state_flavor_t;
+typedef natural_t mach_port_t;
+typedef mach_port_t thread_t;
+typedef thread_t thread_act_t;
+typedef thread_act_t *thread_act_array_t;
+typedef natural_t mach_msg_type_number_t;
+`,
+  'usr/include/mach/mach.h': `#pragma once
+#include <mach/mach_types.h>
+`,
+  'usr/include/TargetConditionals.h': `#pragma once
+#define TARGET_OS_IPHONE 1
+#define TARGET_OS_IOS 1
+#define TARGET_OS_SIMULATOR 1
+#define TARGET_OS_OSX 0
+#define TARGET_OS_MAC 1
+#define TARGET_OS_TV 0
+#define TARGET_OS_WATCH 0
+#define TARGET_OS_VISION 0
+#define TARGET_OS_MACCATALYST 0
+#define TARGET_IPHONE_SIMULATOR 1
+#define TARGET_CPU_ARM64 1
+#define TARGET_CPU_X86_64 0
+#define TARGET_RT_64_BIT 1
+`,
+  'usr/include/stdlib.h': `#pragma once
+#include <stddef.h>
+void exit(int) __attribute__((noreturn));
+void abort(void) __attribute__((noreturn));
+void *malloc(size_t);
+void free(void *);
+`,
+  'usr/include/unistd.h': `#pragma once
+#include <stdlib.h>
+void _exit(int) __attribute__((noreturn));
+`,
+  'usr/include/string.h': `#pragma once
+#include <stddef.h>
+size_t strlen(const char *);
+char *strdup(const char *);
+void *memcpy(void *, const void *, size_t);
+void *memset(void *, int, size_t);
+int strcmp(const char *, const char *);
+`,
+  'usr/include/sys/types.h': `#pragma once
+#include <time.h>
+#include <stddef.h>
+typedef long ssize_t;
+`,
+  'usr/include/time.h': `#pragma once
+typedef long time_t;
+`,
+  'usr/include/dlfcn.h': `#pragma once
+typedef struct dl_info {
+  const char *dli_fname;
+  void *dli_fbase;
+  const char *dli_sname;
+  void *dli_saddr;
+} Dl_info;
+`,
+  'usr/include/sys/ucontext.h': `#pragma once
+#include <stdint.h>
+#define _STRUCT_ARM_EXCEPTION_STATE64 struct __darwin_arm_exception_state64
+_STRUCT_ARM_EXCEPTION_STATE64 { uint64_t __far; uint32_t __esr, __exception; };
+#define _STRUCT_ARM_THREAD_STATE64 struct __darwin_arm_thread_state64
+_STRUCT_ARM_THREAD_STATE64 {
+  uint64_t __x[29];
+  uint64_t __fp, __lr, __sp, __pc;
+  uint32_t __cpsr, __pad;
+};
+#define _STRUCT_ARM_NEON_STATE64 struct __darwin_arm_neon_state64
+_STRUCT_ARM_NEON_STATE64 { unsigned __int128 __v[32]; uint32_t __fpsr, __fpcr; };
+#define _STRUCT_MCONTEXT64 struct __darwin_mcontext64
+_STRUCT_MCONTEXT64 {
+  _STRUCT_ARM_EXCEPTION_STATE64 __es;
+  _STRUCT_ARM_THREAD_STATE64 __ss;
+  _STRUCT_ARM_NEON_STATE64 __ns;
+};
+`,
+  'usr/include/mach-o/loader.h': `#pragma once
+#include <stdint.h>
+#include <mach/mach_types.h>
+#define LC_SEGMENT_64 0x19
+struct mach_header_64 {
+  uint32_t magic;
+  int32_t cputype, cpusubtype;
+  uint32_t filetype, ncmds, sizeofcmds, flags, reserved;
+};
+struct segment_command_64 {
+  uint32_t cmd, cmdsize;
+  char segname[16];
+  uint64_t vmaddr, vmsize, fileoff, filesize;
+  int32_t maxprot, initprot;
+  uint32_t nsects, flags;
+};
+struct section_64 {
+  char sectname[16], segname[16];
+  uint64_t addr, size;
+  uint32_t offset, align, reloff, nreloc, flags, reserved1, reserved2, reserved3;
+};
+`,
+  'usr/include/mach-o/nlist.h': `#pragma once
+#include <stdint.h>
+struct nlist_64 {
+  union { uint32_t n_strx; } n_un;
+  uint8_t n_type, n_sect;
+  uint16_t n_desc;
+  uint64_t n_value;
+};
+`,
   'usr/include/module.modulemap': `module ObjectiveC [system] {
   header "objc/NSObject.h"
   export *
@@ -67,6 +190,10 @@ __attribute__((objc_root_class))
 @end
 @interface Protocol : NSObject
 @end
+`,
+  'System/Library/Frameworks/CoreFoundation.framework/Headers/CoreFoundation.h': `#pragma once
+#import <Foundation/Foundation.h>
+typedef const struct __attribute__((objc_bridge(NSString))) __CFString *CFStringRef;
 `,
   'System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.h': `#pragma once
 #include <stdint.h>
@@ -99,9 +226,15 @@ typedef struct __attribute__((objc_bridge(id))) CGColorSpace *CGColorSpaceRef;
 #include <stddef.h>
 #include <stdbool.h>
 #include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <TargetConditionals.h>
 #import <objc/NSObject.h>
 #import <CoreGraphics/CoreGraphics.h>
 
+@class NSException;
+typedef void NSUncaughtExceptionHandler(NSException *exception);
 #define FOUNDATION_EXPORT extern
 #define FOUNDATION_EXTERN extern
 #define FOUNDATION_STATIC_INLINE static inline
@@ -237,16 +370,6 @@ typedef struct __attribute__((objc_bridge(id))) CGColorSpace *CGColorSpaceRef;
 #define CF_IMPLICIT_BRIDGING_DISABLED _Pragma("clang arc_cf_code_audited end")
 #define NS_NONATOMIC_IOSONLY nonatomic
 #define NS_UNAVAILABLE_INIT
-#define TARGET_OS_IPHONE 1
-#define TARGET_OS_IOS 1
-#define TARGET_OS_SIMULATOR 1
-#define TARGET_OS_OSX 0
-#define TARGET_OS_MAC 1
-#define TARGET_OS_TV 0
-#define TARGET_OS_WATCH 0
-#define TARGET_OS_VISION 0
-#define TARGET_OS_MACCATALYST 0
-#define TARGET_IPHONE_SIMULATOR 1
 #define NSIntegerMax LONG_MAX
 #define NSIntegerMin LONG_MIN
 #define NSUIntegerMax ULONG_MAX

package/src/swift-objc-standin.ts

@@ -26,6 +26,7 @@ export interface ObjcSurface {
   module: string
   modulemap: string
   headers: string
+  dependencies?: { module: string; headers: string }[]
 }
 
 export interface ObjcView {
@@ -123,7 +124,7 @@ 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,
@@ -143,7 +144,22 @@ 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'))
+  }
+  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)) {
+      fs.mkdirSync(path.dirname(path.join(dir, file)), { recursive: true })
+      fs.copyFileSync(path.join(dependency.headers, file), path.join(dir, file))
+    }
+    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')
@@ -158,6 +174,12 @@ export function objcView(
     frameworks,
     '-I',
     include,
+    '-I',
+    headersDir,
+    ...(surface.dependencies ?? []).flatMap((dependency) => [
+      '-I',
+      path.join(include, dependency.module),
+    ]),
     '-F',
     stubs,
     '-I',
@@ -174,6 +196,19 @@ export function objcView(
     const slash = include.indexOf('/')
     if (slash > 0 && /^[A-Z]/.test(include)) {
       const name = include.slice(0, slash)
+      const umbrella = `${name}/${name}.h`
+      if (
+        Object.hasOwn(
+          IOS_SDK_HEADERS,
+          `System/Library/Frameworks/${name}.framework/Headers/${name}.h`,
+        )
+      ) {
+        // retain the sdk module's owner when a vendor imports a leaf header.
+        const header = path.join(stubIncludes, include)
+        fs.mkdirSync(path.dirname(header), { recursive: true })
+        fs.writeFileSync(header, `#import <${umbrella}>\n`)
+        return true
+      }
       const root = path.join(stubs, `${name}.framework`)
       const header = path.join(root, 'Headers', include.slice(slash + 1))
       fs.mkdirSync(path.dirname(header), { recursive: true })
@@ -287,7 +322,7 @@ 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: ${[...new Set(errors.map((match) => match[4]!))].slice(0, 10).join('; ')}`,
       )
     if (missing.size > 0) declareMissing()
   }

package/src/swift-package-manifest.ts

@@ -8,8 +8,8 @@
 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 type { SwiftTargetDependency } from './swift-package'
@@ -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,12 @@ export interface SwiftManifestTarget {
   dependencies: SwiftTargetDependency[]
   languageMode: number
   mainActorIsolation: boolean
-  defines: SwiftManifestDefine[]
+  defines: SwiftManifestSetting[]
+  libraries: SwiftManifestSetting[]
   /** 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 +83,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 +111,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
@@ -249,7 +253,8 @@ export function swiftPackageManifest(dir: string): SwiftPackageManifest {
     }
     let languageMode = packageMode
     let mainActorIsolation = false
-    const defines: SwiftManifestDefine[] = []
+    const defines: SwiftManifestSetting[] = []
+    const libraries: SwiftManifestSetting[] = []
     for (const setting of array(target.settings)) {
       const { kind: rawKind, tool, condition } = record(setting)
       const settingKind = record(rawKind)
@@ -271,6 +276,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 +298,9 @@ export function swiftPackageManifest(dir: string): SwiftPackageManifest {
       languageMode,
       mainActorIsolation,
       defines,
+      libraries,
       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)
     ? []