peachsim 0.1.939 → 0.1.1399

package/src/swift-package-manifest.ts

@@ -27,6 +27,13 @@ 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
+ *  configuration it needs (null applies in both). */
+export interface SwiftManifestDefine {
+  name: string
+  configuration: 'debug' | 'release' | null
+}
+
 export interface SwiftManifestTarget {
   name: string
   type: SwiftManifestTargetType
@@ -40,6 +47,7 @@ export interface SwiftManifestTarget {
   dependencies: SwiftTargetDependency[]
   languageMode: number
   mainActorIsolation: boolean
+  defines: SwiftManifestDefine[]
   /** true when the target declares `resources:`. */
   declaresResources: boolean
   /** a binary target's archive url; a local one's artifact is `dir`. */
@@ -49,6 +57,7 @@ export interface SwiftManifestTarget {
 }
 
 export interface SwiftPackageManifest {
+  name: string
   dir: string
   /** library product name to the targets it vends. */
   products: Map<string, string[]>
@@ -240,13 +249,28 @@ export function swiftPackageManifest(dir: string): SwiftPackageManifest {
     }
     let languageMode = packageMode
     let mainActorIsolation = false
+    const defines: SwiftManifestDefine[] = []
     for (const setting of array(target.settings)) {
-      const settingKind = record(record(setting).kind)
+      const { kind: rawKind, tool, condition } = record(setting)
+      const settingKind = record(rawKind)
       const mode = string(record(settingKind.swiftLanguageMode)._0)
       if (mode)
         languageMode = Math.max(5, Number(/^(\d+)/.exec(mode)?.[1] ?? languageMode))
       if (string(record(settingKind.defaultIsolation)._0) === 'MainActor')
         mainActorIsolation = true
+      const define = string(record(settingKind.define)._0)
+      if (
+        define &&
+        string(tool) === 'swift' &&
+        /^[A-Za-z_][A-Za-z0-9_]*$/.test(define) &&
+        linksOnIOS(condition, traits)
+      ) {
+        const config = string(record(condition).config)
+        defines.push({
+          name: define,
+          configuration: config === 'debug' || config === 'release' ? config : null,
+        })
+      }
     }
     targets.set(name, {
       name,
@@ -260,12 +284,15 @@ export function swiftPackageManifest(dir: string): SwiftPackageManifest {
       dependencies,
       languageMode,
       mainActorIsolation,
+      defines,
       declaresResources: array(target.resources).length > 0,
       url: string(target.url) ?? null,
       checksum: string(target.checksum) ?? null,
     })
   }
-  const manifest = { dir, products, targets, packages }
+  const name = string(raw.name)
+  if (!name) throw new Error(`swiftpm returned no package name for ${dir}`)
+  const manifest = { name, dir, products, targets, packages }
   evaluated.set(key, manifest)
   return manifest
 }

package/src/swift-package.ts

@@ -1,3 +1,5 @@
+import type { SwiftResourceBundle } from './swiftContract'
+
 /** one SwiftPM target a sent root manifest declares. */
 export interface SwiftPackageTarget {
   /** the target name, as `import <name>` spells it. */
@@ -10,8 +12,16 @@ export interface SwiftPackageTarget {
   languageMode: number
   /** true when the target declares `.defaultIsolation(MainActor.self)`. */
   mainActorIsolation: boolean
+  /** true when the target declares unconditional C++ interoperability. */
+  cxxInterop?: boolean
+  /** compilation conditions the target declares unconditionally with `.define`. */
+  defines?: string[]
   /** true when declared or implicit resources give the target `Bundle.module`. */
   resources: boolean
+  /** declared dependencies on other targets in the same package. */
+  dependencies?: SwiftTargetDependency[]
+  /** explicit target-relative exclusions retained for resource discovery. */
+  exclude?: string[]
 }
 
 /** whether a project-relative key is a SwiftPM manifest, not a source. */
@@ -65,7 +75,10 @@ function manifestCalls(manifest: string, kinds: readonly string[]): ManifestCall
   const calls: ManifestCall[] = []
   // every declaration kind is scanned, so a `.target(name:)` dependency
   // nested in an unrequested `.testTarget(` is skipped as part of it
-  const pattern = new RegExp(`\\.(${MANIFEST_DECLARATIONS.join('|')})\\s*\\(`, 'g')
+  const pattern = new RegExp(
+    `(?:\\.(${MANIFEST_DECLARATIONS.join('|')})|\\b(Package))\\s*\\(`,
+    'g',
+  )
   let match: RegExpExecArray | null
   while ((match = pattern.exec(code)) !== null) {
     let depth = 1
@@ -95,14 +108,49 @@ function manifestCalls(manifest: string, kinds: readonly string[]): ManifestCall
       }
       i++
     }
-    if (kinds.includes(match[1]!))
-      calls.push({ kind: match[1]!, flat, call: code.slice(start, i) })
+    const kind = match[1] ?? match[2]!
+    if (kinds.includes(kind)) calls.push({ kind, flat, call: code.slice(start, i) })
+    else if (kind === 'Package') {
+      // target declarations are arguments of the root Package call.
+      calls.push(...manifestCalls(code.slice(start, i - 1), kinds))
+    }
     // declarations never nest, so a call inside one is part of it
     pattern.lastIndex = i
   }
   return calls
 }
 
+function splitManifestArguments(source: string): string[] {
+  const arguments_: string[] = []
+  let start = 0
+  let parentheses = 0
+  let brackets = 0
+  let braces = 0
+  let inString = false
+  let escaped = false
+  for (let index = 0; index < source.length; index++) {
+    const character = source[index]
+    if (inString) {
+      if (escaped) escaped = false
+      else if (character === '\\') escaped = true
+      else if (character === '"') inString = false
+    } else if (character === '"') inString = true
+    else if (character === '(') parentheses++
+    else if (character === ')') parentheses--
+    else if (character === '[') brackets++
+    else if (character === ']') brackets--
+    else if (character === '{') braces++
+    else if (character === '}') braces--
+    else if (character === ',' && parentheses === 0 && brackets === 0 && braces === 0) {
+      arguments_.push(source.slice(start, index).trim())
+      start = index + 1
+    }
+  }
+  const final = source.slice(start).trim()
+  if (final) arguments_.push(final)
+  return arguments_
+}
+
 /** a target dependency: a target of the same package, or another package's product. */
 export type SwiftTargetDependency =
   | { kind: 'target'; name: string }
@@ -129,10 +177,14 @@ export function swiftManifestTargets(
 ): SwiftPackageTarget[] {
   const implicitResources = swiftImplicitResourcePaths(resourcePaths)
   const targets: SwiftPackageTarget[] = []
-  for (const { kind, flat, call } of manifestCalls(manifest, [
-    'executableTarget',
-    'target',
-  ])) {
+  const declarations = manifestCalls(manifest, ['executableTarget', 'target'])
+  const targetNames = new Set(
+    declarations.flatMap(({ flat }) => {
+      const name = /\bname\s*:\s*"([^"]+)"/.exec(flat)?.[1]
+      return name ? [name] : []
+    }),
+  )
+  for (const { kind, flat, call } of declarations) {
     const executable = kind === 'executableTarget'
     const name = /\bname\s*:\s*"([^"]+)"/.exec(flat)?.[1]
     if (!name) continue
@@ -147,6 +199,12 @@ export function swiftManifestTargets(
       /\.swiftLanguageMode\(\s*\.v(\d+)\s*\)/.exec(call)?.[1] ?? '5',
     )
     const mainActorIsolation = /\.defaultIsolation\(\s*MainActor\.self\s*\)/.test(call)
+    const cxxInterop = /\.interoperabilityMode\(\s*\.Cxx\s*\)/.test(
+      call.replace(/"(?:\\.|[^"\\])*"/g, ''),
+    )
+    const defines = [
+      ...call.matchAll(/\.define\(\s*"([A-Za-z_][A-Za-z0-9_]*)"\s*\)/g),
+    ].map((match) => match[1]!)
     const excluded = [
       ...(/\bexclude\s*:\s*\[([^\]]*)\]/.exec(flat)?.[1] ?? '').matchAll(/"([^"]+)"/g),
     ].map((match) => match[1].replace(/^\.\//, '').replace(/\/+$/, ''))
@@ -164,29 +222,141 @@ export function swiftManifestTargets(
           return false
         return true
       })
+    const targetArguments = splitManifestArguments(call.slice(0, -1))
+    const dependencyArgument = targetArguments.find((argument) =>
+      /^dependencies\s*:/.test(argument),
+    )
+    const dependencyList = dependencyArgument?.replace(/^dependencies\s*:\s*/, '').trim()
+    const dependencyNames = new Set<string>()
+    if (dependencyList?.startsWith('[') && dependencyList.endsWith(']')) {
+      for (const dependency of splitManifestArguments(dependencyList.slice(1, -1))) {
+        const dependencyName =
+          /^"([^"]+)"$/.exec(dependency)?.[1] ??
+          /^\.(?:target|byName)\s*\(\s*name\s*:\s*"([^"]+)"/.exec(dependency)?.[1]
+        if (dependencyName && targetNames.has(dependencyName))
+          dependencyNames.add(dependencyName)
+      }
+    }
+    const dependencies: SwiftTargetDependency[] = [...dependencyNames].map((name) => ({
+      kind: 'target',
+      name,
+    }))
     targets.push({
       name,
       path: targetPath,
       executable,
       languageMode,
       mainActorIsolation,
+      ...(cxxInterop ? { cxxInterop: true } : {}),
+      ...(defines.length === 0 ? {} : { defines }),
       resources,
+      ...(dependencies.length === 0 ? {} : { dependencies }),
+      ...(excluded.length === 0 ? {} : { exclude: excluded }),
     })
   }
   return targets
 }
 
+/** the root package's declared C++ language standard. */
+export function swiftManifestCxxLanguageStandard(manifest: string): string | undefined {
+  const declaration = manifestCalls(manifest, ['Package'])[0]
+  if (!declaration) return undefined
+  const code = declaration.flat.replace(/"(?:\\.|[^"\\])*"/g, '')
+  return /\bcxxLanguageStandard\s*:\s*\.(\w+)/.exec(code)?.[1]
+}
+
+/** target resource bundles in the original package, before source rewriting. */
+export function swiftResourceBundles(
+  files: Record<string, string>,
+  resourcePaths: readonly string[] = [],
+): SwiftResourceBundle[] {
+  const manifest = files['Package.swift'] ?? ''
+  const targets = swiftManifestTargets(manifest, resourcePaths).filter(
+    (target) => target.resources,
+  )
+  if (targets.length === 0) return []
+  const declaration = manifestCalls(manifest, ['Package'])[0]
+  const packageName =
+    declaration && /\bname\s*:\s*"([^"/\\]+)"/.exec(declaration.flat)?.[1]
+  if (!packageName)
+    throw new Error('swift resource bundles require the original package name')
+  return targets.map((target) => ({
+    target: target.name,
+    sourcePath: target.path,
+    path: `${packageName}_${target.name}.bundle`,
+  }))
+}
+
+/** the one resource target owning a canonical compile-input file. */
+export function swiftResourceBundleForFile(
+  bundles: readonly SwiftResourceBundle[],
+  file: string,
+): SwiftResourceBundle | undefined {
+  let owner: SwiftResourceBundle | undefined
+  for (const bundle of bundles) {
+    const prefix = bundle.sourcePath === '.' ? '' : `${bundle.sourcePath}/`
+    if (
+      file.startsWith(prefix) &&
+      (!owner || bundle.sourcePath.length > owner.sourcePath.length)
+    )
+      owner = bundle
+  }
+  return owner
+}
+
+/** the marker Foundation needs to open a copied resource bundle. */
+export function swiftResourceBundleInfoPlist(bundle: SwiftResourceBundle): string {
+  const name = bundle.path
+    .split('/')
+    .pop()!
+    .replace(/\.(bundle|framework)$/, '')
+  const escaped = name
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+  return `<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"><plist version="1.0"><dict><key>CFBundleName</key><string>${escaped}</string><key>CFBundlePackageType</key><string>${bundle.path.endsWith('.framework') ? 'FMWK' : 'BNDL'}</string></dict></plist>`
+}
+
+/** original metal sources that belong to the package's declared targets. */
+export function swiftMetalSourceFiles(
+  files: Record<string, string>,
+): Record<string, string> {
+  const sources = Object.entries(files).filter(([file]) => file.endsWith('.metal'))
+  if (sources.length === 0) return {}
+  const targets = swiftManifestTargets(files['Package.swift'] ?? '')
+  return Object.fromEntries(
+    sources.filter(([file]) => {
+      if (targets.length === 0) return true
+      return targets.some((target) => {
+        const prefix = target.path === '.' ? '' : `${target.path}/`
+        if (!file.startsWith(prefix)) return false
+        const relative = file.slice(prefix.length)
+        return !(target.exclude ?? []).some(
+          (excluded) => relative === excluded || relative.startsWith(`${excluded}/`),
+        )
+      })
+    }),
+  )
+}
+
 /**
  * the target partition a root manifest declares for the compile. a single
- * executable target at the package root (`path: "."`) holds the whole project,
- * which is the compiler's single-target shape, so it declares no partition.
+ * executable target at the package root (`path: "."`) holds the whole project and
+ * can use the compiler's single-target template only with its default settings.
  */
 export function swiftPackagePartition(
   manifest: string,
   resourcePaths: readonly string[] = [],
 ): SwiftPackageTarget[] {
   const targets = swiftManifestTargets(manifest, resourcePaths)
-  return targets.length === 1 && targets[0].executable && targets[0].path === '.'
+  return targets.length === 1 &&
+    targets[0].executable &&
+    targets[0].path === '.' &&
+    targets[0].languageMode === 5 &&
+    !targets[0].mainActorIsolation &&
+    !targets[0].defines?.length &&
+    !targets[0].cxxInterop &&
+    !swiftManifestCxxLanguageStandard(manifest)
     ? []
     : targets
 }

package/src/swift-packages.ts

@@ -18,6 +18,7 @@ import {
 import {
   swiftPackageManifest,
   swiftTargetFiles,
+  type SwiftManifestDefine,
   type SwiftPackageManifest,
 } from './swift-package-manifest'
 
@@ -40,6 +41,8 @@ export interface SwiftPackageSourceTarget extends SwiftPackageTarget {
   /** the package directory, so a manifest edit reaches the compile. */
   packageDir: string
   remote: boolean
+  /** the conditions its manifest defines, before a build configuration picks them. */
+  packageDefines: SwiftManifestDefine[]
 }
 
 /** why a product or module does not compile, and where it comes from. */
@@ -252,6 +255,7 @@ export function resolveSwiftPackages(options: {
         files,
         packageDir: pkg.manifest.dir,
         remote: pkg.remote,
+        packageDefines: target.defines,
         executable: false,
         languageMode: target.languageMode,
         mainActorIsolation: target.mainActorIsolation,

package/src/swift-standin-emit.ts

@@ -87,6 +87,9 @@ export type StandinResult = {
 /** bump when emitted source changes: the stand-in cache keys on it. */
 export const STANDIN_EMIT_VERSION = '5'
 
+/** the modules every stand-in source imports. */
+export const STANDIN_IMPORTS = ['Foundation', 'UIKit']
+
 const TYPE_KINDS = new Set([
   'swift.class',
   'swift.struct',
@@ -912,7 +915,7 @@ export function emitSwiftStandin(
     emit(`}`)
   }
 
-  const imports = ['Foundation', 'UIKit', ...(options.imports ?? [])]
+  const imports = [...STANDIN_IMPORTS, ...(options.imports ?? [])]
   const banner = [
     `// stand-in for the binary ${options.module} module, generated from ${options.source}.`,
     `// do not hand-edit: every body traps because the vendor binary cannot run`,