peachsim 0.1.1641 → 0.1.1653

package/src/swift-objc-standin.ts

@@ -32,6 +32,8 @@ export interface ObjcSurface {
 
 export interface ObjcView {
   graphs: SymbolGraph[]
+  /** present for original implementations, read without repairing declarations. */
+  clangAST?: unknown
   /** precise enum case and option ids → their header values. */
   values: Map<string, string>
   /** the modules the headers import besides their own. */
@@ -206,6 +208,7 @@ export function objcView(
   stdlib: string,
   cacheDir: string,
   work: string,
+  original?: { flags: readonly string[]; target: string },
 ): ObjcView {
   if (!fs.existsSync(stdlib))
     throw new Error(
@@ -220,6 +223,7 @@ export function objcView(
   const headersDir = framework
     ? path.join(frameworks, `${surface.module}.framework`, 'Headers')
     : path.join(include, surface.module)
+  fs.mkdirSync(headersDir, { recursive: true })
   const originals = new Map(
     headerFiles(surface.headers).map((file) => [
       path.join(headersDir, file),
@@ -373,8 +377,9 @@ export function objcView(
         '-module-name',
         surface.module,
         '-target',
-        IOS_SDK_TARGET,
+        original?.target ?? IOS_SDK_TARGET,
         ...search,
+        ...(original?.flags.flatMap((flag) => ['-Xcc', flag]) ?? []),
         '-module-cache-path',
         path.join(cacheDir, 'ios-module-cache'),
         '-minimum-access-level',
@@ -391,6 +396,10 @@ export function objcView(
       ...run.stderr.matchAll(/^(?:(.+?):(\d+):(\d+): )?(?:fatal )?error: (.*)$/gm),
     ]
     if (errors.length === 0 && run.status === 0) break
+    if (original)
+      throw new Error(
+        `original Objective-C declarations do not import as Swift: ${run.stderr.trim() || run.stdout.trim()}`,
+      )
     let progress = false
     const learn = (name: string, kind: 'class' | 'protocol' | 'struct' | 'macro') => {
       if (missing.has(name)) return
@@ -452,11 +461,138 @@ export function objcView(
   imports.delete(surface.module)
   return {
     graphs,
+    ...(original
+      ? {
+          clangAST: objcDeclarationAST(
+            surface,
+            framework,
+            toolchainBin,
+            search,
+            work,
+            original.flags,
+            original.target,
+          ),
+        }
+      : {}),
     values: enumValues(graphs, surface, framework, toolchainBin, search, work),
     imports: [...imports].sort(),
   }
 }
 
+function objcDeclarationAST(
+  surface: ObjcSurface,
+  framework: boolean,
+  toolchainBin: string,
+  search: string[],
+  work: string,
+  originalFlags: readonly string[],
+  target: string,
+): unknown {
+  const roots = [
+    ...fs
+      .readFileSync(surface.modulemap, 'utf8')
+      .matchAll(/(?:umbrella\s+)?header\s+"([^"]+)"/g),
+  ].map((match) => match[1]!)
+  const probe = path.join(work, 'declarations.m')
+  fs.writeFileSync(
+    probe,
+    roots
+      .map((file) =>
+        framework ? `#import <${surface.module}/${file}>\n` : `#import "${file}"\n`,
+      )
+      .join(''),
+  )
+  const flags: string[] = []
+  for (let index = 0; index < search.length; index += 2) {
+    const [flag, value] = [search[index]!, search[index + 1]!]
+    // the swift resource directory contains swift overlays, not clang builtins.
+    if (flag === '-resource-dir') continue
+    flags.push(flag === '-sdk' ? '-isysroot' : flag, value)
+  }
+  const args = [
+    '-x',
+    'objective-c',
+    '-fobjc-arc',
+    '-fblocks',
+    '-fsyntax-only',
+    '-target',
+    target,
+    ...flags,
+    ...originalFlags,
+    `-fmodule-name=${surface.module}`,
+    '-Xclang',
+    '-ast-dump-all=json',
+  ]
+  const dump = (filter?: string) => {
+    const run = spawnSync(
+      path.join(toolchainBin, 'clang'),
+      [
+        ...args,
+        ...(filter ? ['-Xclang', '-ast-dump-filter', '-Xclang', filter] : []),
+        probe,
+      ],
+      { encoding: 'utf8', env: swiftEnvironment(), maxBuffer: 256 * 1024 * 1024 },
+    )
+    if (run.error) throw run.error
+    if (run.status !== 0)
+      throw new Error(`original Objective-C declaration AST failed: ${run.stderr.trim()}`)
+    return run.stdout
+  }
+  const ast: unknown = JSON.parse(dump())
+  const children: unknown =
+    ast && typeof ast === 'object' ? Reflect.get(ast, 'inner') : undefined
+  if (!Array.isArray(children))
+    throw new Error('original Objective-C declaration AST has no translation unit')
+  const inner: unknown[] = children
+  // clang lazily omits module typedefs from a translation unit dump, even with
+  // ast-dump-all. named lookup deserializes the original typedef declarations.
+  // C function result types lack the desugared type that parameters carry.
+  const aliases = new Set<string>()
+  const declared = new Set<string>()
+  for (const node of inner) {
+    if (!node || typeof node !== 'object') continue
+    if (Reflect.get(node, 'kind') === 'TypedefDecl')
+      declared.add(String(Reflect.get(node, 'name')))
+    if (Reflect.get(node, 'kind') !== 'FunctionDecl') continue
+    const type: unknown = Reflect.get(node, 'type')
+    const written: unknown =
+      type && typeof type === 'object' ? Reflect.get(type, 'qualType') : undefined
+    const name =
+      typeof written === 'string' ? /^([A-Za-z_]\w*)\s*\(/.exec(written)?.[1] : undefined
+    if (name) aliases.add(name)
+  }
+  for (const alias of aliases) {
+    if (
+      declared.has(alias) ||
+      [
+        'void',
+        'bool',
+        '_Bool',
+        'char',
+        'short',
+        'int',
+        'long',
+        'float',
+        'double',
+      ].includes(alias)
+    )
+      continue
+    const output = dump(alias)
+    // filtered clang output is a stream of JSON declaration objects.
+    for (const object of output.split(/\n(?=\{\n)/).filter((text) => text.trim())) {
+      const declaration: unknown = JSON.parse(object)
+      if (
+        declaration &&
+        typeof declaration === 'object' &&
+        Reflect.get(declaration, 'kind') === 'TypedefDecl' &&
+        Reflect.get(declaration, 'name') === alias
+      )
+        inner.push(declaration)
+    }
+  }
+  return ast
+}
+
 // the header values of the graphs' objective-c enum cases and option members
 // (c:@E@Enum@Constant, c:@EA@Enum@Constant), from clang's AST of the same
 // headers: an enumerator's value is its initializer's, or one past the one

package/src/swift-package.ts

@@ -174,6 +174,7 @@ export const SWIFT_NATIVE_SOURCE_EXTENSIONS = [
   '.hh',
   '.hpp',
   '.hxx',
+  '.pch',
   '.inc',
   '.inl',
   '.modulemap',
@@ -325,6 +326,99 @@ export function swiftResourceBundles(
   }))
 }
 
+/** the generated accessor files of a native Objective-C resource target,
+ *  written beside its sources: the header is forced into each unit of the
+ *  target and the body is one more unit of it. */
+export const OBJC_RESOURCE_ACCESSOR_HEADER = 'resource_bundle_accessor.h'
+export const OBJC_RESOURCE_ACCESSOR_BODY = 'resource_bundle_accessor.m'
+
+/** the bundle name SwiftPM derives symbols from, for a native Objective-C
+ *  target. a resource target needs the assignment of its own source path, a
+ *  target without resources cannot use the macro, and either mismatch is
+ *  refused here because clang accepts another target's header. */
+export function swiftObjCResourceBundleName(args: {
+  target: string
+  path: string
+  resources: boolean
+  usesBundleMacro: boolean
+  bundles: readonly SwiftResourceBundle[] | undefined
+}): string | undefined {
+  const { target, resources, usesBundleMacro } = args
+  if (!resources) {
+    if (usesBundleMacro)
+      throw new Error(
+        `objective-c target ${target} uses SWIFTPM_MODULE_BUNDLE but declares no resources`,
+      )
+    return undefined
+  }
+  const bundle = args.bundles?.find((candidate) => candidate.target === target)
+  if (
+    !bundle ||
+    bundle.sourcePath !== args.path ||
+    !bundle.path.endsWith(`_${target}.bundle`)
+  )
+    throw new Error(`swift resource target ${target} has no matching bundle assignment`)
+  return bundle.path.slice(0, -'.bundle'.length)
+}
+
+/** SwiftPM's Objective-C resource accessor for one bundle name. */
+export function swiftObjCResourceAccessor(bundleName: string): {
+  header: string
+  body: string
+} {
+  if (!/^[A-Za-z_]\w*$/.test(bundleName))
+    throw new Error(`Objective-C resource bundle symbol is unqualified: ${bundleName}`)
+  const symbol = `${bundleName}_SWIFTPM_MODULE_BUNDLE`
+  const finder = `${bundleName}_SWIFTPM_MODULE_BUNDLER_FINDER`
+  return {
+    header: [
+      '#import <Foundation/Foundation.h>',
+      '',
+      '__BEGIN_DECLS',
+      '',
+      `NSBundle* ${symbol}(void);`,
+      '',
+      `#define SWIFTPM_MODULE_BUNDLE ${symbol}()`,
+      '',
+      '__END_DECLS',
+    ].join('\n'),
+    body: [
+      '#import <Foundation/Foundation.h>',
+      '',
+      'NS_ASSUME_NONNULL_BEGIN',
+      '',
+      `@interface ${finder} : NSObject`,
+      '@end',
+      '',
+      `@implementation ${finder}`,
+      '@end',
+      '',
+      `NSBundle* ${symbol}() {`,
+      `    NSString *bundleName = @"${bundleName}";`,
+      '',
+      '    NSArray<NSURL*> *candidates = @[',
+      '        NSBundle.mainBundle.resourceURL,',
+      `        [NSBundle bundleForClass:[${finder} class]].resourceURL,`,
+      '        NSBundle.mainBundle.bundleURL',
+      '    ];',
+      '',
+      '    for (NSURL* candidate in candidates) {',
+      '        NSURL *bundlePath = [candidate URLByAppendingPathComponent:[NSString stringWithFormat:@"%@.bundle", bundleName]];',
+      '',
+      '        NSBundle *bundle = [NSBundle bundleWithURL:bundlePath];',
+      '        if (bundle != nil) {',
+      '            return bundle;',
+      '        }',
+      '    }',
+      '',
+      '    @throw [[NSException alloc] initWithName:@"SwiftPMResourcesAccessor" reason:[NSString stringWithFormat:@"unable to find bundle named %@", bundleName] userInfo:nil];',
+      '}',
+      '',
+      'NS_ASSUME_NONNULL_END',
+    ].join('\n'),
+  }
+}
+
 /** the one resource target owning a canonical compile-input file. */
 export function swiftResourceBundleForFile(
   bundles: readonly SwiftResourceBundle[],

package/src/swift-packages.ts

@@ -3,8 +3,8 @@
 // (swift-package-manifest.ts) to the source targets that build it; remote
 // packages are fetched at the revision the app's Package.resolved pins, into
 // PEACH_HOME/cache/swift-packages, isolated by the app root. swift and c-family source
-// targets use the common compiler backend. objective-c, assembly and binary
-// targets the host built no stand-in for stay missing with their reason;
+// targets, including objective-c, use the common compiler backend. assembly
+// and binary targets the host built no stand-in for stay missing with their reason;
 // the targets beside them still compile.
 
 import { execFileSync } from 'node:child_process'
@@ -93,8 +93,8 @@ export function remoteSwiftCheckouts(root: string): string {
   return path.join(fs.realpathSync(cacheDir()), 'swift-packages', key, 'checkouts')
 }
 
-// sources requiring an objective-c runtime or assembly lowering.
-const UNSUPPORTED_NATIVE = /\.(m|mm|s|S)$/
+// assembly requires its own target lowering; objective-c keeps its original bodies.
+const UNSUPPORTED_NATIVE = /\.(s|S)$/
 
 const BINARY = 'is a binary framework'
 // retain every independent blocker in dependency order. a product can reach
@@ -264,7 +264,7 @@ export function resolveSwiftPackages(options: {
           : target.type !== 'regular' && target.type !== 'system'
             ? `${name} is a ${target.type} target`
             : files.some((file) => UNSUPPORTED_NATIVE.test(file))
-              ? `${name} is an Objective-C or assembly target${gap ? `; ${gap}` : ''}`
+              ? `${name} is an assembly target${gap ? `; ${gap}` : ''}`
               : null
       // every dependency resolves, so a failing one never hides the rest
       // of the closure from the compile or from the report