peachsim 0.1.2182 → 0.1.2185

package/src/swift-standin-emit.ts

@@ -74,7 +74,7 @@ export function restoreSwiftInterfaceSPI(
   for (const line of interfaceText.split('\n')) {
     const enclosing = scopes.at(-1)?.path ?? []
     const declaration =
-      /^\s*(?:@[\w.]+(?:\([^)]*\))?\s+|\w+\s+)*?(class(?!\s+(?:func|var|subscript)\b)|struct|enum|protocol|actor|extension|func|var|let|init|subscript|typealias|case)\b\s*([\w.`]*)/.exec(
+      /^\s*(?:@[\w.]+(?:\([^)]*\))?\s+|\w+\s+)*?(class(?!\s+(?:func|var|subscript)\b)|struct|enum|protocol|actor|extension|func|var|let|init|subscript|typealias|case)\b\s*([/=\-+!*%<>&|^~?]+|[\w.`]*)/.exec(
         line.replace(/::/g, '.'),
       )
     if (declaration) {
@@ -178,6 +178,8 @@ export type StandinOptions = {
   plain?: ReadonlySet<string>
   /** paths whose type the guest cannot represent in objective-c: emitted without @objc */
   unobjc?: ReadonlySet<string>
+  /** class path → objective-c protocols the compiler found its witnesses mismatch (nullability a swift protocol checks); the class drops the conformance */
+  unconformed?: ReadonlyMap<string, ReadonlySet<string>>
   /** paths the compiler says must be marked override */
   forcedOverride?: ReadonlySet<string>
   /** class path → its generic superclass with arguments, from the swiftinterface */
@@ -267,6 +269,25 @@ const KEEP_EXTERNAL = new Map([
   ['s:Se', 'Decodable'],
   ['s:s23CustomStringConvertibleP', 'CustomStringConvertible'],
   ['s:s9CodingKeyP', 'CodingKey'],
+  ['s:SL', 'Comparable'],
+  ['s:ST', 'Sequence'],
+  ['s:St', 'IteratorProtocol'],
+  ['s:Sl', 'Collection'],
+  ['s:SK', 'BidirectionalCollection'],
+  ['s:Sk', 'RandomAccessCollection'],
+  ['s:SM', 'MutableCollection'],
+  ['s:Sm', 'RangeReplaceableCollection'],
+  ['s:s28CustomDebugStringConvertibleP', 'CustomDebugStringConvertible'],
+  ['s:s25LosslessStringConvertibleP', 'LosslessStringConvertible'],
+  ['s:s20TextOutputStreamableP', 'TextOutputStreamable'],
+  ['s:Sx', 'Strideable'],
+  ['s:s18AdditiveArithmeticP', 'AdditiveArithmetic'],
+  ['s:s25ExpressibleByArrayLiteralP', 'ExpressibleByArrayLiteral'],
+  ['s:s30ExpressibleByDictionaryLiteralP', 'ExpressibleByDictionaryLiteral'],
+  ['s:s26ExpressibleByStringLiteralP', 'ExpressibleByStringLiteral'],
+  ['s:s27ExpressibleByIntegerLiteralP', 'ExpressibleByIntegerLiteral'],
+  ['s:s25ExpressibleByFloatLiteralP', 'ExpressibleByFloatLiteral'],
+  ['s:s27ExpressibleByBooleanLiteralP', 'ExpressibleByBooleanLiteral'],
 ])
 const LEADING_ATTRS = /^((?:@\w+(?:\([^)]*\))?\s*|nonisolated\s+)*)(.*)$/s
 
@@ -1488,9 +1509,15 @@ export function emitSwiftStandin(
                 !(
                   parent &&
                   objectConformers.has(id) &&
-                  ['Hashable', 'Equatable', 'CustomStringConvertible'].includes(name)
+                  [
+                    'Hashable',
+                    'Equatable',
+                    'CustomStringConvertible',
+                    'CustomDebugStringConvertible',
+                  ].includes(name)
                 ) &&
-                !(name === nsObjectProtocol && externalRoot(id) === nsObject),
+                !(name === nsObjectProtocol && externalRoot(id) === nsObject) &&
+                !options.unconformed?.get(path)?.has(name),
             ),
           ].filter((name, at, all) => all.indexOf(name) === at)
           const parentSymbol = superId.has(id) ? byId.get(superId.get(id)!) : undefined

package/src/swift-standins.ts

@@ -45,6 +45,7 @@ import {
 } from './swift-objc-standin'
 import {
   clangImportNames,
+  moduleMapModules,
   moduleMapName,
   swiftManifestDeclarations,
   swiftTargetModuleName,
@@ -674,6 +675,22 @@ function cxxOnly(surface: Surface): boolean {
   })
 }
 
+// the surfaces of a library slice's module map, one per module it declares: a
+// uniffi xcframework ships a module per generated header in one map, and an
+// app imports each by name.
+function mapSurfaces(modulemap: string): SliceSurface[] {
+  const text = fs.readFileSync(modulemap, 'utf8')
+  const headers = path.dirname(modulemap)
+  const modules = moduleMapModules(text)
+  if (modules.length <= 1) {
+    const module = moduleMapName(text)
+    return module ? [headerSurface(module, modulemap, headers)] : []
+  }
+  return modules.map((module) =>
+    headerSurface(module.name, generatedModuleMap(`${module.text}\n`, false), headers),
+  )
+}
+
 function simulatorSlice(xcframeworkDir: string): string | null {
   const slice = fs
     .readdirSync(xcframeworkDir)
@@ -762,8 +779,7 @@ function surfaces(
   const headers = path.join(root, 'Headers')
   for (const map of files(headers, (name) => name === 'module.modulemap')) {
     const modulemap = path.join(headers, map)
-    const module = moduleMapName(fs.readFileSync(modulemap, 'utf8'))
-    if (module) found.push(headerSurface(module, modulemap, path.dirname(modulemap)))
+    found.push(...mapSurfaces(modulemap))
   }
   if (found.length === 0 && files(headers, (name) => name.endsWith('.h')).length) {
     const module = swiftTargetModuleName(target)
@@ -964,13 +980,22 @@ export function swiftInterfaceForWasm(text: string, cFlags: readonly string[]):
     ])
     return `${interop} ${xcc.join(' ')}`
   })
-  return retargeted
-    .split('\n')
+  const lines = retargeted.split('\n')
+  // an optional requirement stays @objc, so a type its signature names must be
+  // objective-c representable: an enum it names keeps its own @objc
+  const required = lines.filter((line) => OPTIONAL_REQUIREMENT.test(line)).join('\n')
+  return lines
     .map((line) => {
       // an enum's @objc only bridges it to objective-c, which wasm has no
       // runtime for, and an @objc error enum loses its raw-value Hashable.
-      if (/\benum\s/.test(line) && TYPE_DECLARATION.test(line))
-        return line.replace(/@objc(?:\s*\([^()]*\))?\s+/g, '')
+      if (/\benum\s/.test(line) && TYPE_DECLARATION.test(line)) {
+        const name = /\benum\s+(\w+)/.exec(line)?.[1]
+        return name &&
+          new RegExp(`\\b${name}\\b`).test(required) &&
+          !/\bSwift\.Error\b/.test(line)
+          ? line
+          : line.replace(/@objc(?:\s*\([^()]*\))?\s+/g, '')
+      }
       if (TYPE_DECLARATION.test(line)) return line.replace(/@objcMembers\b/g, '')
       if (OPTIONAL_REQUIREMENT.test(line)) return line
       return line.replace(OBJC_ATTRIBUTE, '')
@@ -1522,6 +1547,18 @@ function graphStandin(
   const plain = new Set<string>()
   const unobjc = new Set<string>()
   const trapped = new Set<string>()
+  const unconformed = new Map<string, Set<string>>()
+  const objcProtocols = new Set(
+    graphs.flatMap((graph) =>
+      graph.symbols
+        .filter(
+          (symbol) =>
+            symbol.kind.identifier === 'swift.protocol' &&
+            symbol.identifier.precise.startsWith('c:'),
+        )
+        .map((symbol) => symbol.pathComponents.join('.')),
+    ),
+  )
   const file = path.join(work, `${module}.swift`)
   // a source target whose implementation compiles keeps inert bodies, and a
   // placeholder sends nothing. a target replaced because assembly cannot
@@ -1540,6 +1577,7 @@ function graphStandin(
       omit,
       plain,
       unobjc,
+      unconformed,
       trapped,
       inert,
       imports: [...(placeholder?.peachImports ?? []), ...imports],
@@ -1589,7 +1627,7 @@ function graphStandin(
         files: { [`${module}.swift`]: source },
         ...(imports.length ? { dependencies: imports } : {}),
       }
-    const before = omit.size + plain.size + unobjc.size + trapped.size
+    const before = omit.size + plain.size + unobjc.size + trapped.size + unconformed.size
     const elsewhere: string[] = []
     for (const match of check.stderr.matchAll(/^(\S+?):(\d+):\d+: error: (.*)$/gm)) {
       const owner = match[1] === file ? owners[Number(match[2]) - 1] : undefined
@@ -1599,6 +1637,15 @@ function graphStandin(
         unobjc.add(owner)
         continue
       }
+      // an objective-c protocol the guest adapts to a swift one checks the
+      // nullability a swift class's exported witness differs in
+      const conformance = /^type '\w+' does not conform to protocol '(\w+)'$/.exec(
+        match[3]!,
+      )?.[1]
+      if (owner && conformance && objcProtocols.has(conformance)) {
+        unconformed.set(owner, new Set([...(unconformed.get(owner) ?? []), conformance]))
+        continue
+      }
       if (owner && swiftPaths.has(owner))
         throw new Error(
           `Swift declaration ${module}.${owner} does not typecheck: ${match[3]}`,
@@ -1615,7 +1662,7 @@ function graphStandin(
       else if (owner) omit.set(owner, `rejected by swiftc: ${match[3]}`)
       else elsewhere.push(match[3]!)
     }
-    if (omit.size + plain.size + unobjc.size + trapped.size === before)
+    if (omit.size + plain.size + unobjc.size + trapped.size + unconformed.size === before)
       throw new Error(
         `its generated source does not typecheck: ${elsewhere.slice(0, 3).join('; ') || check.stderr.trim().slice(0, 400)}`,
       )
@@ -1788,7 +1835,20 @@ function cStandin(
   toolchain: Toolchain,
   work: string,
 ): SwiftStandin {
-  const headers = files(surface.headers, (name) => name.endsWith('.h'))
+  const everyHeader = files(surface.headers, (name) => name.endsWith('.h'))
+  const moduleRoots = moduleMapHeaders(surface.modulemap, everyHeader)
+  // the module's headers and the local headers they include: a map of several modules
+  // (one per uniffi header) gives each its own
+  const headers = [...moduleRoots]
+  for (let at = 0; at < headers.length; at++)
+    for (const [, local] of fs
+      .readFileSync(path.join(surface.headers, headers[at]!), 'utf8')
+      .matchAll(/^\s*#\s*(?:include|import)\s*["<]([^">]+)[">]/gm)) {
+      const file = path.posix.normalize(
+        path.posix.join(path.posix.dirname(headers[at]!), local!),
+      )
+      if (everyHeader.includes(file) && !headers.includes(file)) headers.push(file)
+    }
   const framework = path.basename(path.dirname(surface.modulemap)) === 'Modules'
   const headerDirectory = framework ? `${surface.module}.framework/Headers` : '.'
   const texts = new Map(
@@ -1804,9 +1864,7 @@ function cStandin(
     fs.mkdirSync(path.dirname(path.join(include, file)), { recursive: true })
     fs.writeFileSync(path.join(include, file), text)
   }
-  const roots = moduleMapHeaders(surface.modulemap, headers).map((file) =>
-    path.posix.join(headerDirectory, file),
-  )
+  const roots = moduleRoots.map((file) => path.posix.join(headerDirectory, file))
   const frameworkMap = `${surface.module}.framework/Modules/module.modulemap`
   const modulemap = `module ${surface.module} {\n${roots.map((file) => `  header "${file}"\n`).join('')}  export *\n}\n`
   const probe = path.join(work, 'declarations.c')
@@ -2728,9 +2786,14 @@ async function binaryStandins(
     fs.rmSync(work, { recursive: true, force: true })
     return error instanceof Error ? error.message : String(error)
   }
+  // a framework whose module map names headers it does not ship declares nothing
   const found = all.filter(
     (surface) =>
       !provided.has(surface.module) &&
+      (surface.kind === 'swift' ||
+        surface.kind === 'mixed' ||
+        surface.kind === 'source' ||
+        files(surface.headers, (name) => name.endsWith('.h')).length > 0) &&
       !(binary.cxxHeaders === undefined && cxxOnly(surface)),
   )
   if (found.length === 0) {