peachsim 0.1.2219 → 0.1.2221

package/sdk/ios/System/Library/Frameworks/UIKitTypes.framework/Headers/UILayoutPriority.h

@@ -0,0 +1,11 @@
+#pragma once
+#import <Foundation/Foundation.h>
+
+typedef float UILayoutPriority NS_TYPED_EXTENSIBLE_ENUM API_UNAVAILABLE(watchos);
+static const UILayoutPriority UILayoutPriorityRequired API_AVAILABLE(ios(6.0)) API_UNAVAILABLE(watchos) = 1000; // A required constraint.  Do not exceed this.
+static const UILayoutPriority UILayoutPriorityDefaultHigh API_AVAILABLE(ios(6.0)) API_UNAVAILABLE(watchos) = 750; // This is the priority level with which a button resists compressing its content.
+static const UILayoutPriority UILayoutPriorityDragThatCanResizeScene API_AVAILABLE(macCatalyst(13.0)) API_UNAVAILABLE(watchos) = 510; // This is the appropriate priority level for a drag that may end up resizing the window's scene.
+static const UILayoutPriority UILayoutPrioritySceneSizeStayPut API_AVAILABLE(macCatalyst(13.0)) API_UNAVAILABLE(watchos) = 500; // This is the priority level at which the window's scene prefers to stay the same size.  It's generally not appropriate to make a constraint at exactly this priority. You want to be higher or lower.
+static const UILayoutPriority UILayoutPriorityDragThatCannotResizeScene API_AVAILABLE(macCatalyst(13.0)) API_UNAVAILABLE(watchos) = 490; // This is the priority level at which a split view divider, say, is dragged.  It won't resize the window's scene.
+static const UILayoutPriority UILayoutPriorityDefaultLow API_AVAILABLE(ios(6.0)) API_UNAVAILABLE(watchos) = 250; // This is the priority level at which a button hugs its contents horizontally.
+static const UILayoutPriority UILayoutPriorityFittingSizeLevel API_AVAILABLE(ios(6.0)) API_UNAVAILABLE(watchos) = 50; // When you send -[UIView systemLayoutSizeFittingSize:], the size fitting most closely to the target size (the argument) is computed.  UILayoutPriorityFittingSizeLevel is the priority level with which the view wants to conform to the target size in that computation.  It's quite low.  It is generally not appropriate to make a constraint at exactly this priority.  You want to be higher or lower.

package/src/swift-compile.ts

@@ -424,11 +424,14 @@ export function swiftModuleInterface(
 // the compiler imports the module that defines a type, and UIKit's declarations
 // live in UIKitCore/UIKitText, which only the umbrella UIKit module represents
 // to clang. CoreFoundation's CGFloat lives in the Swift CoreFoundation overlay,
-// while clang's Foundation umbrella provides CoreFoundation/CoreFoundation.h.
+// while clang's Foundation umbrella also owns networking class declarations.
 const clangInterfaceHeader = (header: string): string =>
   header
     .replace(/^@import (?:UIKitCore|UIKitText);$/gm, '@import UIKit;')
-    .replace(/^@import CoreFoundation;$/gm, '@import Foundation;')
+    .replace(
+      /^@import (?:CoreFoundation|FoundationNetworking);$/gm,
+      '@import Foundation;',
+    )
     .replace(/\b_TtC10Foundation\d+(NS\w+)\b/g, '$1')
     .replace(/\b__attribute__\(\(objc_subclassing_restricted\)\)\s*/g, '')
 
@@ -1853,6 +1856,7 @@ export function emitSwiftPackageManifest(args: {
   nativeFlags?: Map<string, string[]>
   nativeImportFlags?: Map<string, string[]>
   nativeHeaderFlags?: string[]
+  nativeSwiftHeaderMaps?: ReadonlyMap<string, string>
   nativeHeaderDeclarations?: Readonly<Record<string, readonly string[]>>
   objcImplementationModules?: Set<string>
   siblings: Map<string, string[]>
@@ -2163,6 +2167,11 @@ export function emitSwiftPackageManifest(args: {
       includeImportContext(dependency)
     const importedNativeFlags = [
       ...(args.nativeImportFlags?.get(target.name) ?? []),
+      ...[...importContext].flatMap((name) => {
+        const map =
+          name === target.name ? undefined : args.nativeSwiftHeaderMaps?.get(name)
+        return map ? ['-fmodule-map-file=' + map] : []
+      }),
       ...[...importContext].flatMap((name) => args.native?.get(name)?.importFlags ?? []),
       ...[...importContext].flatMap((name) => {
         const flags = targets.find((target) => target.name === name)?.swiftFlags ?? []
@@ -4610,6 +4619,7 @@ export function writeSwiftProject(
   // declarations are imported before swift can emit the header that native
   // implementations consume. give those implementations a downstream target.
   const importModuleMaps = new Map<string, string>()
+  const sourceModuleMaps = new Map<string, { path: string; contents: string }>()
   const generatedModuleMaps: { output: string; module: string; published: string }[] = []
   for (const target of targets) {
     const prefix = target.path === '.' ? '' : `${target.path}/`
@@ -4938,6 +4948,10 @@ export function writeSwiftProject(
         stageTargetFile(target.name, path.join(layout.root, modulemap), moduleContents, {
           allowExisting: true,
         })
+        sourceModuleMaps.set(swiftTargetModuleName(target.name), {
+          path: path.join(layout.root, modulemap),
+          contents: moduleContents.toString(),
+        })
         // clang resolves a framework map loaded through extern module against
         // the map directory, not the framework root, so mirror every header
         // the map names there. clang looks in Headers/ and PrivateHeaders/ for
@@ -5272,6 +5286,7 @@ export function writeSwiftProject(
       ? ['-ivfsoverlay', headerSearch.files[0]!]
       : []
   const nativeHeaderFlags: string[] = [...headerAliasFlags]
+  const nativeSwiftHeaderMaps = new Map<string, string>()
   const originalMaps = new Map<string, string>()
   for (const target of input.nativeTargets ?? []) {
     for (const flag of [...target.flags, ...target.cxxFlags]) {
@@ -5304,9 +5319,14 @@ export function writeSwiftProject(
     )
     const moduleName = swiftTargetModuleName(name)
     const originalMap = originalMaps.get(moduleName)
-    const originalTokens = originalMap ? moduleMapTokens(input.files[originalMap]!) : []
+    const stagedMap = sourceModuleMaps.get(moduleName)
+    const originalPath = originalMap
+      ? path.join(layout.root, originalMap)
+      : stagedMap?.path
+    const originalContents = originalMap ? input.files[originalMap]! : stagedMap?.contents
+    const originalTokens = originalContents ? moduleMapTokens(originalContents) : []
     if (
-      originalMap &&
+      originalPath &&
       originalTokens.some(
         (token, index) =>
           token === 'module' &&
@@ -5314,26 +5334,26 @@ export function writeSwiftProject(
             originalTokens[index + 1] === `${moduleName}.Swift`),
       )
     ) {
-      nativeHeaderFlags.push('-fmodule-map-file=' + path.join(layout.root, originalMap))
+      nativeHeaderFlags.push('-fmodule-map-file=' + originalPath)
+      nativeSwiftHeaderMaps.set(name, originalPath)
       continue
     }
     files.set(
       modulemap,
-      originalMap
-        ? `extern module ${moduleName} ${JSON.stringify(path.join(layout.root, originalMap))}\nmodule ${moduleName}.Swift {\n  header ${JSON.stringify(path.join(headerDirectory, name + '-Swift.h'))}\n  requires objc\n}\n`
+      originalPath
+        ? `extern module ${moduleName} ${JSON.stringify(originalPath)}\nmodule ${moduleName}.Swift {\n  header ${JSON.stringify(path.join(headerDirectory, name + '-Swift.h'))}\n  requires objc\n}\n`
         : swiftObjCModuleMap(
             moduleName,
-            [
-              ...(
-                input.nativeTargets?.find((target) => target.name === name)
-                  ?.publicHeaders ?? []
-              ).map((header) => path.join(layout.root, header)),
-              path.join(headerDirectory, name + '-Swift.h'),
-            ],
+            (
+              input.nativeTargets?.find((target) => target.name === name)
+                ?.publicHeaders ?? []
+            ).map((header) => path.join(layout.root, header)),
             submoduleImports.get(moduleName),
+            path.join(headerDirectory, name + '-Swift.h'),
           ),
     )
     nativeHeaderFlags.push('-fmodule-map-file=' + modulemap)
+    nativeSwiftHeaderMaps.set(name, modulemap)
   }
   // swiftpm plans a build root's build once and reuses the plan until a
   // manifest changes, so a file added to the module would never compile
@@ -5788,6 +5808,7 @@ export function writeSwiftProject(
         nativeFlags,
         nativeImportFlags,
         nativeHeaderFlags,
+        nativeSwiftHeaderMaps,
         nativeHeaderDeclarations,
         objcImplementationModules: new Set(
           targets
@@ -5974,31 +5995,30 @@ export function writeSwiftProject(
       ),
     ]),
   )
+  const producerSet = new Set([...Object.keys(nativeHeaderDeclarations), ...producers])
+  const orderedProducers: string[] = []
   const included = new Set<string>()
   const include = (name: string): void => {
     if (included.has(name)) return
     included.add(name)
     for (const dependency of dependencies.get(name) ?? []) include(dependency)
+    if (producerSet.has(name)) orderedProducers.push(name)
   }
-  for (const producer of producers)
+  for (const producer of producerSet)
     for (const dependency of dependencies.get(producer) ?? []) include(dependency)
-  // building a producer also emits its dependency producers' headers.
+  const needsHeaderStages = [...producerSet].some((name) => included.has(name))
+  for (const producer of producerSet) include(producer)
   return {
     nativeBuildTargets: [...native].flatMap(([name, plan]) => [
       ...(!plan.mixed && plan.sources.length > 0 ? [name] : []),
       ...(plan.groups?.map((group) => group.name) ?? (plan.late ? [plan.late.name] : [])),
     ]),
-    headerProducers: [
-      ...new Set([
-        ...Object.keys(nativeHeaderDeclarations),
-        ...producers.filter((name) => !included.has(name)),
-      ]),
-    ],
+    headerProducers: orderedProducers,
     emittedHeaderProducers: [
       ...new Set([...Object.keys(nativeHeaderDeclarations), ...producers]),
     ],
     nativeHeaderDeclarations,
-    headerProductTarget,
+    headerProductTarget: needsHeaderStages ? undefined : headerProductTarget,
     targetFailures,
     generatedOwners,
     targetToolset,

package/src/swift-host.ts

@@ -1,5 +1,5 @@
 import { AsyncLocalStorage } from 'node:async_hooks'
-import { execFileSync } from 'node:child_process'
+import { execFile, execFileSync } from 'node:child_process'
 import { createHash } from 'node:crypto'
 // the node host for every Swift preview: package inputs, one compile and
 // immutable artifact addresses. vite and the foreground CLI adapt this host.
@@ -42,6 +42,7 @@ import {
   swiftDistributionAt,
   swiftOptionalFramework,
   compilerSourceDigest,
+  swiftSdkPaths,
 } from './swift-compile'
 import {
   assetSymbolText,
@@ -522,6 +523,79 @@ export function configureSwiftStandinBehavior(
 const standinBuilds = new Map<string, Promise<SwiftStandins>>()
 
 // packages resolve once per set of linked products, pins and local manifests.
+// assembly guarded to the architectures it was written for preprocesses to
+// nothing for wasm32 under the target's own headers and the sdk's c flags, so
+// swiftpm builds that target as plain c instead of it standing in. a file that
+// fails to preprocess (#error on an unknown platform) keeps the stand-in.
+const emptyWasmAssembly = new Map<string, Promise<boolean>>()
+async function wasmPortableAssembly(
+  binaries: readonly SwiftPackageBinary[],
+  toolchainBin: string,
+  moduleRoot: string,
+): Promise<Set<string>> {
+  const assembly = binaries.filter(
+    (binary) =>
+      binary.unloweredSources?.length &&
+      binary.unloweredSources.every((file) => /\.(s|S)$/.test(file)) &&
+      binary.publicHeaders !== undefined,
+  )
+  if (assembly.length === 0) return new Set()
+  const sdk = swiftSdkPaths(moduleRoot, toolchainBin)
+  const clang = path.join(toolchainBin, 'clang')
+  const empty = (binary: SwiftPackageBinary, file: string) => {
+    const source = path.join(binary.dir, file)
+    const key = createHash('sha256')
+      .update(
+        JSON.stringify([
+          clang,
+          sdk.sysroot,
+          sdk.cFlags,
+          binary.dir,
+          binary.publicHeaders,
+        ]),
+      )
+      .update(fs.readFileSync(source))
+      .digest('hex')
+    const known = emptyWasmAssembly.get(key)
+    if (known) return known
+    const result = new Promise<boolean>((resolve) =>
+      execFile(
+        clang,
+        [
+          '-target',
+          'wasm32-unknown-wasip1',
+          '--sysroot',
+          sdk.sysroot,
+          ...sdk.cFlags,
+          '-I',
+          path.join(binary.dir, binary.publicHeaders!),
+          '-I',
+          path.dirname(source),
+          '-E',
+          '-P',
+          '-x',
+          'assembler-with-cpp',
+          source,
+        ],
+        { maxBuffer: 64 * 1024 * 1024 },
+        (error, stdout) => resolve(!error && stdout.trim() === ''),
+      ),
+    )
+    emptyWasmAssembly.set(key, result)
+    return result
+  }
+  const portable = await Promise.all(
+    assembly.map(async (binary) =>
+      (
+        await Promise.all(binary.unloweredSources!.map((file) => empty(binary, file)))
+      ).every(Boolean)
+        ? [binary.target]
+        : [],
+    ),
+  )
+  return new Set(portable.flat())
+}
+
 async function swiftPackages(
   entry: XcodeProjectEntry,
   app: XcodeAppTarget,
@@ -616,7 +690,14 @@ async function swiftPackages(
         entry.moduleRoot,
         path.join(resolved.toolchainBin, 'clang++'),
       )
-    const cxxArtifacts = reached.filter(standinArtifact)
+    const portableAssembly = await wasmPortableAssembly(
+      reached,
+      resolved.toolchainBin,
+      entry.moduleRoot,
+    )
+    const cxxArtifacts = reached.filter(
+      (binary) => standinArtifact(binary) && !portableAssembly.has(binary.target),
+    )
     const generation = standinGenerationInputs(cxxArtifacts, toolchain, entry.behavior)
     if (cached.standinKey !== generation) {
       // an archive other than the one peach ships a module for stands in itself
@@ -648,6 +729,7 @@ async function swiftPackages(
           [...replaced].filter((target) => !built.gaps.has(target)),
         ),
         binaryGaps: built.gaps,
+        portableAssembly,
         owners,
       })
       for (const target of new Set(built.standins.map((standin) => standin.target)))

package/src/swift-objc-import.ts

@@ -49,6 +49,7 @@ export function swiftObjCModuleMap(
   module: string,
   headers: readonly string[],
   submodules: ReadonlySet<string> = new Set(),
+  swiftHeader?: string,
 ): string {
   const header = (file: string) => `header ${JSON.stringify(file)}`
   const stem = (file: string) =>
@@ -60,6 +61,9 @@ export function swiftObjCModuleMap(
         ? `  module ${stem(file)} { ${header(file)} export * }`
         : `  ${header(file)}`,
     ),
+    ...(swiftHeader
+      ? ['  module Swift {', `    ${header(swiftHeader)}`, '    requires objc', '  }']
+      : []),
     '  export *',
     '}',
     '',

package/src/swift-packages.ts

@@ -165,18 +165,23 @@ const UNSUPPORTED_NATIVE = /\.(s|S)$/
 // return address, cannot lower to wasm, unless upstream declares
 // wasi-conditioned c settings for it: that is the package's own supported
 // portable path (boringssl's guarded assembly with OPENSSL_NO_ASM), which
-// compiles with those flags exactly as swiftpm builds it. without that signal
-// the target keeps the refusal below. when a refused target also ships public
-// headers, those headers stand in for it and every declaration they spell
-// traps by name. this is the assembly rule above, widened only where the
-// target has a header surface to stand in from.
+// compiles with those flags exactly as swiftpm builds it. assembly that
+// preprocesses to nothing for wasm32 (guarded to the architectures it was
+// written for) is the same portable path without the signal: swiftpm compiles
+// it as plain c. otherwise the target keeps the refusal below. when a refused
+// target also ships public headers, those headers stand in for it and every
+// declaration they spell traps by name. this is the assembly rule above,
+// widened only where the target has a header surface to stand in from.
 function unlowerableSources(
   files: readonly string[],
   target: SwiftManifestTarget,
+  portable: ReadonlySet<string>,
 ): string[] {
   if (target.declaresWasiNativeSettings) return []
   return [
-    ...files.filter((file) => UNSUPPORTED_NATIVE.test(file)),
+    ...(portable.has(target.name)
+      ? []
+      : files.filter((file) => UNSUPPORTED_NATIVE.test(file))),
     ...files
       .filter(isSwiftNativeTranslationUnit)
       .filter((file) => swiftCTakesReturnAddress(fs.readFileSync(file, 'utf8'))),
@@ -186,10 +191,11 @@ function unlowerableSources(
 function unloweredSources(
   files: readonly string[],
   target: SwiftManifestTarget,
+  portable: ReadonlySet<string>,
 ): string[] | null {
   if (target.type !== 'regular') return null
   if (!files.some(isSwiftNativeTranslationUnit)) return null
-  const unlowered = unlowerableSources(files, target)
+  const unlowered = unlowerableSources(files, target, portable)
   if (unlowered.length === 0) return null
   const headers = path.resolve(target.dir, target.publicHeadersPath)
   if (
@@ -533,6 +539,8 @@ export function resolveSwiftPackages(options: {
   standinTargets?: ReadonlySet<string>
   /** why a binary target has no stand-in, added to its reason. */
   binaryGaps?: ReadonlyMap<string, string>
+  /** assembly targets whose sources preprocess to nothing for wasm32. */
+  portableAssembly?: ReadonlySet<string>
   /**
    * each compiling module and the package products it links. a clang target
    * in that product's closure records the module as a client.
@@ -542,6 +550,7 @@ export function resolveSwiftPackages(options: {
 }): SwiftPackages {
   const { rootDir, resolved, products, localDirs } = options
   const providedTargets = new Set(options.provided ?? [])
+  const portableAssembly = options.portableAssembly ?? new Set<string>()
   const providedProducts = new Set(options.provided ?? [])
   const result: SwiftPackages = {
     sourceLinks: { targets: [], owners: [] },
@@ -674,7 +683,7 @@ export function resolveSwiftPackages(options: {
           ? swiftTargetFiles(pkg.manifest, target)
           : []
       const gap = options.binaryGaps?.get(name)
-      const unlowerable = unlowerableSources(files, target)
+      const unlowerable = unlowerableSources(files, target, portableAssembly)
       const placeholder = placeholderPackage(pkg)
       const ownReason =
         target.type === 'binary'
@@ -794,7 +803,7 @@ export function resolveSwiftPackages(options: {
     )
       return false
     // a target whose headers stand in for its unlowered sources stays with the stand-in
-    if (unloweredSources(files, target)) return false
+    if (unloweredSources(files, target, portableAssembly)) return false
     claimed.add(key)
     providedTargets.delete(name)
     for (const dependency of target.dependencies) {
@@ -865,7 +874,7 @@ export function resolveSwiftPackages(options: {
           : []
       const objc =
         target.type === 'regular' && files.some((file) => /\.(m|mm)$/.test(file))
-      const unlowered = unloweredSources(files, target)
+      const unlowered = unloweredSources(files, target, portableAssembly)
       const gap = placeholderPackage(pkg)
       const sources = files.filter((file) => file.endsWith('.swift'))
       // swiftpm's release settings, as xcode builds a package for any

package/src/swift-standins.ts

@@ -1747,7 +1747,7 @@ function graphStandin(
       before
     )
       throw new Error(
-        `its generated source does not typecheck: ${elsewhere.slice(0, 3).join('; ') || check.stderr.trim().slice(0, 400)}`,
+        `its generated source does not typecheck: ${(elsewhere.length > 0 ? elsewhere : [...check.stderr.matchAll(/^\S+?:\d+:\d+: error: .*$/gm)].map((line) => line[0].replace(/^[^:]*\//, ''))).slice(0, 3).join('; ') || check.stderr.trim().slice(0, 400)}`,
       )
   }
 }