peachsim 0.1.1640 → 0.1.1641

package/src/swift-objc-metadata.ts

@@ -0,0 +1,204 @@
+import { spawnSync } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import fs from 'node:fs'
+import path from 'node:path'
+import { IOS_SDK_HEADERS } from './swift-objc-sdk'
+import { IOS_SDK_ID, materializeObjcSdk } from './swift-objc-standin'
+import { swiftEnvironment } from './swift-toolchain'
+import type { SwiftObjCPeerClass } from './swiftContract'
+
+export class ObjcPeerMetadataError extends Error {
+  constructor(
+    message: string,
+    readonly files: string[],
+    readonly reusable: boolean,
+  ) {
+    super(message)
+  }
+}
+
+export function validateObjcPeerClasses(
+  classes: readonly SwiftObjCPeerClass[],
+): Set<string> {
+  const names = new Set<string>()
+  for (const peer of classes) {
+    if (!/^[A-Za-z_]\w*$/.test(peer.name) || names.has(peer.name))
+      throw new Error(`invalid or duplicate Objective-C metadata class: ${peer.name}`)
+    names.add(peer.name)
+    const header = /^(\w+)\/([\w./-]+\.h)$/.exec(peer.header)
+    if (
+      !header ||
+      header[2]!.split('/').some((part) => part === '..' || part === '.') ||
+      !Object.hasOwn(
+        IOS_SDK_HEADERS,
+        `System/Library/Frameworks/${header[1]}.framework/Headers/${header[2]}`,
+      )
+    )
+      throw new Error(`Objective-C peer header is outside the shared SDK: ${peer.header}`)
+  }
+  if (names.size === 0) throw new Error('Objective-C metadata requires peer classes')
+  return names
+}
+
+/** emits class metadata and its startup registration; adapters own every method. */
+export function compileObjcPeerMetadata(args: {
+  classes: readonly SwiftObjCPeerClass[]
+  work: string
+  headerCache: string
+  toolchainBin: string
+  sysroot: string
+  minimum: number
+  descriptor?: number
+}): { object: string; registration: string; files: string[] } {
+  const names = validateObjcPeerClasses(args.classes)
+  const headers = materializeObjcSdk(args.headerCache)
+  const source = path.join(args.work, 'peer-metadata.m')
+  const object = path.join(args.work, 'peer-metadata.o')
+  const log = path.join(args.work, 'peer-metadata.log')
+  const receipt = path.join(args.work, 'peer-metadata.json')
+  const registration = path.join(args.work, 'peer-registration.swift')
+  fs.writeFileSync(
+    registration,
+    [
+      'import PeachObjC',
+      ...[...new Set(args.classes.map((peer) => peer.header.split('/')[0]!))].map(
+        (module) => `import ${module}`,
+      ),
+      '@_cdecl("_peach_objc_register_peers")',
+      'public func _peachRegisterObjcPeers() {',
+      ...[...args.classes]
+        .sort(
+          (left, right) =>
+            Number(right.name === 'NSObject') - Number(left.name === 'NSObject'),
+        )
+        .map(
+          (peer) =>
+            `  _objcRegisterPeerClass(\`${peer.name}\`.self, nativeName: "${peer.name}")`,
+        ),
+      '}',
+      '',
+    ].join('\n'),
+  )
+  fs.writeFileSync(
+    source,
+    [
+      ...[...new Set(args.classes.map((peer) => peer.header))].map(
+        (header) => `#import <${header}>`,
+      ),
+      ...args.classes.map((peer) => `@implementation ${peer.name}\n@end`),
+      'extern void _peach_objc_register_peers(void);',
+      '__attribute__((constructor)) static void peach_register_objc_peers(void) {',
+      '  _peach_objc_register_peers();',
+      '}',
+      '',
+    ].join('\n'),
+  )
+  const command = [
+    '--target=wasm32-unknown-wasip1',
+    `--sysroot=${args.sysroot}`,
+    '-fwasm-exceptions',
+    '-fexceptions',
+    '-D_WASI_EMULATED_SIGNAL',
+    '-D_WASI_EMULATED_MMAN',
+    `-D__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__=${args.minimum}`,
+    `-D__IPHONE_OS_VERSION_MIN_REQUIRED=${args.minimum}`,
+    '-fobjc-runtime=gnustep-2.2',
+    '-fobjc-exceptions',
+    '-fobjc-arc',
+    '-fblocks',
+    // empty implementations must not synthesize framework getters or storage.
+    '-Xclang',
+    '-disable-objc-default-synthesize-properties',
+    '-Werror=objc-root-class',
+    '-F',
+    path.join(headers, 'System/Library/Frameworks'),
+    '-idirafter',
+    path.join(headers, 'usr/include'),
+    '-Os',
+    '-c',
+    source,
+    '-o',
+    object,
+  ]
+  const compiler = path.join(args.toolchainBin, 'clang')
+  const result = spawnSync(compiler, command, {
+    cwd: args.work,
+    env: swiftEnvironment(),
+    encoding: 'utf8',
+    stdio: [
+      'ignore',
+      'pipe',
+      'pipe',
+      ...(args.descriptor === undefined ? [] : [args.descriptor]),
+    ],
+    timeout: 120_000,
+    maxBuffer: 16 * 1024 * 1024,
+  })
+  fs.writeFileSync(
+    log,
+    `${result.stdout ?? ''}${result.stderr ?? ''}${result.error?.message ?? ''}`,
+  )
+  const digest = (file: string) =>
+    createHash('sha256').update(fs.readFileSync(file)).digest('hex')
+  fs.writeFileSync(
+    receipt,
+    JSON.stringify(
+      {
+        classes: args.classes,
+        declarations: IOS_SDK_ID,
+        compiler: digest(compiler),
+        command,
+        source: digest(source),
+        status: result.status,
+        signal: result.signal,
+        error: result.error?.message,
+        ...(result.status === 0 && !result.error ? { object: digest(object) } : {}),
+      },
+      null,
+      2,
+    ),
+  )
+  const files = [source, registration, log, receipt]
+  if (result.error || result.status !== 0)
+    throw new ObjcPeerMetadataError(
+      `Objective-C peer metadata compilation failed: ${log}`,
+      files,
+      !result.error && !result.signal && result.status !== null,
+    )
+  files.push(object)
+  const symbols = spawnSync(
+    path.join(args.toolchainBin, 'llvm-nm'),
+    ['--format=posix', object],
+    {
+      encoding: 'utf8',
+      env: swiftEnvironment(),
+      timeout: 120_000,
+      maxBuffer: 16 * 1024 * 1024,
+    },
+  )
+  fs.appendFileSync(
+    log,
+    `${symbols.stdout ?? ''}${symbols.stderr ?? ''}${symbols.error?.message ?? ''}`,
+  )
+  if (symbols.error || symbols.status !== 0)
+    throw new ObjcPeerMetadataError(
+      `could not inspect Objective-C peer metadata: ${log}`,
+      files,
+      !symbols.error && !symbols.signal && symbols.status !== null,
+    )
+  const emitted = [...symbols.stdout.matchAll(/^\._OBJC_CLASS_(\w+) [^U] /gm)].map(
+    (match) => match[1]!,
+  )
+  if (
+    emitted.length !== names.size ||
+    !emitted.every((name) => names.has(name)) ||
+    /^\._OBJC_CLASS_\w+ U(?: |$)/m.test(symbols.stdout) ||
+    /^_[ic]_\w+/m.test(symbols.stdout)
+  )
+    throw new ObjcPeerMetadataError(
+      `Objective-C peer metadata contains unexpected classes or methods: ${receipt}`,
+      files,
+      true,
+    )
+  return { object, registration, files }
+}

package/src/swift-objc-sdk.ts

@@ -24,6 +24,7 @@ int removexattr(const char *path, const char *name, int options);
 `,
   'usr/include/MacTypes.h': `#pragma once
 enum { noErr = 0 };
+enum { kNilOptions = 0 };
 `,
   // darwin pointer and mach port identities used in public native headers.
   'usr/include/pthread.h': `#pragma once
@@ -273,6 +274,7 @@ __attribute__((objc_root_class))
 + (void)initialize;
 - (instancetype)init __attribute__((objc_designated_initializer));
 + (instancetype)new __attribute__((availability(swift, unavailable, message="use object initializers instead")));
++ (instancetype)allocWithZone:(struct _NSZone *)zone __attribute__((availability(swift, unavailable, message="use object initializers instead")));
 + (instancetype)alloc __attribute__((availability(swift, unavailable, message="use object initializers instead")));
 + (Class)class __attribute__((availability(swift, unavailable, message="use 'aClass.self' instead")));
 - (id)copy;
@@ -355,6 +357,127 @@ OSStatus SecItemDelete(CFDictionaryRef query) __attribute__((availability(macos,
 #ifdef __cplusplus
 }
 #endif
+`,
+  'System/Library/Frameworks/CoreData.framework/Headers/CoreData.h': `#pragma once
+#import <CoreData/NSManagedObjectModel.h>
+#import <CoreData/NSPersistentStoreCoordinator.h>
+#import <CoreData/NSManagedObjectContext.h>
+#import <CoreData/NSFetchedResultsController.h>
+`,
+  'System/Library/Frameworks/CoreData.framework/Headers/NSManagedObjectModel.h': `#pragma once
+#import <Foundation/Foundation.h>
+__attribute__((availability(ios,introduced=3.0)))
+@interface NSManagedObjectModel : NSObject <NSCoding, NSCopying, NSFastEnumeration>
+@end
+`,
+  'System/Library/Frameworks/CoreData.framework/Headers/NSPersistentStoreCoordinator.h': `#pragma once
+#import <Foundation/Foundation.h>
+__attribute__((availability(ios,introduced=3.0))) NS_SWIFT_SENDABLE
+@interface NSPersistentStoreCoordinator : NSObject <NSLocking>
+@end
+`,
+  'System/Library/Frameworks/CoreData.framework/Headers/NSManagedObjectID.h': `#pragma once
+#import <Foundation/Foundation.h>
+NS_ASSUME_NONNULL_BEGIN
+__attribute__((availability(ios,introduced=3.0))) NS_SWIFT_SENDABLE
+@interface NSManagedObjectID : NSObject <NSCopying>
+@end
+NS_ASSUME_NONNULL_END
+`,
+  'System/Library/Frameworks/CoreData.framework/Headers/NSManagedObject.h': `#pragma once
+#import <Foundation/Foundation.h>
+#import <CoreData/NSManagedObjectID.h>
+NS_ASSUME_NONNULL_BEGIN
+__attribute__((availability(ios,introduced=3.0))) NS_SWIFT_NONISOLATED NS_SWIFT_NONSENDABLE __attribute__((objc_requires_property_definitions))
+@interface NSManagedObject : NSObject
+@property (nonatomic, readonly, strong) NSManagedObjectID *objectID;
+@property (nonatomic, getter=isFault, readonly) BOOL fault;
+@end
+NS_ASSUME_NONNULL_END
+`,
+  'System/Library/Frameworks/CoreData.framework/Headers/NSManagedObjectContext.h': `#pragma once
+#import <Foundation/Foundation.h>
+#import <CoreData/NSManagedObject.h>
+NS_ASSUME_NONNULL_BEGIN
+__attribute__((availability(ios,introduced=3.0))) NS_SWIFT_NONISOLATED NS_SWIFT_SENDABLE
+@interface NSManagedObjectContext : NSObject <NSCoding, NSLocking>
+- (nullable __kindof NSManagedObject *)existingObjectWithID:(NSManagedObjectID *)objectID error:(NSError **)error __attribute__((availability(ios,introduced=3.0)));
+@end
+NS_ASSUME_NONNULL_END
+`,
+  'System/Library/Frameworks/CoreData.framework/Headers/NSPersistentStoreRequest.h': `#pragma once
+#import <Foundation/Foundation.h>
+__attribute__((availability(ios,introduced=5.0)))
+@interface NSPersistentStoreRequest : NSObject <NSCopying>
+@end
+`,
+  'System/Library/Frameworks/CoreData.framework/Headers/NSFetchRequest.h': `#pragma once
+#import <Foundation/Foundation.h>
+#import <CoreData/NSPersistentStoreRequest.h>
+#import <CoreData/NSManagedObject.h>
+#import <CoreData/NSManagedObjectID.h>
+NS_ASSUME_NONNULL_BEGIN
+@protocol NSFetchRequestResult <NSObject>
+@end
+@interface NSNumber (NSFetchedResultSupport) <NSFetchRequestResult>
+@end
+@interface NSDictionary (NSFetchedResultSupport) <NSFetchRequestResult>
+@end
+@interface NSManagedObject (NSFetchedResultSupport) <NSFetchRequestResult>
+@end
+@interface NSManagedObjectID (NSFetchedResultSupport) <NSFetchRequestResult>
+@end
+__attribute__((availability(ios,introduced=3.0)))
+@interface NSFetchRequest<__covariant ResultType:id<NSFetchRequestResult>> : NSPersistentStoreRequest <NSCoding, NSCopying>
+@property (nullable, nonatomic, readonly, strong) NSString *entityName __attribute__((availability(ios,introduced=4.0)));
+@end
+NS_ASSUME_NONNULL_END
+`,
+  'System/Library/Frameworks/CoreData.framework/Headers/NSFetchedResultsController.h': `#pragma once
+#import <Foundation/Foundation.h>
+#import <CoreData/NSManagedObjectContext.h>
+#import <CoreData/NSFetchRequest.h>
+NS_ASSUME_NONNULL_BEGIN
+@protocol NSFetchedResultsControllerDelegate;
+@protocol NSFetchedResultsSectionInfo;
+__attribute__((availability(ios,introduced=3.0)))
+@interface NSFetchedResultsController<ResultType:id<NSFetchRequestResult>> : NSObject
+- (instancetype)initWithFetchRequest:(NSFetchRequest<ResultType> *)fetchRequest managedObjectContext:(NSManagedObjectContext *)context sectionNameKeyPath:(nullable NSString *)sectionNameKeyPath cacheName:(nullable NSString *)name;
+- (BOOL)performFetch:(NSError **)error;
+@property (nonatomic, readonly) NSFetchRequest<ResultType> *fetchRequest;
+@property (nonatomic, readonly) NSManagedObjectContext *managedObjectContext;
+@property (nullable, nonatomic, assign) id<NSFetchedResultsControllerDelegate> delegate;
+@property (nullable, nonatomic, readonly) NSArray<ResultType> *fetchedObjects;
+- (ResultType)objectAtIndexPath:(NSIndexPath *)indexPath;
+- (nullable NSIndexPath *)indexPathForObject:(ResultType)object;
+@property (nullable, nonatomic, readonly) NSArray<id<NSFetchedResultsSectionInfo>> *sections;
+@end
+@protocol NSFetchedResultsSectionInfo
+@property (nonatomic, readonly) NSString *name;
+@property (nullable, nonatomic, readonly) NSString *indexTitle;
+@property (nonatomic, readonly) NSUInteger numberOfObjects;
+@property (nullable, nonatomic, readonly) NSArray *objects;
+@end
+typedef NS_ENUM(NSUInteger, NSFetchedResultsChangeType) {
+    NSFetchedResultsChangeInsert = 1,
+    NSFetchedResultsChangeDelete = 2,
+    NSFetchedResultsChangeMove = 3,
+    NSFetchedResultsChangeUpdate = 4
+} __attribute__((availability(ios,introduced=3.0)));
+@protocol NSFetchedResultsControllerDelegate <NSObject>
+@optional
+- (void)controller:(NSFetchedResultsController *)controller didChangeObject:(id)anObject atIndexPath:(nullable NSIndexPath *)indexPath forChangeType:(NSFetchedResultsChangeType)type newIndexPath:(nullable NSIndexPath *)newIndexPath;
+- (void)controller:(NSFetchedResultsController *)controller didChangeSection:(id<NSFetchedResultsSectionInfo>)sectionInfo atIndex:(NSUInteger)sectionIndex forChangeType:(NSFetchedResultsChangeType)type;
+- (void)controllerWillChangeContent:(NSFetchedResultsController *)controller;
+- (void)controllerDidChangeContent:(NSFetchedResultsController *)controller;
+@end
+NS_ASSUME_NONNULL_END
+`,
+  'System/Library/Frameworks/CoreData.framework/Modules/module.modulemap': `framework module CoreData [system] {
+  umbrella header "CoreData.h"
+  export *
+  module * { export * }
+}
 `,
   'System/Library/Frameworks/Security.framework/Modules/module.modulemap': `framework module Security {
   umbrella header "Security.h"
@@ -603,7 +726,7 @@ typedef struct __attribute__((objc_bridge(id))) CGColorSpace *CGColorSpaceRef;
 #import <CoreGraphics/CoreGraphics.h>
 
 @class NSException;
-typedef void NSUncaughtExceptionHandler(NSException *exception);
+typedef void NSUncaughtExceptionHandler(NSException * _Nonnull exception);
 #define FOUNDATION_EXPORT extern
 #define FOUNDATION_EXTERN extern
 #define FOUNDATION_STATIC_INLINE static inline
@@ -978,6 +1101,9 @@ __attribute__((swift_bridge("DateInterval")))
 __attribute__((swift_bridge("URL")))
 @interface NSURL : NSObject <NSCopying, NSSecureCoding>
 @property (nullable, readonly, copy) NSString *path;
+@property (nullable, readonly, copy) NSString *scheme;
+@property (nullable, readonly, copy) NSString *host;
++ (nullable instancetype)URLWithString:(NSString * _Nonnull)URLString;
 + (NSURL *)fileURLWithPath:(NSString *)path;
 @end
 __attribute__((swift_bridge("URLComponents")))
@@ -988,6 +1114,7 @@ __attribute__((swift_bridge("URLQueryItem")))
 @end
 __attribute__((swift_bridge("URLRequest")))
 @interface NSURLRequest : NSObject <NSCopying, NSMutableCopying, NSSecureCoding>
++ (instancetype _Nonnull)requestWithURL:(NSURL * _Nonnull)URL;
 @end
 @interface NSMutableURLRequest : NSURLRequest
 @end
@@ -1006,16 +1133,26 @@ NS_SWIFT_NAME(URLSessionTaskDelegate)
 NS_SWIFT_NAME(URLSessionDataDelegate)
 @protocol NSURLSessionDataDelegate <NSURLSessionTaskDelegate>
 @end
+@class NSURLSessionDataTask;
 NS_SWIFT_NAME(URLSession)
+NS_SWIFT_SENDABLE
+__attribute__((availability(ios,introduced=7.0)))
 @interface NSURLSession : NSObject
+@property (class, readonly, strong) NSURLSession * _Nonnull sharedSession;
+- (NSURLSessionDataTask * _Nonnull)dataTaskWithRequest:(NSURLRequest * _Nonnull)request completionHandler:(void (NS_SWIFT_SENDABLE ^ _Nonnull)(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error))completionHandler;
 @end
 NS_SWIFT_NAME(URLSessionTask)
+NS_SWIFT_SENDABLE
+__attribute__((availability(ios,introduced=7.0)))
 @interface NSURLSessionTask : NSObject <NSCopying>
+- (void)resume;
 @end
 NS_SWIFT_NAME(URLSessionTaskMetrics)
 @interface NSURLSessionTaskMetrics : NSObject
 @end
 NS_SWIFT_NAME(URLSessionDataTask)
+NS_SWIFT_SENDABLE
+__attribute__((availability(ios,introduced=7.0)))
 @interface NSURLSessionDataTask : NSURLSessionTask
 @end
 NS_SWIFT_NAME(URLSessionConfiguration)
@@ -1158,8 +1295,18 @@ NS_SWIFT_NAME(DateFormatter)
 NS_SWIFT_NAME(NumberFormatter)
 @interface NSNumberFormatter : NSObject
 @end
+typedef NS_OPTIONS(NSUInteger, NSJSONReadingOptions) {
+    NSJSONReadingMutableContainers = (1UL << 0),
+    NSJSONReadingMutableLeaves = (1UL << 1),
+    NSJSONReadingFragmentsAllowed = (1UL << 2),
+    NSJSONReadingJSON5Allowed __attribute__((availability(ios,introduced=15.0))) = (1UL << 3),
+    NSJSONReadingTopLevelDictionaryAssumed __attribute__((availability(ios,introduced=15.0))) = (1UL << 4),
+    NSJSONReadingAllowFragments __attribute__((availability(ios,introduced=5.0,deprecated=100000,replacement="NSJSONReadingFragmentsAllowed"))) = NSJSONReadingFragmentsAllowed
+} __attribute__((availability(ios,introduced=5.0)));
 NS_SWIFT_NAME(JSONSerialization)
+__attribute__((availability(ios,introduced=5.0)))
 @interface NSJSONSerialization : NSObject
++ (nullable id)JSONObjectWithData:(NSData * _Nonnull)data options:(NSJSONReadingOptions)opt error:(NSError * _Nullable * _Nullable)error;
 @end
 @interface NSPredicate : NSObject <NSSecureCoding, NSCopying>
 @end
@@ -1279,12 +1426,14 @@ typedef NS_ENUM(NSInteger, UIImageOrientation) { UIImageOrientationUp, UIImageOr
 typedef NS_ENUM(NSInteger, UIViewContentMode) { UIViewContentModeScaleToFill, UIViewContentModeScaleAspectFit, UIViewContentModeScaleAspectFill } NS_SWIFT_NAME(UIView.ContentMode);
 typedef NS_OPTIONS(NSUInteger, UIControlState) { UIControlStateNormal = 0, UIControlStateHighlighted = 1 << 0, UIControlStateDisabled = 1 << 1, UIControlStateSelected = 1 << 2 } NS_SWIFT_NAME(UIControl.State);
 typedef NS_OPTIONS(NSUInteger, UIControlEvents) { UIControlEventTouchDown = 1 << 0, UIControlEventTouchUpInside = 1 << 6, UIControlEventValueChanged = 1 << 12, UIControlEventPrimaryActionTriggered = 1 << 13 } NS_SWIFT_NAME(UIControl.Event);
+typedef NS_ENUM(NSInteger, UITableViewCellEditingStyle) { UITableViewCellEditingStyleNone, UITableViewCellEditingStyleDelete, UITableViewCellEditingStyleInsert } __attribute__((availability(watchos,unavailable)));
+typedef NS_ENUM(NSInteger, UITableViewRowAnimation) { UITableViewRowAnimationFade, UITableViewRowAnimationRight, UITableViewRowAnimationLeft, UITableViewRowAnimationTop, UITableViewRowAnimationBottom, UITableViewRowAnimationNone, UITableViewRowAnimationMiddle, UITableViewRowAnimationAutomatic = 100 };
 typedef NS_ENUM(NSInteger, UIStatusBarStyle) { UIStatusBarStyleDefault = 0, UIStatusBarStyleLightContent = 1, UIStatusBarStyleDarkContent = 3 };
 typedef NS_OPTIONS(NSUInteger, UIInterfaceOrientationMask) { UIInterfaceOrientationMaskPortrait = 1 << 1, UIInterfaceOrientationMaskLandscapeLeft = 1 << 4, UIInterfaceOrientationMaskLandscapeRight = 1 << 3, UIInterfaceOrientationMaskAll = 30 };
 typedef NS_ENUM(NSInteger, UIInterfaceOrientation) { UIInterfaceOrientationUnknown = 0, UIInterfaceOrientationPortrait = 1, UIInterfaceOrientationPortraitUpsideDown = 2, UIInterfaceOrientationLandscapeLeft = 4, UIInterfaceOrientationLandscapeRight = 3 };
 typedef NS_ENUM(NSInteger, UIModalPresentationStyle) { UIModalPresentationFullScreen = 0, UIModalPresentationPageSheet = 1, UIModalPresentationFormSheet = 2, UIModalPresentationOverFullScreen = 5, UIModalPresentationAutomatic = -2 };
 typedef NS_ENUM(NSInteger, UIUserInterfaceStyle) { UIUserInterfaceStyleUnspecified, UIUserInterfaceStyleLight, UIUserInterfaceStyleDark };
-@class UIView, UIViewController, UIWindow, UIColor, UIImage, UIFont, UIEvent, UITouch, UIPress, UIScreen, UIWindowScene, UIGestureRecognizer;
+@class UIView, UIViewController, UIWindow, UIColor, UIImage, UIFont, UIEvent, UITouch, UIPress, UIScreen, UIWindowScene, UIGestureRecognizer, UITableViewCell;
 @interface UIGraphicsRendererFormat : NSObject <NSCopying>
 @end
 @interface UIGraphicsImageRendererFormat : UIGraphicsRendererFormat
@@ -1343,6 +1492,50 @@ NS_SWIFT_UI_ACTOR @interface UIScrollView : UIView
 @end
 NS_SWIFT_UI_ACTOR @interface UITableView : UIScrollView
 @end
+@class UISwipeActionsConfiguration, UIContextMenuConfiguration;
+__attribute__((availability(watchos,unavailable))) NS_SWIFT_UI_ACTOR
+@protocol UIScrollViewDelegate <NSObject>
+@optional
+- (void)scrollViewDidScroll:(UIScrollView *)scrollView;
+- (void)scrollViewWillBeginDragging:(UIScrollView *)scrollView;
+- (void)scrollViewWillEndDragging:(UIScrollView *)scrollView withVelocity:(CGPoint)velocity targetContentOffset:(inout CGPoint *)targetContentOffset __attribute__((availability(ios,introduced=5.0)));
+- (void)scrollViewDidEndDragging:(UIScrollView *)scrollView willDecelerate:(BOOL)decelerate;
+- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView;
+@end
+__attribute__((availability(watchos,unavailable))) NS_SWIFT_UI_ACTOR
+@protocol UITableViewDelegate <NSObject, UIScrollViewDelegate>
+@optional
+- (void)tableView:(UITableView *)tableView willDisplayCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath *)indexPath;
+- (void)tableView:(UITableView *)tableView willDisplayHeaderView:(UIView *)view forSection:(NSInteger)section __attribute__((availability(ios,introduced=6.0)));
+- (void)tableView:(UITableView *)tableView willDisplayFooterView:(UIView *)view forSection:(NSInteger)section __attribute__((availability(ios,introduced=6.0)));
+- (void)tableView:(UITableView *)tableView didEndDisplayingCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath *)indexPath __attribute__((availability(ios,introduced=6.0)));
+- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath;
+- (CGFloat)tableView:(UITableView *)tableView heightForHeaderInSection:(NSInteger)section;
+- (CGFloat)tableView:(UITableView *)tableView heightForFooterInSection:(NSInteger)section;
+- (CGFloat)tableView:(UITableView *)tableView estimatedHeightForRowAtIndexPath:(NSIndexPath *)indexPath __attribute__((availability(ios,introduced=7.0)));
+- (nullable UIView *)tableView:(UITableView *)tableView viewForHeaderInSection:(NSInteger)section;
+- (nullable UIView *)tableView:(UITableView *)tableView viewForFooterInSection:(NSInteger)section;
+- (BOOL)tableView:(UITableView *)tableView shouldHighlightRowAtIndexPath:(NSIndexPath *)indexPath __attribute__((availability(ios,introduced=6.0)));
+- (nullable NSIndexPath *)tableView:(UITableView *)tableView willSelectRowAtIndexPath:(NSIndexPath *)indexPath;
+- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath;
+- (UITableViewCellEditingStyle)tableView:(UITableView *)tableView editingStyleForRowAtIndexPath:(NSIndexPath *)indexPath;
+- (nullable NSString *)tableView:(UITableView *)tableView titleForDeleteConfirmationButtonForRowAtIndexPath:(NSIndexPath *)indexPath __attribute__((availability(ios,introduced=3.0), availability(tvos,unavailable)));
+- (nullable UISwipeActionsConfiguration *)tableView:(UITableView *)tableView leadingSwipeActionsConfigurationForRowAtIndexPath:(NSIndexPath *)indexPath __attribute__((availability(ios,introduced=11.0), availability(watchos,unavailable), availability(tvos,unavailable)));
+- (nullable UISwipeActionsConfiguration *)tableView:(UITableView *)tableView trailingSwipeActionsConfigurationForRowAtIndexPath:(NSIndexPath *)indexPath __attribute__((availability(ios,introduced=11.0), availability(watchos,unavailable), availability(tvos,unavailable)));
+- (nullable UIContextMenuConfiguration *)tableView:(UITableView *)tableView contextMenuConfigurationForRowAtIndexPath:(NSIndexPath *)indexPath point:(CGPoint)point __attribute__((availability(ios,introduced=13.0), availability(tvos,introduced=17.0), availability(watchos,unavailable)));
+@end
+__attribute__((availability(watchos,unavailable))) NS_SWIFT_UI_ACTOR
+@protocol UITableViewDataSource <NSObject>
+@required
+- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section;
+- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath;
+@optional
+- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView;
+- (nullable NSString *)tableView:(UITableView *)tableView titleForHeaderInSection:(NSInteger)section;
+- (nullable NSString *)tableView:(UITableView *)tableView titleForFooterInSection:(NSInteger)section;
+- (BOOL)tableView:(UITableView *)tableView canEditRowAtIndexPath:(NSIndexPath *)indexPath;
+- (void)tableView:(UITableView *)tableView commitEditingStyle:(UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath;
+@end
 NS_SWIFT_UI_ACTOR @protocol UIGestureRecognizerDelegate <NSObject>
 @optional
 - (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)gestureRecognizer;

package/src/swift-package-manifest.ts

@@ -277,14 +277,17 @@ export function swiftPackageManifest(dir: string): SwiftPackageManifest {
         const header = string(record(settingKind.headerSearchPath)._0)
         const definition = string(record(settingKind.define)._0)
         const value = string(record(settingKind.define)._1)
+        const disabledWarning = string(record(settingKind.disableWarning)._0)
         const unsafe = record(settingKind.unsafeFlags)._0
         const flags = header
           ? ['-I', path.resolve(targetDir, header)]
           : definition
             ? [`-D${definition}${value === undefined ? '' : `=${value}`}`]
-            : Array.isArray(unsafe)
-              ? unsafe.flatMap((flag) => string(flag) ?? [])
-              : null
+            : disabledWarning !== undefined
+              ? [`-Wno-${disabledWarning}`]
+              : Array.isArray(unsafe)
+                ? unsafe.flatMap((flag) => string(flag) ?? [])
+                : null
         if (!flags)
           throw new Error(
             `${name}: unsupported ${tool} compiler setting ${JSON.stringify(rawKind)}`,

package/src/swift-root-lock.ts

@@ -0,0 +1,153 @@
+import { execFileSync } from 'node:child_process'
+import { createHash, randomUUID } from 'node:crypto'
+import {
+  linkSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
+import path from 'node:path'
+import { rnxHomeDir } from './home-paths'
+
+const POLL_MS = 250
+
+interface Holder {
+  pid: number
+  start: string | null
+}
+
+// a pid alone is reused; the start time names the process that wrote the lock.
+function processStart(pid: number): string | null {
+  try {
+    return (
+      execFileSync('ps', ['-o', 'lstart=', '-p', String(pid)], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+      }).trim() || null
+    )
+  } catch {
+    return null
+  }
+}
+
+function parseHolder(text: string): Holder | null {
+  try {
+    const value: unknown = JSON.parse(text)
+    if (
+      value &&
+      typeof value === 'object' &&
+      'pid' in value &&
+      typeof value.pid === 'number' &&
+      'start' in value &&
+      (typeof value.start === 'string' || value.start === null)
+    )
+      return { pid: value.pid, start: value.start }
+  } catch {}
+  return null
+}
+
+function readLock(lock: string): string | null {
+  try {
+    return readFileSync(lock, 'utf8')
+  } catch (error) {
+    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') return null
+    throw error
+  }
+}
+
+function holderAlive(text: string): boolean {
+  const holder = parseHolder(text)
+  if (!holder) return false
+  const start = processStart(holder.pid)
+  return start !== null && start === holder.start
+}
+
+function pause(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve) => {
+    const done = () => {
+      clearTimeout(timer)
+      signal?.removeEventListener('abort', done)
+      resolve()
+    }
+    const timer = setTimeout(done, ms)
+    signal?.addEventListener('abort', done, { once: true })
+  })
+}
+
+/** runs `work` as the only process using a swift build root. the in-process
+ *  queue orders one process's requests; two processes sharing a root each
+ *  rewrite its sources and manifest, and swiftpm's own build lock only orders
+ *  the builds, so a build can compile the other process's sources and then
+ *  read back that process's executable. the lock lives beside the root's
+ *  tree, never inside it: a write sweeps every file of the tree it does not
+ *  name. a lock whose owner process is gone is taken over. */
+export async function withSwiftRootLock<T>(
+  root: string,
+  work: () => Promise<T>,
+  signal?: AbortSignal,
+): Promise<T> {
+  const directory = path.join(rnxHomeDir(), 'cache', 'swift-root-locks')
+  mkdirSync(directory, { recursive: true })
+  const lock = path.join(
+    directory,
+    `${createHash('sha256').update(root).digest('hex').slice(0, 32)}.lock`,
+  )
+  const token = randomUUID()
+  const owner = JSON.stringify({
+    pid: process.pid,
+    start: processStart(process.pid),
+    token,
+  })
+  const pending = `${lock}.${token}`
+  // the owner record is complete before the lock path exists, so a waiter
+  // never reads a half-written lock.
+  writeFileSync(pending, owner)
+  try {
+    for (;;) {
+      signal?.throwIfAborted()
+      try {
+        linkSync(pending, lock)
+        break
+      } catch (error) {
+        if (!(error instanceof Error && 'code' in error && error.code === 'EEXIST'))
+          throw error
+      }
+      const held = readLock(lock)
+      if (held === null) continue
+      if (holderAlive(held)) {
+        await pause(POLL_MS, signal)
+        continue
+      }
+      // take over by moving the dead record aside. a different record in the
+      // moved file means a new owner landed first; put it back.
+      const dead = `${lock}.dead-${token}`
+      try {
+        renameSync(lock, dead)
+      } catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') continue
+        throw error
+      }
+      try {
+        if (readLock(dead) !== held) {
+          try {
+            linkSync(dead, lock)
+          } catch (error) {
+            if (!(error instanceof Error && 'code' in error && error.code === 'EEXIST'))
+              throw error
+          }
+        }
+      } finally {
+        rmSync(dead, { force: true })
+      }
+    }
+  } finally {
+    rmSync(pending, { force: true })
+  }
+  try {
+    return await work()
+  } finally {
+    if (readLock(lock) === owner) rmSync(lock, { force: true })
+  }
+}