The Swift Package Index logo.Swift Package Index

Build Information

Failed to build MachOKit, reference main (6103fa), with Swift 6.0 for Linux on 19 Apr 2026 07:23:19 UTC.

Build Command

bash -c docker run --pull=always --rm -v "checkouts-4609320-3":/host -w "$PWD" -e JAVA_HOME="/root/.sdkman/candidates/java/current" -e SPI_BUILD="1" -e SPI_PROCESSING="1" registry.gitlab.com/swiftpackageindex/spi-images:basic-6.0-latest swift build --triple x86_64-unknown-linux-gnu 2>&1

Build Log

 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:62: error: expected expression
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                                              `- error: expected expression
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:32: error: expected 'else' after 'guard' condition
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                `- error: expected 'else' after 'guard' condition
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:25: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                         `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:84: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                    `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:86: error: expected expression
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                      `- error: expected expression
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:37: error: expected 'else' after 'guard' condition
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                     `- error: expected 'else' after 'guard' condition
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:30: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                              `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: expected expression
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: expected expression
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:26: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:42: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:44: error: expected expression
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                            `- error: expected expression
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:49:16: error: consecutive statements on a line must be separated by ';'
 47 |         }
 48 |
 49 |         return unsafe String(cString: path)
    |                `- error: consecutive statements on a line must be separated by ';'
 50 |     }
 51 |
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:57:24: error: consecutive statements on a line must be separated by ';'
 55 |     ) -> T? {
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
    |                        `- error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:58:35: error: expected '{' after 'while' condition
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
 58 |         while let handle = unsafe iterator.next() {
    |                                   `- error: expected '{' after 'while' condition
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:39: error: expected 'else' after 'guard' condition
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                       `- error: expected 'else' after 'guard' condition
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:32: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:93: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                             `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:95: error: expected expression
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                               `- error: expected expression
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:63:20: error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
 63 |             return unsafe unsafeBitCast(symbol, to: T.self)
    |                    `- error: consecutive statements on a line must be separated by ';'
 64 |         }
 65 |
[600/733] Compiling MachOKit SymbolProtocol.swift
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:61: error: consecutive declarations on a line must be separated by ';'
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                             `- error: consecutive declarations on a line must be separated by ';'
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:68: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                                    `- error: expected declaration
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:16:16: error: expected ',' separator
 14 |     }
 15 |     nonisolated(unsafe) private static let symbolSearchHandles: [UnsafeMutableRawPointer?] = unsafe [
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
    |                `- error: expected ',' separator
 17 |         fallbackHandle,
 18 |     ]
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:18:5: error: unexpected ',' separator
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
 17 |         fallbackHandle,
 18 |     ]
    |     `- error: unexpected ',' separator
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:51: error: consecutive declarations on a line must be separated by ';'
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                   `- error: consecutive declarations on a line must be separated by ';'
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:58: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                          `- error: expected declaration
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:54: error: consecutive declarations on a line must be separated by ';'
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                      `- error: consecutive declarations on a line must be separated by ';'
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:61: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                             `- error: expected declaration
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: expected 'else' after 'guard' condition
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: expected 'else' after 'guard' condition
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:30: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                              `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:62: error: expected expression
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                                              `- error: expected expression
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:32: error: expected 'else' after 'guard' condition
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                `- error: expected 'else' after 'guard' condition
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:25: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                         `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:84: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                    `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:86: error: expected expression
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                      `- error: expected expression
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:37: error: expected 'else' after 'guard' condition
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                     `- error: expected 'else' after 'guard' condition
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:30: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                              `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: expected expression
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: expected expression
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:26: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:42: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:44: error: expected expression
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                            `- error: expected expression
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:49:16: error: consecutive statements on a line must be separated by ';'
 47 |         }
 48 |
 49 |         return unsafe String(cString: path)
    |                `- error: consecutive statements on a line must be separated by ';'
 50 |     }
 51 |
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:57:24: error: consecutive statements on a line must be separated by ';'
 55 |     ) -> T? {
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
    |                        `- error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:58:35: error: expected '{' after 'while' condition
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
 58 |         while let handle = unsafe iterator.next() {
    |                                   `- error: expected '{' after 'while' condition
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:39: error: expected 'else' after 'guard' condition
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                       `- error: expected 'else' after 'guard' condition
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:32: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:93: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                             `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:95: error: expected expression
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                               `- error: expected expression
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:63:20: error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
 63 |             return unsafe unsafeBitCast(symbol, to: T.self)
    |                    `- error: consecutive statements on a line must be separated by ';'
 64 |         }
 65 |
[601/733] Compiling MachOKit _DyldCacheFileRepresentable.swift
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:61: error: consecutive declarations on a line must be separated by ';'
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                             `- error: consecutive declarations on a line must be separated by ';'
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:68: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                                    `- error: expected declaration
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:16:16: error: expected ',' separator
 14 |     }
 15 |     nonisolated(unsafe) private static let symbolSearchHandles: [UnsafeMutableRawPointer?] = unsafe [
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
    |                `- error: expected ',' separator
 17 |         fallbackHandle,
 18 |     ]
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:18:5: error: unexpected ',' separator
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
 17 |         fallbackHandle,
 18 |     ]
    |     `- error: unexpected ',' separator
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:51: error: consecutive declarations on a line must be separated by ';'
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                   `- error: consecutive declarations on a line must be separated by ';'
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:58: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                          `- error: expected declaration
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:54: error: consecutive declarations on a line must be separated by ';'
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                      `- error: consecutive declarations on a line must be separated by ';'
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:61: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                             `- error: expected declaration
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: expected 'else' after 'guard' condition
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: expected 'else' after 'guard' condition
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:30: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                              `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:62: error: expected expression
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                                              `- error: expected expression
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:32: error: expected 'else' after 'guard' condition
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                `- error: expected 'else' after 'guard' condition
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:25: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                         `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:84: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                    `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:86: error: expected expression
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                      `- error: expected expression
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:37: error: expected 'else' after 'guard' condition
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                     `- error: expected 'else' after 'guard' condition
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:30: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                              `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: expected expression
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: expected expression
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:26: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:42: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:44: error: expected expression
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                            `- error: expected expression
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:49:16: error: consecutive statements on a line must be separated by ';'
 47 |         }
 48 |
 49 |         return unsafe String(cString: path)
    |                `- error: consecutive statements on a line must be separated by ';'
 50 |     }
 51 |
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:57:24: error: consecutive statements on a line must be separated by ';'
 55 |     ) -> T? {
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
    |                        `- error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:58:35: error: expected '{' after 'while' condition
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
 58 |         while let handle = unsafe iterator.next() {
    |                                   `- error: expected '{' after 'while' condition
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:39: error: expected 'else' after 'guard' condition
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                       `- error: expected 'else' after 'guard' condition
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:32: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:93: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                             `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:95: error: expected expression
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                               `- error: expected expression
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:63:20: error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
 63 |             return unsafe unsafeBitCast(symbol, to: T.self)
    |                    `- error: consecutive statements on a line must be separated by ';'
 64 |         }
 65 |
[602/733] Compiling MachOKit CxaDemangle.swift
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:61: error: consecutive declarations on a line must be separated by ';'
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                             `- error: consecutive declarations on a line must be separated by ';'
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:68: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                                    `- error: expected declaration
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:16:16: error: expected ',' separator
 14 |     }
 15 |     nonisolated(unsafe) private static let symbolSearchHandles: [UnsafeMutableRawPointer?] = unsafe [
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
    |                `- error: expected ',' separator
 17 |         fallbackHandle,
 18 |     ]
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:18:5: error: unexpected ',' separator
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
 17 |         fallbackHandle,
 18 |     ]
    |     `- error: unexpected ',' separator
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:51: error: consecutive declarations on a line must be separated by ';'
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                   `- error: consecutive declarations on a line must be separated by ';'
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:58: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                          `- error: expected declaration
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:54: error: consecutive declarations on a line must be separated by ';'
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                      `- error: consecutive declarations on a line must be separated by ';'
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:61: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                             `- error: expected declaration
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: expected 'else' after 'guard' condition
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: expected 'else' after 'guard' condition
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:30: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                              `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:62: error: expected expression
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                                              `- error: expected expression
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:32: error: expected 'else' after 'guard' condition
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                `- error: expected 'else' after 'guard' condition
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:25: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                         `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:84: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                    `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:86: error: expected expression
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                      `- error: expected expression
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:37: error: expected 'else' after 'guard' condition
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                     `- error: expected 'else' after 'guard' condition
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:30: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                              `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: expected expression
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: expected expression
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:26: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:42: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:44: error: expected expression
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                            `- error: expected expression
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:49:16: error: consecutive statements on a line must be separated by ';'
 47 |         }
 48 |
 49 |         return unsafe String(cString: path)
    |                `- error: consecutive statements on a line must be separated by ';'
 50 |     }
 51 |
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:57:24: error: consecutive statements on a line must be separated by ';'
 55 |     ) -> T? {
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
    |                        `- error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:58:35: error: expected '{' after 'while' condition
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
 58 |         while let handle = unsafe iterator.next() {
    |                                   `- error: expected '{' after 'while' condition
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:39: error: expected 'else' after 'guard' condition
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                       `- error: expected 'else' after 'guard' condition
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:32: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:93: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                             `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:95: error: expected expression
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                               `- error: expected expression
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:63:20: error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
 63 |             return unsafe unsafeBitCast(symbol, to: T.self)
    |                    `- error: consecutive statements on a line must be separated by ';'
 64 |         }
 65 |
[603/733] Compiling MachOKit SwiftDemangle.swift
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:61: error: consecutive declarations on a line must be separated by ';'
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                             `- error: consecutive declarations on a line must be separated by ';'
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:68: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                                    `- error: expected declaration
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:16:16: error: expected ',' separator
 14 |     }
 15 |     nonisolated(unsafe) private static let symbolSearchHandles: [UnsafeMutableRawPointer?] = unsafe [
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
    |                `- error: expected ',' separator
 17 |         fallbackHandle,
 18 |     ]
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:18:5: error: unexpected ',' separator
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
 17 |         fallbackHandle,
 18 |     ]
    |     `- error: unexpected ',' separator
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:51: error: consecutive declarations on a line must be separated by ';'
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                   `- error: consecutive declarations on a line must be separated by ';'
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:58: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                          `- error: expected declaration
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:54: error: consecutive declarations on a line must be separated by ';'
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                      `- error: consecutive declarations on a line must be separated by ';'
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:61: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                             `- error: expected declaration
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: expected 'else' after 'guard' condition
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: expected 'else' after 'guard' condition
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:30: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                              `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:62: error: expected expression
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                                              `- error: expected expression
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:32: error: expected 'else' after 'guard' condition
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                `- error: expected 'else' after 'guard' condition
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:25: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                         `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:84: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                    `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:86: error: expected expression
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                      `- error: expected expression
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:37: error: expected 'else' after 'guard' condition
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                     `- error: expected 'else' after 'guard' condition
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:30: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                              `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: expected expression
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: expected expression
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:26: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:42: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:44: error: expected expression
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                            `- error: expected expression
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:49:16: error: consecutive statements on a line must be separated by ';'
 47 |         }
 48 |
 49 |         return unsafe String(cString: path)
    |                `- error: consecutive statements on a line must be separated by ';'
 50 |     }
 51 |
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:57:24: error: consecutive statements on a line must be separated by ';'
 55 |     ) -> T? {
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
    |                        `- error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:58:35: error: expected '{' after 'while' condition
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
 58 |         while let handle = unsafe iterator.next() {
    |                                   `- error: expected '{' after 'while' condition
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:39: error: expected 'else' after 'guard' condition
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                       `- error: expected 'else' after 'guard' condition
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:32: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:93: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                             `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:95: error: expected expression
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                               `- error: expected expression
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:63:20: error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
 63 |             return unsafe unsafeBitCast(symbol, to: T.self)
    |                    `- error: consecutive statements on a line must be separated by ';'
 64 |         }
 65 |
[604/733] Compiling MachOKit DataTrieTree.swift
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:61: error: consecutive declarations on a line must be separated by ';'
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                             `- error: consecutive declarations on a line must be separated by ';'
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:68: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                                    `- error: expected declaration
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:16:16: error: expected ',' separator
 14 |     }
 15 |     nonisolated(unsafe) private static let symbolSearchHandles: [UnsafeMutableRawPointer?] = unsafe [
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
    |                `- error: expected ',' separator
 17 |         fallbackHandle,
 18 |     ]
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:18:5: error: unexpected ',' separator
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
 17 |         fallbackHandle,
 18 |     ]
    |     `- error: unexpected ',' separator
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:51: error: consecutive declarations on a line must be separated by ';'
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                   `- error: consecutive declarations on a line must be separated by ';'
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:58: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                          `- error: expected declaration
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:54: error: consecutive declarations on a line must be separated by ';'
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                      `- error: consecutive declarations on a line must be separated by ';'
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:61: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                             `- error: expected declaration
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: expected 'else' after 'guard' condition
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: expected 'else' after 'guard' condition
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:30: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                              `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:62: error: expected expression
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                                              `- error: expected expression
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:32: error: expected 'else' after 'guard' condition
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                `- error: expected 'else' after 'guard' condition
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:25: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                         `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:84: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                    `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:86: error: expected expression
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                      `- error: expected expression
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:37: error: expected 'else' after 'guard' condition
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                     `- error: expected 'else' after 'guard' condition
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:30: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                              `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: expected expression
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: expected expression
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:26: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:42: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:44: error: expected expression
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                            `- error: expected expression
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:49:16: error: consecutive statements on a line must be separated by ';'
 47 |         }
 48 |
 49 |         return unsafe String(cString: path)
    |                `- error: consecutive statements on a line must be separated by ';'
 50 |     }
 51 |
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:57:24: error: consecutive statements on a line must be separated by ';'
 55 |     ) -> T? {
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
    |                        `- error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:58:35: error: expected '{' after 'while' condition
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
 58 |         while let handle = unsafe iterator.next() {
    |                                   `- error: expected '{' after 'while' condition
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:39: error: expected 'else' after 'guard' condition
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                       `- error: expected 'else' after 'guard' condition
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:32: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:93: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                             `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:95: error: expected expression
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                               `- error: expected expression
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:63:20: error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
 63 |             return unsafe unsafeBitCast(symbol, to: T.self)
    |                    `- error: consecutive statements on a line must be separated by ';'
 64 |         }
 65 |
[605/733] Compiling MachOKit MemoryTrieTree.swift
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:61: error: consecutive declarations on a line must be separated by ';'
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                             `- error: consecutive declarations on a line must be separated by ';'
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:68: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                                    `- error: expected declaration
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:16:16: error: expected ',' separator
 14 |     }
 15 |     nonisolated(unsafe) private static let symbolSearchHandles: [UnsafeMutableRawPointer?] = unsafe [
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
    |                `- error: expected ',' separator
 17 |         fallbackHandle,
 18 |     ]
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:18:5: error: unexpected ',' separator
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
 17 |         fallbackHandle,
 18 |     ]
    |     `- error: unexpected ',' separator
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:51: error: consecutive declarations on a line must be separated by ';'
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                   `- error: consecutive declarations on a line must be separated by ';'
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:58: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                          `- error: expected declaration
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:54: error: consecutive declarations on a line must be separated by ';'
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                      `- error: consecutive declarations on a line must be separated by ';'
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:61: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                             `- error: expected declaration
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: expected 'else' after 'guard' condition
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: expected 'else' after 'guard' condition
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:30: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                              `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:62: error: expected expression
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                                              `- error: expected expression
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:32: error: expected 'else' after 'guard' condition
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                `- error: expected 'else' after 'guard' condition
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:25: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                         `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:84: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                    `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:86: error: expected expression
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                      `- error: expected expression
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:37: error: expected 'else' after 'guard' condition
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                     `- error: expected 'else' after 'guard' condition
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:30: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                              `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: expected expression
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: expected expression
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:26: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:42: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:44: error: expected expression
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                            `- error: expected expression
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:49:16: error: consecutive statements on a line must be separated by ';'
 47 |         }
 48 |
 49 |         return unsafe String(cString: path)
    |                `- error: consecutive statements on a line must be separated by ';'
 50 |     }
 51 |
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:57:24: error: consecutive statements on a line must be separated by ';'
 55 |     ) -> T? {
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
    |                        `- error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:58:35: error: expected '{' after 'while' condition
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
 58 |         while let handle = unsafe iterator.next() {
    |                                   `- error: expected '{' after 'while' condition
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:39: error: expected 'else' after 'guard' condition
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                       `- error: expected 'else' after 'guard' condition
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:32: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:93: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                             `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:95: error: expected expression
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                               `- error: expected expression
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:63:20: error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
 63 |             return unsafe unsafeBitCast(symbol, to: T.self)
    |                    `- error: consecutive statements on a line must be separated by ';'
 64 |         }
 65 |
[606/733] Compiling MachOKit TrieNode.swift
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:61: error: consecutive declarations on a line must be separated by ';'
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                             `- error: consecutive declarations on a line must be separated by ';'
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:68: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                                    `- error: expected declaration
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:16:16: error: expected ',' separator
 14 |     }
 15 |     nonisolated(unsafe) private static let symbolSearchHandles: [UnsafeMutableRawPointer?] = unsafe [
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
    |                `- error: expected ',' separator
 17 |         fallbackHandle,
 18 |     ]
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:18:5: error: unexpected ',' separator
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
 17 |         fallbackHandle,
 18 |     ]
    |     `- error: unexpected ',' separator
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:51: error: consecutive declarations on a line must be separated by ';'
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                   `- error: consecutive declarations on a line must be separated by ';'
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:58: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                          `- error: expected declaration
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:54: error: consecutive declarations on a line must be separated by ';'
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                      `- error: consecutive declarations on a line must be separated by ';'
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:61: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                             `- error: expected declaration
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: expected 'else' after 'guard' condition
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: expected 'else' after 'guard' condition
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:30: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                              `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:62: error: expected expression
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                                              `- error: expected expression
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:32: error: expected 'else' after 'guard' condition
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                `- error: expected 'else' after 'guard' condition
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:25: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                         `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:84: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                    `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:86: error: expected expression
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                      `- error: expected expression
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:37: error: expected 'else' after 'guard' condition
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                     `- error: expected 'else' after 'guard' condition
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:30: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                              `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: expected expression
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: expected expression
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:26: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:42: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:44: error: expected expression
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                            `- error: expected expression
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:49:16: error: consecutive statements on a line must be separated by ';'
 47 |         }
 48 |
 49 |         return unsafe String(cString: path)
    |                `- error: consecutive statements on a line must be separated by ';'
 50 |     }
 51 |
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:57:24: error: consecutive statements on a line must be separated by ';'
 55 |     ) -> T? {
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
    |                        `- error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:58:35: error: expected '{' after 'while' condition
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
 58 |         while let handle = unsafe iterator.next() {
    |                                   `- error: expected '{' after 'while' condition
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:39: error: expected 'else' after 'guard' condition
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                       `- error: expected 'else' after 'guard' condition
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:32: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:93: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                             `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:95: error: expected expression
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                               `- error: expected expression
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:63:20: error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
 63 |             return unsafe unsafeBitCast(symbol, to: T.self)
    |                    `- error: consecutive statements on a line must be separated by ';'
 64 |         }
 65 |
[607/733] Compiling MachOKit TrieNodeContent.swift
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:61: error: consecutive declarations on a line must be separated by ';'
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                             `- error: consecutive declarations on a line must be separated by ';'
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:68: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                                    `- error: expected declaration
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:16:16: error: expected ',' separator
 14 |     }
 15 |     nonisolated(unsafe) private static let symbolSearchHandles: [UnsafeMutableRawPointer?] = unsafe [
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
    |                `- error: expected ',' separator
 17 |         fallbackHandle,
 18 |     ]
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:18:5: error: unexpected ',' separator
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
 17 |         fallbackHandle,
 18 |     ]
    |     `- error: unexpected ',' separator
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:51: error: consecutive declarations on a line must be separated by ';'
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                   `- error: consecutive declarations on a line must be separated by ';'
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:58: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                          `- error: expected declaration
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:54: error: consecutive declarations on a line must be separated by ';'
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                      `- error: consecutive declarations on a line must be separated by ';'
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:61: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                             `- error: expected declaration
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: expected 'else' after 'guard' condition
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: expected 'else' after 'guard' condition
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:30: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                              `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:62: error: expected expression
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                                              `- error: expected expression
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:32: error: expected 'else' after 'guard' condition
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                `- error: expected 'else' after 'guard' condition
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:25: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                         `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:84: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                    `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:86: error: expected expression
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                      `- error: expected expression
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:37: error: expected 'else' after 'guard' condition
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                     `- error: expected 'else' after 'guard' condition
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:30: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                              `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: expected expression
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: expected expression
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:26: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:42: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:44: error: expected expression
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                            `- error: expected expression
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:49:16: error: consecutive statements on a line must be separated by ';'
 47 |         }
 48 |
 49 |         return unsafe String(cString: path)
    |                `- error: consecutive statements on a line must be separated by ';'
 50 |     }
 51 |
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:57:24: error: consecutive statements on a line must be separated by ';'
 55 |     ) -> T? {
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
    |                        `- error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:58:35: error: expected '{' after 'while' condition
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
 58 |         while let handle = unsafe iterator.next() {
    |                                   `- error: expected '{' after 'while' condition
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:39: error: expected 'else' after 'guard' condition
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                       `- error: expected 'else' after 'guard' condition
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:32: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:93: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                             `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:95: error: expected expression
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                               `- error: expected expression
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:63:20: error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
 63 |             return unsafe unsafeBitCast(symbol, to: T.self)
    |                    `- error: consecutive statements on a line must be separated by ';'
 64 |         }
 65 |
[608/733] Compiling MachOKit TrieTreeProtocol.swift
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:61: error: consecutive declarations on a line must be separated by ';'
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                             `- error: consecutive declarations on a line must be separated by ';'
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:68: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                                    `- error: expected declaration
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:16:16: error: expected ',' separator
 14 |     }
 15 |     nonisolated(unsafe) private static let symbolSearchHandles: [UnsafeMutableRawPointer?] = unsafe [
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
    |                `- error: expected ',' separator
 17 |         fallbackHandle,
 18 |     ]
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:18:5: error: unexpected ',' separator
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
 17 |         fallbackHandle,
 18 |     ]
    |     `- error: unexpected ',' separator
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:51: error: consecutive declarations on a line must be separated by ';'
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                   `- error: consecutive declarations on a line must be separated by ';'
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:58: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                          `- error: expected declaration
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:54: error: consecutive declarations on a line must be separated by ';'
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                      `- error: consecutive declarations on a line must be separated by ';'
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:61: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                             `- error: expected declaration
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: expected 'else' after 'guard' condition
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: expected 'else' after 'guard' condition
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:30: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                              `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:62: error: expected expression
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                                              `- error: expected expression
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:32: error: expected 'else' after 'guard' condition
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                `- error: expected 'else' after 'guard' condition
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:25: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                         `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:84: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                    `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:86: error: expected expression
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                      `- error: expected expression
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:37: error: expected 'else' after 'guard' condition
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                     `- error: expected 'else' after 'guard' condition
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:30: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                              `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: expected expression
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: expected expression
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:26: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:42: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:44: error: expected expression
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                            `- error: expected expression
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:49:16: error: consecutive statements on a line must be separated by ';'
 47 |         }
 48 |
 49 |         return unsafe String(cString: path)
    |                `- error: consecutive statements on a line must be separated by ';'
 50 |     }
 51 |
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:57:24: error: consecutive statements on a line must be separated by ';'
 55 |     ) -> T? {
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
    |                        `- error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:58:35: error: expected '{' after 'while' condition
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
 58 |         while let handle = unsafe iterator.next() {
    |                                   `- error: expected '{' after 'while' condition
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:39: error: expected 'else' after 'guard' condition
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                       `- error: expected 'else' after 'guard' condition
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:32: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:93: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                             `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:95: error: expected expression
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                               `- error: expected expression
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:63:20: error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
 63 |             return unsafe unsafeBitCast(symbol, to: T.self)
    |                    `- error: consecutive statements on a line must be separated by ';'
 64 |         }
 65 |
[609/733] Compiling MachOKit _DyldSharedCacheRuntime.swift
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:61: error: consecutive declarations on a line must be separated by ';'
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                             `- error: consecutive declarations on a line must be separated by ';'
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:68: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                                    `- error: expected declaration
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:16:16: error: expected ',' separator
 14 |     }
 15 |     nonisolated(unsafe) private static let symbolSearchHandles: [UnsafeMutableRawPointer?] = unsafe [
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
    |                `- error: expected ',' separator
 17 |         fallbackHandle,
 18 |     ]
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:18:5: error: unexpected ',' separator
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
 17 |         fallbackHandle,
 18 |     ]
    |     `- error: unexpected ',' separator
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:51: error: consecutive declarations on a line must be separated by ';'
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                   `- error: consecutive declarations on a line must be separated by ';'
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:58: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                          `- error: expected declaration
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:54: error: consecutive declarations on a line must be separated by ';'
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                      `- error: consecutive declarations on a line must be separated by ';'
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:61: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                             `- error: expected declaration
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: expected 'else' after 'guard' condition
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: expected 'else' after 'guard' condition
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:30: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                              `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:62: error: expected expression
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                                              `- error: expected expression
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:32: error: expected 'else' after 'guard' condition
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                `- error: expected 'else' after 'guard' condition
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:25: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                         `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:84: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                    `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:86: error: expected expression
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                      `- error: expected expression
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:37: error: expected 'else' after 'guard' condition
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                     `- error: expected 'else' after 'guard' condition
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:30: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                              `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: expected expression
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: expected expression
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:26: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:42: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:44: error: expected expression
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                            `- error: expected expression
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:49:16: error: consecutive statements on a line must be separated by ';'
 47 |         }
 48 |
 49 |         return unsafe String(cString: path)
    |                `- error: consecutive statements on a line must be separated by ';'
 50 |     }
 51 |
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:57:24: error: consecutive statements on a line must be separated by ';'
 55 |     ) -> T? {
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
    |                        `- error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:58:35: error: expected '{' after 'while' condition
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
 58 |         while let handle = unsafe iterator.next() {
    |                                   `- error: expected '{' after 'while' condition
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:39: error: expected 'else' after 'guard' condition
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                       `- error: expected 'else' after 'guard' condition
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:32: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:93: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                             `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:95: error: expected expression
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                               `- error: expected expression
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:63:20: error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
 63 |             return unsafe unsafeBitCast(symbol, to: T.self)
    |                    `- error: consecutive statements on a line must be separated by ';'
 64 |         }
 65 |
[610/733] Compiling MachOKit exported.swift
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:61: error: consecutive declarations on a line must be separated by ';'
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                             `- error: consecutive declarations on a line must be separated by ';'
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:68: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                                    `- error: expected declaration
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:16:16: error: expected ',' separator
 14 |     }
 15 |     nonisolated(unsafe) private static let symbolSearchHandles: [UnsafeMutableRawPointer?] = unsafe [
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
    |                `- error: expected ',' separator
 17 |         fallbackHandle,
 18 |     ]
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:18:5: error: unexpected ',' separator
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
 17 |         fallbackHandle,
 18 |     ]
    |     `- error: unexpected ',' separator
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:51: error: consecutive declarations on a line must be separated by ';'
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                   `- error: consecutive declarations on a line must be separated by ';'
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:58: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                          `- error: expected declaration
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:54: error: consecutive declarations on a line must be separated by ';'
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                      `- error: consecutive declarations on a line must be separated by ';'
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:61: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                             `- error: expected declaration
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: expected 'else' after 'guard' condition
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: expected 'else' after 'guard' condition
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:30: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                              `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:62: error: expected expression
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                                              `- error: expected expression
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:32: error: expected 'else' after 'guard' condition
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                `- error: expected 'else' after 'guard' condition
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:25: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                         `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:84: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                    `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:86: error: expected expression
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                      `- error: expected expression
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:37: error: expected 'else' after 'guard' condition
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                     `- error: expected 'else' after 'guard' condition
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:30: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                              `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: expected expression
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: expected expression
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:26: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:42: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:44: error: expected expression
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                            `- error: expected expression
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:49:16: error: consecutive statements on a line must be separated by ';'
 47 |         }
 48 |
 49 |         return unsafe String(cString: path)
    |                `- error: consecutive statements on a line must be separated by ';'
 50 |     }
 51 |
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:57:24: error: consecutive statements on a line must be separated by ';'
 55 |     ) -> T? {
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
    |                        `- error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:58:35: error: expected '{' after 'while' condition
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
 58 |         while let handle = unsafe iterator.next() {
    |                                   `- error: expected '{' after 'while' condition
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:39: error: expected 'else' after 'guard' condition
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                       `- error: expected 'else' after 'guard' condition
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:32: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:93: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                             `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:95: error: expected expression
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                               `- error: expected expression
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:63:20: error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
 63 |             return unsafe unsafeBitCast(symbol, to: T.self)
    |                    `- error: consecutive statements on a line must be separated by ';'
 64 |         }
 65 |
[611/733] Compiling MachOKit global.swift
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:61: error: consecutive declarations on a line must be separated by ';'
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                             `- error: consecutive declarations on a line must be separated by ';'
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:12:68: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
 10 |     private static let obfuscationKey: UInt8 = 0x5A
 11 |
 12 |     nonisolated(unsafe) private static let fallbackHandle = unsafe withDecodedCString(libraryPathBytes) {
    |                                                                    `- error: expected declaration
 13 |         dlopen($0, RTLD_LAZY | RTLD_LOCAL)
 14 |     }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:16:16: error: expected ',' separator
 14 |     }
 15 |     nonisolated(unsafe) private static let symbolSearchHandles: [UnsafeMutableRawPointer?] = unsafe [
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
    |                `- error: expected ',' separator
 17 |         fallbackHandle,
 18 |     ]
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:18:5: error: unexpected ',' separator
 16 |         unsafe UnsafeMutableRawPointer(bitPattern: -2),
 17 |         fallbackHandle,
 18 |     ]
    |     `- error: unexpected ',' separator
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:51: error: consecutive declarations on a line must be separated by ';'
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                   `- error: consecutive declarations on a line must be separated by ';'
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:20:58: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 18 |     ]
 19 |
 20 |     private static let sharedCacheRangeFunction = unsafe loadFunction(
    |                                                          `- error: expected declaration
 21 |         symbolBytes: sharedCacheRangeSymbolBytes,
 22 |         as: SharedCacheRangeFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:54: error: consecutive declarations on a line must be separated by ';'
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                      `- error: consecutive declarations on a line must be separated by ';'
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:25:61: error: expected declaration
  5 |
  6 | // Shared-cache runtime shim that avoids direct private loader helper imports.
  7 | @unsafe enum _DyldSharedCacheRuntime {
    |              `- note: in declaration of '_DyldSharedCacheRuntime'
  8 |     typealias SharedCacheRangeFunction = @convention(c) (UnsafeMutablePointer<Int>?) -> UnsafeRawPointer?
  9 |     typealias SharedCacheFilePathFunction = @convention(c) () -> UnsafePointer<CChar>?
    :
 23 |     )
 24 |
 25 |     private static let sharedCacheFilePathFunction = unsafe loadFunction(
    |                                                             `- error: expected declaration
 26 |         symbolBytes: sharedCacheFilePathSymbolBytes,
 27 |         as: SharedCacheFilePathFunction.self
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: expected 'else' after 'guard' condition
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: expected 'else' after 'guard' condition
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:30: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                              `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:37: error: consecutive statements on a line must be separated by ';'
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                     `- error: consecutive statements on a line must be separated by ';'
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:31:62: error: expected expression
 29 |
 30 |     static func sharedCacheRange() -> (ptr: UnsafeRawPointer, size: Int)? {
 31 |         guard let function = unsafe sharedCacheRangeFunction else {
    |                                                              `- error: expected expression
 32 |             return nil
 33 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:32: error: expected 'else' after 'guard' condition
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                `- error: expected 'else' after 'guard' condition
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:25: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                         `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:84: error: consecutive statements on a line must be separated by ';'
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                    `- error: consecutive statements on a line must be separated by ';'
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:36:86: error: expected expression
 34 |
 35 |         var size = 0
 36 |         guard let ptr = unsafe withUnsafeMutablePointer(to: &size, { function($0) }) else {
    |                                                                                      `- error: expected expression
 37 |             return nil
 38 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:37: error: expected 'else' after 'guard' condition
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                     `- error: expected 'else' after 'guard' condition
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:30: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                              `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: consecutive statements on a line must be separated by ';'
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: consecutive statements on a line must be separated by ';'
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:44:64: error: expected expression
 42 |
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
    |                                                                `- error: expected expression
 45 |               let path = unsafe function() else {
 46 |             return nil
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:26: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:42: error: consecutive statements on a line must be separated by ';'
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                          `- error: consecutive statements on a line must be separated by ';'
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:45:44: error: expected expression
 43 |     static func sharedCacheFilePath() -> String? {
 44 |         guard let function = unsafe sharedCacheFilePathFunction,
 45 |               let path = unsafe function() else {
    |                                            `- error: expected expression
 46 |             return nil
 47 |         }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:49:16: error: consecutive statements on a line must be separated by ';'
 47 |         }
 48 |
 49 |         return unsafe String(cString: path)
    |                `- error: consecutive statements on a line must be separated by ';'
 50 |     }
 51 |
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:57:24: error: consecutive statements on a line must be separated by ';'
 55 |     ) -> T? {
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
    |                        `- error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:58:35: error: expected '{' after 'while' condition
 56 |         _ = type
 57 |         var iterator = unsafe symbolSearchHandles.makeIterator()
 58 |         while let handle = unsafe iterator.next() {
    |                                   `- error: expected '{' after 'while' condition
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:39: error: expected 'else' after 'guard' condition
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                       `- error: expected 'else' after 'guard' condition
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:32: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:93: error: consecutive statements on a line must be separated by ';'
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                             `- error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:60:95: error: expected expression
 58 |         while let handle = unsafe iterator.next() {
 59 |             guard let handle,
 60 |                   let symbol = unsafe resolveSymbol(encodedName: symbolBytes, handle: handle) else {
    |                                                                                               `- error: expected expression
 61 |                 continue
 62 |             }
/host/spi-builder-workspace/Sources/MachOKit/Util/_DyldSharedCacheRuntime.swift:63:20: error: consecutive statements on a line must be separated by ';'
 61 |                 continue
 62 |             }
 63 |             return unsafe unsafeBitCast(symbol, to: T.self)
    |                    `- error: consecutive statements on a line must be separated by ';'
 64 |         }
 65 |
[612/733] Compiling MachOKit DyldChainedImportFormat.swift
[613/733] Compiling MachOKit DyldChainedPage.swift
[614/733] Compiling MachOKit DyldChainedStartsInImage.swift
[615/733] Compiling MachOKit DyldChainedStartsInSegment.swift
[616/733] Compiling MachOKit DyldChainedStartsOffsets.swift
[617/733] Compiling MachOKit DyldChainedSymbolsFormat.swift
[618/733] Compiling MachOKit ExportSymbolFlags.swift
[619/733] Compiling MachOKit ExportSymbolKind.swift
[620/733] Compiling MachOKit ExportTrieEntry.swift
[621/733] Compiling MachOKit ExportedSymbol.swift
[622/733] Compiling MachOKit FunctionStart.swift
[623/733] Compiling MachOKit IndirectSymbol.swift
[624/733] Compiling MachOKit Rebase.swift
[625/733] Compiling MachOKit RebaseOpcode.swift
[626/733] Compiling MachOKit RebaseOperation.swift
[627/733] Compiling MachOKit RebaseType.swift
[628/733] Compiling MachOKit Relocation.swift
[629/733] Compiling MachOKit RelocationInfo.swift
[630/733] Compiling MachOKit RelocationLength.swift
[631/733] Compiling MachOKit RelocationType.swift
[632/733] Compiling MachOKit ScatteredRelocationInfo.swift
[633/733] Compiling MachOKit Nlist.swift
[634/733] Compiling MachOKit Stab.swift
[635/733] Compiling MachOKit SymbolDescription.swift
[636/733] Compiling MachOKit AotCache+CodeFragments.swift
[637/733] Compiling MachOKit AotCache.swift
[638/733] Compiling MachOKit DyldCache+SubCaches.swift
[639/733] Compiling MachOKit DyldCache+host.swift
[640/733] Compiling MachOKit DyldCache.swift
[641/733] Compiling MachOKit DyldCacheLoaded+SubCaches.swift
[642/733] Compiling MachOKit DyldCacheLoaded+static.swift
[643/733] Compiling MachOKit DyldCacheLoaded.swift
[644/733] Compiling MachOKit Data+.swift
[645/733] Compiling MachOKit FileHandle+.swift
[646/733] Compiling MachOKit FixedWidthInteger+.swift
[647/733] Compiling MachOKit Sequence+.swift
[648/733] Compiling MachOKit String+.swift
[649/733] Compiling MachOKit TrieTreeProtocol+.swift
[650/733] Compiling MachOKit UUID+.swift
[651/733] Compiling MachOKit UnsafePointer+.swift
[652/733] Compiling MachOKit UnsafeRawPointer+.swift
[653/733] Compiling MachOKit _FileIOProtocol+.swift
[654/733] Compiling MachOKit dyld_chained_ptr+.swift
[655/733] Compiling MachOKit FatFile.swift
[656/733] Compiling MachOKit FullDyldCache+host.swift
[657/733] Compiling MachOKit FullDyldCache.swift
[658/733] Compiling MachOKit AotCacheHeader.swift
[659/733] Compiling MachOKit CPU.swift
[660/733] Compiling MachOKit CPUSubType.swift
[661/733] Compiling MachOKit ObjCHeaderInfoRO.swift
[662/733] Compiling MachOKit ObjCHeaderInfoRW.swift
[663/733] Compiling MachOKit ObjCHeaderOptimizationRO.swift
[664/733] Compiling MachOKit ObjCHeaderOptimizationRW.swift
[665/733] Compiling MachOKit ObjCImageInfo.swift
[666/733] Compiling MachOKit ObjCOptimization.swift
[667/733] Compiling MachOKit ObjCOptimizationFlags.swift
[668/733] Compiling MachOKit OldObjCOptimization.swift
[669/733] Compiling MachOKit _OldObjCOptimizationProtocol.swift
[670/733] Compiling MachOKit ProgramOffset.swift
[671/733] Compiling MachOKit ProgramsTrieNodeContent.swift
[672/733] Compiling MachOKit DyldCacheSlideInfo.swift
[673/733] Compiling MachOKit DyldCacheSlideInfo1.swift
[674/733] Compiling MachOKit DyldCacheSlideInfo2.swift
[675/733] Compiling MachOKit DyldCacheSlideInfo3.swift
[676/733] Compiling MachOKit DyldCacheSlideInfo4.swift
[677/733] Compiling MachOKit DyldCacheSlideInfo5.swift
[678/733] Compiling MachOKit SwiftOptimization.swift
[679/733] Compiling MachOKit DyldChainedFixupPointer.swift
[680/733] Compiling MachOKit DyldChainedFixupPointerContent.swift
[681/733] Compiling MachOKit DyldChainedFixupPointerFormat.swift
[682/733] Compiling MachOKit DyldChainedFixupPointerInfo.swift
[683/733] Compiling MachOKit DyldChainedFixupsHeader.swift
[684/733] Compiling MachOKit DyldChainedImport.swift
[685/733] Compiling MachOKit DependedDylib.swift
[686/733] Compiling MachOKit DyldCacheDynamicData.swift
[687/733] Compiling MachOKit DyldCacheFunctionVariantEntry.swift
[688/733] Compiling MachOKit DyldCacheFunctionVariantInfo.swift
[689/733] Compiling MachOKit DyldCacheImageInfo.swift
[690/733] Compiling MachOKit DyldCacheImageTextInfo.swift
[691/733] Compiling MachOKit DyldCacheLocalSymbolsEntry.swift
[692/733] Compiling MachOKit DyldCacheLocalSymbolsInfo.swift
[693/733] Compiling MachOKit DyldCacheMappingAndSlideInfo.swift
[694/733] Compiling MachOKit DyldCacheMappingFlags.swift
[695/733] Compiling MachOKit DyldCacheMappingInfo.swift
[696/733] Compiling MachOKit DyldCachePrewarming.swift
[697/733] Compiling MachOKit DyldCachePrewarmingEntry.swift
[698/733] Compiling MachOKit DyldCacheTproMappingInfo.swift
[699/733] Compiling MachOKit DyldSubCacheEntry.swift
[700/733] Compiling MachOKit DylibIndex.swift
[701/733] Compiling MachOKit DylibsTrieNodeContent.swift
[702/733] Compiling MachOKit LoaderRef.swift
[703/733] Compiling MachOKit ObjCBinaryInfo.swift
[704/733] Compiling MachOKit PrebuiltLoader.swift
[705/733] Compiling MachOKit PrebuiltLoaderProtocol.swift
[706/733] Compiling MachOKit PrebuiltLoaderSet.swift
[707/733] Compiling MachOKit PrebuiltLoader_Pre1165_3.swift
[708/733] Compiling MachOKit SectionLocations.swift
[709/733] Compiling MachOKit MachOFile+LoadCommands.swift
[710/733] Compiling MachOKit MachOFile+RebaseOperations.swift
[711/733] Compiling MachOKit MachOFile+Strings.swift
[712/733] Compiling MachOKit MachOFile+Symbols.swift
[713/733] Compiling MachOKit MachOFile.swift
[714/733] Compiling MachOKit MachOImage+BindOperations.swift
[715/733] Compiling MachOKit MachOImage+CodeSign.swift
[716/733] Compiling MachOKit MachOImage+DyldChainedFixups..swift
[717/733] Compiling MachOKit MachOImage+ExportTrie.swift
[718/733] Compiling MachOKit MachOImage+FunctionStarts.swift
[719/733] Compiling MachOKit MachOImage+LoadCommands.swift
[720/733] Compiling MachOKit MachOImage+RebaseOperations.swift
[721/733] Compiling MachOKit MachOImage+Strings.swift
[722/733] Compiling MachOKit MachOImage+Symbols.swift
[723/733] Compiling MachOKit MachOImage+static.swift
[724/733] Compiling MachOKit MachOImage.swift
[725/733] Compiling MachOKit MachOKit.swift
[726/733] Compiling MachOKit AotCacheCodeFragment.swift
[727/733] Compiling MachOKit AotCodeFragment.swift
[728/733] Compiling MachOKit AotCodeFragmentType.swift
[729/733] Compiling MachOKit AotBranchData.swift
[730/733] Compiling MachOKit AotBranchDataHeader.swift
[731/733] Compiling MachOKit AotBranchDataIndexEntry.swift
[732/733] Compiling MachOKit AotInstructionMap.swift
[733/733] Compiling MachOKit AotInstructionMapHeader.swift
BUILD FAILURE 6.0 linux