peachsim 0.1.2179 → 0.1.2182

package/src/swift-compile.ts

@@ -1791,6 +1791,32 @@ export function emitSwiftPackageManifest(args: {
   const linkedObjects = Boolean(distribution || prebuilt)
   const cxxFlagsFor = (flags: readonly string[]): readonly string[] =>
     args.deferDarwinOverlay ? withoutWasmOverlayIsystem(flags) : flags
+  // swiftpm writes the module map of a target with no swift sources, so an
+  // installed pod's map of that module (a prebuilt React Native core target
+  // the app's pods also list) would define it twice. a swift target imports
+  // its underlying objective-c module through the pod's map and keeps it.
+  const packageModules = new Set(
+    targets
+      .filter(({ name }) => !args.sourceSwiftTargets?.has(name))
+      .map(({ name }) => swiftTargetModuleName(name)),
+  )
+  const mapsPackageModule = (flag: string): boolean => {
+    if (!flag.startsWith('-fmodule-map-file=')) return false
+    const file = flag
+      .slice('-fmodule-map-file='.length)
+      .replaceAll(SWIFT_NATIVE_INPUT_ROOT, args.root)
+    if (!file.includes('/Pods/Headers/')) return false
+    const map =
+      args.files.get(file) ?? (existsSync(file) ? readFileSync(file) : undefined)
+    const name = map === undefined ? undefined : moduleMapName(map.toString())
+    return name !== undefined && packageModules.has(name)
+  }
+  const withoutPackageModuleMaps = (flags: readonly string[]): string[] =>
+    flags.filter((flag) => !mapsPackageModule(flag))
+  const targetCFlags = (flags: readonly string[]) =>
+    cFlagArray(withoutPackageModuleMaps(flags))
+  const targetCxxFlags = (flags: readonly string[]) =>
+    cxxFlagArray(withoutPackageModuleMaps(flags))
   const reachedFrameworks = new Set<string>()
   const reach = (name: string) => {
     if (
@@ -1908,7 +1934,11 @@ export function emitSwiftPackageManifest(args: {
   // swiftpm expands target settings into one command; large native import
   // closures exceed exec's argument limit. keep their ordered bytes on disk.
   const swiftFlagArray = (literal: string): string => {
-    const flags: string[] = JSON.parse(literal.replace(/,\s*]$/, ']'))
+    const flags: string[] = JSON.parse(literal.replace(/,\s*]$/, ']')).filter(
+      (flag: string, index: number, all: string[]) =>
+        !mapsPackageModule(flag) &&
+        !(flag === '-Xcc' && mapsPackageModule(all[index + 1] ?? '')),
+    )
     const content = flags.map((flag) => JSON.stringify(flag)).join('\n') + '\n'
     const digest = createHash('sha256').update(content).digest('hex')
     const file = path.join(args.root, '.peach-swift-arguments', `${digest}.rsp`)
@@ -2182,7 +2212,7 @@ export function emitSwiftPackageManifest(args: {
             .map((entry) => ` ${entry},`)
             .join(
               '',
-            )} .unsafeFlags(${flagArray(cFlagArray([...nativeFlags, ...native.clang.flags]))})]`,
+            )} .unsafeFlags(${flagArray(targetCFlags([...nativeFlags, ...native.clang.flags]))})]`,
           ...(nativeCxx
             ? [
                 `cxxSettings: [${cxxDefines}${clangSettingEntries(
@@ -2192,13 +2222,13 @@ export function emitSwiftPackageManifest(args: {
                   .map((entry) => ` ${entry},`)
                   .join(
                     '',
-                  )} .unsafeFlags(${flagArray(cxxFlagArray([...cxxFlagsFor(nativeFlags), ...native.clang.cxxFlags]))})]`,
+                  )} .unsafeFlags(${flagArray(targetCxxFlags([...cxxFlagsFor(nativeFlags), ...native.clang.cxxFlags]))})]`,
               ]
             : []),
         ].join(', ')
       : [
-          `cSettings: [${cDefines}${declaredClangSettings(target, 'c')} .unsafeFlags(${flagArray(cFlagArray([...nativeFlags, ...(native?.flags ?? [])]))})]`,
-          `cxxSettings: [${cxxDefines}${declaredClangSettings(target, 'cxx')} .unsafeFlags(${flagArray(cxxFlagArray([...cxxFlagsFor(nativeFlags), ...(native?.cxxFlags ?? [])]))})]`,
+          `cSettings: [${cDefines}${declaredClangSettings(target, 'c')} .unsafeFlags(${flagArray(targetCFlags([...nativeFlags, ...(native?.flags ?? [])]))})]`,
+          `cxxSettings: [${cxxDefines}${declaredClangSettings(target, 'cxx')} .unsafeFlags(${flagArray(targetCxxFlags([...cxxFlagsFor(nativeFlags), ...(native?.cxxFlags ?? [])]))})]`,
         ].join(', ')
     const exclusions = native?.clang
       ? []
@@ -2287,10 +2317,10 @@ export function emitSwiftPackageManifest(args: {
             `      path: ${JSON.stringify(group.path)},`,
             `      sources: ${JSON.stringify(group.sources)},`,
             `      publicHeadersPath: ${JSON.stringify(native.groups ? 'include' : 'PeachSwiftImplementation')},`,
-            `      cSettings: [${macroSettings(owner?.cDefines)}${declaredClangSettings(owner, 'c')} .unsafeFlags(${flagArray(cFlagArray([...nativeFlags, '-I', native.includeDirectory, ...(args.headerDirectory ? ['-I', args.headerDirectory] : []), ...group.flags]))})],`,
+            `      cSettings: [${macroSettings(owner?.cDefines)}${declaredClangSettings(owner, 'c')} .unsafeFlags(${flagArray(targetCFlags([...nativeFlags, '-I', native.includeDirectory, ...(args.headerDirectory ? ['-I', args.headerDirectory] : []), ...group.flags]))})],`,
             ...(group.sources.some((source) => /\.(?:cc|cpp|cxx|mm)$/.test(source))
               ? [
-                  `      cxxSettings: [${macroSettings(owner?.cxxDefines)}${declaredClangSettings(owner, 'cxx')} .unsafeFlags(${flagArray(cxxFlagArray([...cxxFlagsFor(nativeFlags), '-I', native.includeDirectory, ...group.cxxFlags]))})]),`,
+                  `      cxxSettings: [${macroSettings(owner?.cxxDefines)}${declaredClangSettings(owner, 'cxx')} .unsafeFlags(${flagArray(targetCxxFlags([...cxxFlagsFor(nativeFlags), '-I', native.includeDirectory, ...group.cxxFlags]))})]),`,
                 ]
               : ['    ),']),
           ])
@@ -4300,7 +4330,11 @@ export function writeSwiftProject(
     const target = bySourcePath.find(
       (candidate) => candidate.path === '.' || file.startsWith(`${candidate.path}/`),
     )
-    if (target) swiftTargets.add(target.name)
+    // swiftpm never compiles an excluded file (a prebuilt core's Swift)
+    const excluded = target?.exclude?.some(
+      (name) => file === path.posix.join(target.path, name),
+    )
+    if (target && !excluded) swiftTargets.add(target.name)
   }
   // swiftpm builds a clang target's module only for an importer: a swift
   // import, or a framework-style include or @import in any original source.
@@ -5650,6 +5684,9 @@ export function writeSwiftProject(
         frameworkLink,
         [
           ...prebuilt.objects.map(quote),
+          '-Wl,--start-lib',
+          ...prebuilt.lazyObjects.map(quote),
+          '-Wl,--end-lib',
           ...darwinRecordsRegion(prebuilt.providers.map(quote)),
         ].join('\n') + '\n',
       )
@@ -6016,7 +6053,7 @@ function readCompiledArtifact(
     if (
       createHash('sha256').update(bytes).digest('hex') !== receipt.wasm ||
       createHash('sha256').update(gzip).digest('hex') !== receipt.icu ||
-      bytes.length < 8 ||
+      bytes.length <= 8 ||
       bytes.readUInt32LE(0) !== 0x6d736100 ||
       bytes.readUInt32LE(4) !== 1
     )
@@ -6178,7 +6215,15 @@ function linkedFrameworkTargets(
   )
   const targets = compileTargets(input)
   const planning = targets.length > 0 ? targets : [{ name: 'App', path: '.' }]
-  const siblings = swiftTargetDependencies(input.files, planning, libraries.keys())
+  // a target's prebuilt library links the units its package excludes from
+  // compilation (a React Native core), so their imports reach frameworks too
+  const siblings = swiftTargetDependencies(
+    input.files,
+    planning.map((target) =>
+      input.libraries?.[target.name] ? { ...target, exclude: [] } : target,
+    ),
+    libraries.keys(),
+  )
   const reached = new Set<string>()
   const reach = (name: string) => {
     if (name === 'SwiftUI') return
@@ -6409,8 +6454,13 @@ function removeCaseCollidingModuleArtifacts(
 
 /** a source checkout's framework build: what the app link reads from it. */
 interface SwiftFrameworkProducts {
+  /** the distribution-shaped root whose lib/ holds the framework objects */
+  root: string
   modules: string
+  /** objects the link loads whole */
   objects: string[]
+  /** objects the link loads only for a symbol it resolves */
+  lazyObjects: string[]
   owners: Map<string, string>
   /** the Darwin module's providers, linked as an archive ahead of the sdk's */
   providers: string[]
@@ -6572,9 +6622,41 @@ async function buildFrameworkProducts(
     .sort()
     .map((file) => path.join(providerDir, file))
   for (const provider of providers) linked.owners.set(provider, 'DarwinRecords')
+  // the framework objects link as a distribution's do: under lib/ with the names
+  // build-distribution.ts gives them, Objective-C roots whole and the rest as an
+  // archive region the pruner trims (swift-wasm-prune.ts reads <root>/lib).
+  // Darwin stays whole: a distribution leaves it to the sdk's image.
+  const archive = path.join(scratch, 'lib')
+  rmSync(archive, { recursive: true, force: true })
+  mkdirSync(archive)
+  const archived = new Map<string, string>()
+  for (const object of objects) {
+    const target = linked.owners.get(object)
+    const dir = path.join(release, `${target}.build`)
+    if (!target || target === 'Darwin' || !object.startsWith(dir + path.sep)) continue
+    const name = `${target}-${path
+      .relative(dir, object)
+      .replaceAll(path.sep, '-')
+      .replace(/\.swift\.o$/, '.o')}`
+    symlinkSync(object, path.join(archive, name))
+    archived.set(object, `lib/${name}`)
+  }
+  const roots = swiftObjcRootObjects(`${scratch}\n${args.frameworkKey}`, scratch, [
+    ...archived.values(),
+  ])
+  const linkedObjects = objects.map((object) => {
+    const name = archived.get(object)
+    return name
+      ? { path: path.join(scratch, name), lazy: !roots.has(name) }
+      : { path: object, lazy: false }
+  })
   return {
+    root: scratch,
     modules: path.join(release, 'Modules'),
-    objects,
+    objects: linkedObjects.filter((object) => !object.lazy).map((object) => object.path),
+    lazyObjects: linkedObjects
+      .filter((object) => object.lazy)
+      .map((object) => object.path),
     owners: linked.owners,
     providers,
     link,
@@ -6788,6 +6870,8 @@ function swiftLinkStamp(args: {
   }
   for (const object of args.prebuilt.objects)
     hash.update(`object\n${object}\n${statOf(object)}`)
+  for (const object of args.prebuilt.lazyObjects)
+    hash.update(`lazy-object\n${object}\n${statOf(object)}`)
   for (const object of args.prebuilt.providers)
     hash.update(`provider\n${object}\n${statOf(object)}`)
   for (const map of args.prebuilt.moduleMaps)
@@ -7302,7 +7386,7 @@ function compileSwiftProjectOnce(
               pruneSwiftWasmLink(
                 root,
                 options.toolchainBin,
-                frameworkRoot,
+                prebuilt?.root ?? frameworkRoot,
                 input.staticClangTargets,
                 options.project,
                 undefined,
@@ -7328,11 +7412,19 @@ function compileSwiftProjectOnce(
                 optimized,
               })
             else if (input.optimize) await optimizeWasm(output, optimized)
+            const executable = input.optimize ? optimized : output
+            await runCompiler(
+              path.join(options.toolchainBin, 'llvm-objcopy'),
+              ['--remove-section=.swift1_autolink_entries', executable],
+              buildOptions,
+            )
             const artifact = {
               hash,
-              bytes: readFileSync(input.optimize ? optimized : output),
+              bytes: readFileSync(executable),
               icu: await icu,
             }
+            if (artifact.bytes.length <= 8)
+              throw new Error('swift-compile: deferred linker produced no executable')
             if (!options.project) saveCompiledArtifact(root, artifact)
             saveSharedArtifact(sharedRoot, artifact)
             report('compiled artifact verified')

package/src/swift-submit.ts

@@ -146,7 +146,8 @@ export const MAX_SWIFT_COMPILE_IMAGE_TOTAL_BYTES = 16 * 1024 * 1024
 // 68: fetch headers replies carry `setCookies`, the response's Set-Cookie list.
 // 69: `peach.icu_item_v1` replaces `icu_data_v1`: the host fills icu's table of
 // contents and places each item's pack the first time icu opens it.
-export const SWIFT_HOST_ABI = 69
+// 70: full Objective-C forwarding uses exact typed IMPs (`peach.imp_forwarder_mint`).
+export const SWIFT_HOST_ABI = 70
 
 export interface SwiftImageUpload {
   /** the raster file picked for the asset (has the extension). */

package/src/wasm-optimize.ts

@@ -2,13 +2,13 @@ import { existsSync } from 'node:fs'
 import { join } from 'node:path'
 import { installVerifiedTarball } from '@contrast/runtime-delivery'
 import { BINARYEN_VERSION, wasmOpt } from 'wasm-opt'
+import { windowAdmission } from './admitted-mac-build'
 import { rnxHomeDir } from './home-paths'
 
-// the linked executable of a Nitro or Turbo module, size-optimized. clang's own
+// packaged native executables, size-optimized. clang's own
 // optimizer pass is off (-O0 on the link) so an edit never pays for it and the
 // artifact never depends on the machine; this runs the pinned Binaryen once per
-// cached artifact instead. the features are the ones the link declares, and the
-// pass drops the custom sections (autolink entries, producers) no host reads.
+// cached artifact instead. the features are the ones the link declares.
 const FEATURES = [
   'threads',
   'bulk-memory',
@@ -61,6 +61,15 @@ async function runWasmOpt(
   skipPasses: readonly string[],
   binary: string,
 ): Promise<void> {
+  const admittedCores = windowAdmission()?.cores ?? Number(process.env.TM_EXEC_CPU_CORES)
+  const requestedCores = Number(process.env.BINARYEN_CORES)
+  const environment: NodeJS.ProcessEnv = { ...process.env, WASM_OPT_PATH: binary }
+  if (Number.isInteger(admittedCores) && admittedCores > 0)
+    environment.BINARYEN_CORES = String(
+      Number.isInteger(requestedCores) && requestedCores > 0
+        ? Math.min(admittedCores, requestedCores)
+        : admittedCores,
+    )
   const result = await wasmOpt(
     [
       '-Oz',
@@ -70,7 +79,7 @@ async function runWasmOpt(
       '-o',
       output,
     ],
-    { env: { ...process.env, WASM_OPT_PATH: binary } },
+    { env: environment },
   )
   if (result.status !== 0)
     throw new Error(`wasm-opt exited ${result.status}: ${result.stderr}`)