The Swift Package Index logo.Swift Package Index

Track the adoption of Swift 6 strict concurrency checks for data race safety. How many packages are Ready for Swift 6?

Build Information

Failed to build xcparse, reference master (fdba6f), with Swift 6.1 for Linux on 29 Apr 2025 18:46:20 UTC.

Build Command

bash -c docker run --pull=always --rm -v "checkouts-4609320-0":/host -w "$PWD" registry.gitlab.com/finestructure/spi-images:basic-6.1-latest swift build --triple x86_64-unknown-linux-gnu 2>&1

Build Log

/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:24:60: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
22 |     init(parser: ArgumentParser) {
23 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
24 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
   |                                                            `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
25 |                              optional: false, usage: "Path to the xcresult file", completion: .filename)
26 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:26:73: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
24 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
25 |                              optional: false, usage: "Path to the xcresult file", completion: .filename)
26 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
   |                                                                         `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
27 |                                    optional: true, usage: "Folder to export results to", completion: .filename)
28 |         verbose = subparser.add(option: "--verbose", shortName: "-v", kind: Bool.self, usage: "Enable verbose logging")
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:28:29: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
26 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
27 |                                    optional: true, usage: "Folder to export results to", completion: .filename)
28 |         verbose = subparser.add(option: "--verbose", shortName: "-v", kind: Bool.self, usage: "Enable verbose logging")
   |                             `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
29 |     }
30 |
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:41:42: warning: reference to var 'localFileSystem' is not concurrency-safe because it involves shared mutable state; this is an error in the Swift 6 language mode
39 |         if let outputPathArgument = arguments.get(self.outputPath) {
40 |             outputPath = outputPathArgument.path
41 |         } else if let workingDirectory = localFileSystem.currentWorkingDirectory {
   |                                          `- warning: reference to var 'localFileSystem' is not concurrency-safe because it involves shared mutable state; this is an error in the Swift 6 language mode
42 |             outputPath = workingDirectory
43 |         } else {
/host/spi-builder-workspace/.build/checkouts/swift-tools-support-core/Sources/TSCBasic/FileSystem.swift:1132:12: note: var declared here
1130 |
1131 | /// Public access to the local FS proxy.
1132 | public var localFileSystem: FileSystem = LocalFileSystem()
     |            `- note: var declared here
1133 |
1134 | extension FileSystem {
[224/230] Compiling xcparse CodeCoverageCommand.swift
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:18:15: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
 17 |
 18 |     var path: PositionalArgument<PathArgument>
    |               `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 19 |     var outputPath: PositionalArgument<PathArgument>
 20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:18:34: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
 17 |
 18 |     var path: PositionalArgument<PathArgument>
    |                                  `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 19 |     var outputPath: PositionalArgument<PathArgument>
 20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:19:21: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 17 |
 18 |     var path: PositionalArgument<PathArgument>
 19 |     var outputPath: PositionalArgument<PathArgument>
    |                     `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 20 |     var verbose: OptionArgument<Bool>
 21 |
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:19:40: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 17 |
 18 |     var path: PositionalArgument<PathArgument>
 19 |     var outputPath: PositionalArgument<PathArgument>
    |                                        `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 20 |     var verbose: OptionArgument<Bool>
 21 |
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:20:18: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 18 |     var path: PositionalArgument<PathArgument>
 19 |     var outputPath: PositionalArgument<PathArgument>
 20 |     var verbose: OptionArgument<Bool>
    |                  `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 21 |
 22 |     var divideByModel: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:22:24: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 20 |     var verbose: OptionArgument<Bool>
 21 |
 22 |     var divideByModel: OptionArgument<Bool>
    |                        `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 23 |     var divideByOS: OptionArgument<Bool>
 24 |     var divideByTestRun: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:23:21: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 21 |
 22 |     var divideByModel: OptionArgument<Bool>
 23 |     var divideByOS: OptionArgument<Bool>
    |                     `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 24 |     var divideByTestRun: OptionArgument<Bool>
 25 |     var divideByTestPlanConfig: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:24:26: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 22 |     var divideByModel: OptionArgument<Bool>
 23 |     var divideByOS: OptionArgument<Bool>
 24 |     var divideByTestRun: OptionArgument<Bool>
    |                          `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 25 |     var divideByTestPlanConfig: OptionArgument<Bool>
 26 |     var divideByLanguage: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:25:33: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 23 |     var divideByOS: OptionArgument<Bool>
 24 |     var divideByTestRun: OptionArgument<Bool>
 25 |     var divideByTestPlanConfig: OptionArgument<Bool>
    |                                 `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 26 |     var divideByLanguage: OptionArgument<Bool>
 27 |     var divideByRegion: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:26:27: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 24 |     var divideByTestRun: OptionArgument<Bool>
 25 |     var divideByTestPlanConfig: OptionArgument<Bool>
 26 |     var divideByLanguage: OptionArgument<Bool>
    |                           `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 27 |     var divideByRegion: OptionArgument<Bool>
 28 |     var divideByTest: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:27:25: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 25 |     var divideByTestPlanConfig: OptionArgument<Bool>
 26 |     var divideByLanguage: OptionArgument<Bool>
 27 |     var divideByRegion: OptionArgument<Bool>
    |                         `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 28 |     var divideByTest: OptionArgument<Bool>
 29 |
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:28:23: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 26 |     var divideByLanguage: OptionArgument<Bool>
 27 |     var divideByRegion: OptionArgument<Bool>
 28 |     var divideByTest: OptionArgument<Bool>
    |                       `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 29 |
 30 |     var utiWhitelist: OptionArgument<[String]>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:30:23: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 28 |     var divideByTest: OptionArgument<Bool>
 29 |
 30 |     var utiWhitelist: OptionArgument<[String]>
    |                       `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 31 |     var activityTypeWhitelist: OptionArgument<[String]>
 32 |
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:31:32: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 29 |
 30 |     var utiWhitelist: OptionArgument<[String]>
 31 |     var activityTypeWhitelist: OptionArgument<[String]>
    |                                `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 32 |
 33 |     init(parser: ArgumentParser) {
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:33:18: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 31 |     var activityTypeWhitelist: OptionArgument<[String]>
 32 |
 33 |     init(parser: ArgumentParser) {
    |                  `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 34 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
 35 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:55:30: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 53 |     }
 54 |
 55 |     func run(with arguments: ArgumentParser.Result) throws {
    |                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 56 |         guard let xcresultPathArgument = arguments.get(path) else {
 57 |             print("Missing xcresult path")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:35:60: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 33 |     init(parser: ArgumentParser) {
 34 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
 35 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
    |                                                            `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 36 |                              optional: false, usage: "Path to the xcresult file", completion: .filename)
 37 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:37:73: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 35 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
 36 |                              optional: false, usage: "Path to the xcresult file", completion: .filename)
 37 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
    |                                                                         `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 38 |                                    optional: true, usage: "Folder to export results to", completion: .filename)
 39 |         verbose = subparser.add(option: "--verbose", shortName: "-v", kind: Bool.self, usage: "Enable verbose logging")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:39:29: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 37 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
 38 |                                    optional: true, usage: "Folder to export results to", completion: .filename)
 39 |         verbose = subparser.add(option: "--verbose", shortName: "-v", kind: Bool.self, usage: "Enable verbose logging")
    |                             `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 40 |
 41 |         divideByModel = subparser.add(option: "--model", shortName: nil, kind: Bool.self, usage: "Divide attachments by model")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:41:35: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 39 |         verbose = subparser.add(option: "--verbose", shortName: "-v", kind: Bool.self, usage: "Enable verbose logging")
 40 |
 41 |         divideByModel = subparser.add(option: "--model", shortName: nil, kind: Bool.self, usage: "Divide attachments by model")
    |                                   `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 42 |         divideByOS = subparser.add(option: "--os", shortName: nil, kind: Bool.self, usage: "Divide attachments by OS")
 43 |         divideByTestRun = subparser.add(option: "--test-run", shortName: nil, kind: Bool.self, usage: "Deprecated. Use --test-plan-config")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:42:32: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 40 |
 41 |         divideByModel = subparser.add(option: "--model", shortName: nil, kind: Bool.self, usage: "Divide attachments by model")
 42 |         divideByOS = subparser.add(option: "--os", shortName: nil, kind: Bool.self, usage: "Divide attachments by OS")
    |                                `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 43 |         divideByTestRun = subparser.add(option: "--test-run", shortName: nil, kind: Bool.self, usage: "Deprecated. Use --test-plan-config")
 44 |         divideByTestPlanConfig = subparser.add(option: "--test-plan-config", shortName: nil, kind: Bool.self, usage: "Divide attachments by test plan configuration")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:43:37: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 41 |         divideByModel = subparser.add(option: "--model", shortName: nil, kind: Bool.self, usage: "Divide attachments by model")
 42 |         divideByOS = subparser.add(option: "--os", shortName: nil, kind: Bool.self, usage: "Divide attachments by OS")
 43 |         divideByTestRun = subparser.add(option: "--test-run", shortName: nil, kind: Bool.self, usage: "Deprecated. Use --test-plan-config")
    |                                     `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 44 |         divideByTestPlanConfig = subparser.add(option: "--test-plan-config", shortName: nil, kind: Bool.self, usage: "Divide attachments by test plan configuration")
 45 |         divideByLanguage = subparser.add(option: "--language", shortName: nil, kind: Bool.self, usage: "Divide attachments by test language")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:44:44: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 42 |         divideByOS = subparser.add(option: "--os", shortName: nil, kind: Bool.self, usage: "Divide attachments by OS")
 43 |         divideByTestRun = subparser.add(option: "--test-run", shortName: nil, kind: Bool.self, usage: "Deprecated. Use --test-plan-config")
 44 |         divideByTestPlanConfig = subparser.add(option: "--test-plan-config", shortName: nil, kind: Bool.self, usage: "Divide attachments by test plan configuration")
    |                                            `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 45 |         divideByLanguage = subparser.add(option: "--language", shortName: nil, kind: Bool.self, usage: "Divide attachments by test language")
 46 |         divideByRegion = subparser.add(option: "--region", shortName: nil, kind: Bool.self, usage: "Divide attachments by test region")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:45:38: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 43 |         divideByTestRun = subparser.add(option: "--test-run", shortName: nil, kind: Bool.self, usage: "Deprecated. Use --test-plan-config")
 44 |         divideByTestPlanConfig = subparser.add(option: "--test-plan-config", shortName: nil, kind: Bool.self, usage: "Divide attachments by test plan configuration")
 45 |         divideByLanguage = subparser.add(option: "--language", shortName: nil, kind: Bool.self, usage: "Divide attachments by test language")
    |                                      `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 46 |         divideByRegion = subparser.add(option: "--region", shortName: nil, kind: Bool.self, usage: "Divide attachments by test region")
 47 |         divideByTest = subparser.add(option: "--test", shortName: nil, kind: Bool.self, usage: "Divide attachments by test")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:46:36: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 44 |         divideByTestPlanConfig = subparser.add(option: "--test-plan-config", shortName: nil, kind: Bool.self, usage: "Divide attachments by test plan configuration")
 45 |         divideByLanguage = subparser.add(option: "--language", shortName: nil, kind: Bool.self, usage: "Divide attachments by test language")
 46 |         divideByRegion = subparser.add(option: "--region", shortName: nil, kind: Bool.self, usage: "Divide attachments by test region")
    |                                    `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 47 |         divideByTest = subparser.add(option: "--test", shortName: nil, kind: Bool.self, usage: "Divide attachments by test")
 48 |
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:47:34: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 45 |         divideByLanguage = subparser.add(option: "--language", shortName: nil, kind: Bool.self, usage: "Divide attachments by test language")
 46 |         divideByRegion = subparser.add(option: "--region", shortName: nil, kind: Bool.self, usage: "Divide attachments by test region")
 47 |         divideByTest = subparser.add(option: "--test", shortName: nil, kind: Bool.self, usage: "Divide attachments by test")
    |                                  `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 48 |
 49 |         utiWhitelist = subparser.add(option: "--uti", shortName: nil, kind: [String].self, strategy: .upToNextOption,
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:49:34: warning: conformance of 'String' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 47 |         divideByTest = subparser.add(option: "--test", shortName: nil, kind: Bool.self, usage: "Divide attachments by test")
 48 |
 49 |         utiWhitelist = subparser.add(option: "--uti", shortName: nil, kind: [String].self, strategy: .upToNextOption,
    |                                  `- warning: conformance of 'String' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 50 |                                      usage: "Whitelist of uniform type identifiers (UTI) attachments must conform to [optional, example: \"--uti public.image public.plain-text\"]")
 51 |         activityTypeWhitelist = subparser.add(option: "--activity-type", shortName: nil, kind: [String].self, strategy: .upToNextOption,
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:51:43: warning: conformance of 'String' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 49 |         utiWhitelist = subparser.add(option: "--uti", shortName: nil, kind: [String].self, strategy: .upToNextOption,
 50 |                                      usage: "Whitelist of uniform type identifiers (UTI) attachments must conform to [optional, example: \"--uti public.image public.plain-text\"]")
 51 |         activityTypeWhitelist = subparser.add(option: "--activity-type", shortName: nil, kind: [String].self, strategy: .upToNextOption,
    |                                           `- warning: conformance of 'String' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 52 |                                               usage: "Whitelist of acceptable activity types for attachments. If value does not specify domain, \"com.apple.dt.xctest.activity-type.\" is assumed and prefixed to the value [optional, example: \"--activity-type userCreated attachmentContainer com.apple.dt.xctest.activity-type.testAssertionFailure\"]")
 53 |     }
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:93:24: error: cannot find 'UTTypeConformsTo' in scope
 91 |                 let attachmentUTI = $0.uniformTypeIdentifier as CFString
 92 |                 for allowedUTI in allowedUTIsToExport {
 93 |                     if UTTypeConformsTo(attachmentUTI, allowedUTI as CFString) {
    |                        `- error: cannot find 'UTTypeConformsTo' in scope
 94 |                         return true
 95 |                     }
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:91:65: error: cannot find type 'CFString' in scope
 89 |         if let allowedUTIsToExport = arguments.get(self.utiWhitelist) {
 90 |             options.attachmentFilter = {
 91 |                 let attachmentUTI = $0.uniformTypeIdentifier as CFString
    |                                                                 `- error: cannot find type 'CFString' in scope
 92 |                 for allowedUTI in allowedUTIsToExport {
 93 |                     if UTTypeConformsTo(attachmentUTI, allowedUTI as CFString) {
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:93:70: error: cannot find type 'CFString' in scope
 91 |                 let attachmentUTI = $0.uniformTypeIdentifier as CFString
 92 |                 for allowedUTI in allowedUTIsToExport {
 93 |                     if UTTypeConformsTo(attachmentUTI, allowedUTI as CFString) {
    |                                                                      `- error: cannot find type 'CFString' in scope
 94 |                         return true
 95 |                     }
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:65:42: warning: reference to var 'localFileSystem' is not concurrency-safe because it involves shared mutable state; this is an error in the Swift 6 language mode
 63 |         if let outputPathArgument = arguments.get(self.outputPath) {
 64 |             outputPath = outputPathArgument.path
 65 |         } else if let workingDirectory = localFileSystem.currentWorkingDirectory {
    |                                          `- warning: reference to var 'localFileSystem' is not concurrency-safe because it involves shared mutable state; this is an error in the Swift 6 language mode
 66 |             outputPath = workingDirectory
 67 |         } else {
/host/spi-builder-workspace/.build/checkouts/swift-tools-support-core/Sources/TSCBasic/FileSystem.swift:1132:12: note: var declared here
1130 |
1131 | /// Public access to the local FS proxy.
1132 | public var localFileSystem: FileSystem = LocalFileSystem()
     |            `- note: var declared here
1133 |
1134 | extension FileSystem {
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:18:15: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
17 |
18 |     var path: PositionalArgument<PathArgument>
   |               `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
19 |     var outputPath: PositionalArgument<PathArgument>
20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:18:34: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
17 |
18 |     var path: PositionalArgument<PathArgument>
   |                                  `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
19 |     var outputPath: PositionalArgument<PathArgument>
20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:19:21: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
17 |
18 |     var path: PositionalArgument<PathArgument>
19 |     var outputPath: PositionalArgument<PathArgument>
   |                     `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
20 |     var verbose: OptionArgument<Bool>
21 |
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:19:40: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
17 |
18 |     var path: PositionalArgument<PathArgument>
19 |     var outputPath: PositionalArgument<PathArgument>
   |                                        `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
20 |     var verbose: OptionArgument<Bool>
21 |
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:20:18: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
18 |     var path: PositionalArgument<PathArgument>
19 |     var outputPath: PositionalArgument<PathArgument>
20 |     var verbose: OptionArgument<Bool>
   |                  `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
21 |
22 |     init(parser: ArgumentParser) {
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:22:18: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
20 |     var verbose: OptionArgument<Bool>
21 |
22 |     init(parser: ArgumentParser) {
   |                  `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
23 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
24 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:31:30: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
29 |     }
30 |
31 |     func run(with arguments: ArgumentParser.Result) throws {
   |                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
32 |         guard let xcresultPathArgument = arguments.get(path) else {
33 |             print("Missing xcresult path")
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:24:60: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
22 |     init(parser: ArgumentParser) {
23 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
24 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
   |                                                            `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
25 |                              optional: false, usage: "Path to the xcresult file", completion: .filename)
26 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:26:73: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
24 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
25 |                              optional: false, usage: "Path to the xcresult file", completion: .filename)
26 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
   |                                                                         `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
27 |                                    optional: true, usage: "Folder to export results to", completion: .filename)
28 |         verbose = subparser.add(option: "--verbose", shortName: "-v", kind: Bool.self, usage: "Enable verbose logging")
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:28:29: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
26 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
27 |                                    optional: true, usage: "Folder to export results to", completion: .filename)
28 |         verbose = subparser.add(option: "--verbose", shortName: "-v", kind: Bool.self, usage: "Enable verbose logging")
   |                             `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
29 |     }
30 |
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:41:42: warning: reference to var 'localFileSystem' is not concurrency-safe because it involves shared mutable state; this is an error in the Swift 6 language mode
39 |         if let outputPathArgument = arguments.get(self.outputPath) {
40 |             outputPath = outputPathArgument.path
41 |         } else if let workingDirectory = localFileSystem.currentWorkingDirectory {
   |                                          `- warning: reference to var 'localFileSystem' is not concurrency-safe because it involves shared mutable state; this is an error in the Swift 6 language mode
42 |             outputPath = workingDirectory
43 |         } else {
/host/spi-builder-workspace/.build/checkouts/swift-tools-support-core/Sources/TSCBasic/FileSystem.swift:1132:12: note: var declared here
1130 |
1131 | /// Public access to the local FS proxy.
1132 | public var localFileSystem: FileSystem = LocalFileSystem()
     |            `- note: var declared here
1133 |
1134 | extension FileSystem {
[225/230] Compiling xcparse VersionCommand.swift
/host/spi-builder-workspace/Sources/xcparse/VersionCommand.swift:18:18: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
16 |     let usage = ""
17 |
18 |     init(parser: ArgumentParser) {
   |                  `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
19 |         _ = parser.add(subparser: command, usage: usage, overview: overview)
20 |     }
/host/spi-builder-workspace/Sources/xcparse/VersionCommand.swift:22:30: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
20 |     }
21 |
22 |     func run(with arguments: ArgumentParser.Result) throws {
   |                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
23 |         let xcpParser = XCPParser()
24 |         xcpParser.printVersion()
[226/230] Compiling xcparse XCPParser.swift
/host/spi-builder-workspace/Sources/xcparse/XCPParser.swift:15:5: warning: let 'xcparseCurrentVersion' is not concurrency-safe because non-'Sendable' type 'Version' may have shared mutable state; this is an error in the Swift 6 language mode
 13 | import Converter
 14 |
 15 | let xcparseCurrentVersion = Version(2, 3, 2)
    |     `- warning: let 'xcparseCurrentVersion' is not concurrency-safe because non-'Sendable' type 'Version' may have shared mutable state; this is an error in the Swift 6 language mode
 16 |
 17 | struct XCResultToolCompatability {
/host/spi-builder-workspace/.build/checkouts/swift-tools-support-core/Sources/TSCUtility/Version.swift:14:15: note: struct 'Version' does not conform to the 'Sendable' protocol
 12 |
 13 | /// A struct representing a semver version.
 14 | public struct Version {
    |               `- note: struct 'Version' does not conform to the 'Sendable' protocol
 15 |
 16 |     /// The major version.
/host/spi-builder-workspace/Sources/xcparse/XCPParser.swift:11:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'TSCUtility'
  9 | import Foundation
 10 | import TSCBasic
 11 | import TSCUtility
    | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'TSCUtility'
 12 | import XCParseCore
 13 | import Converter
 14 |
 15 | let xcparseCurrentVersion = Version(2, 3, 2)
    |     |- note: add '@MainActor' to make let 'xcparseCurrentVersion' part of global actor 'MainActor'
    |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 16 |
 17 | struct XCResultToolCompatability {
/host/spi-builder-workspace/Sources/xcparse/XCPParser.swift:285:69: warning: reference to var 'stdoutStream' is not concurrency-safe because it involves shared mutable state; this is an error in the Swift 6 language mode
283 |
284 |         let header = (displayName != "") ? "Exporting \"\(displayName)\" Attachments" : "Exporting Attachments"
285 |         let progressBar = PercentProgressAnimation(stream: TSCBasic.stdoutStream, header: header)
    |                                                                     `- warning: reference to var 'stdoutStream' is not concurrency-safe because it involves shared mutable state; this is an error in the Swift 6 language mode
286 |         progressBar.update(step: 0, total: attachments.count, text: "")
287 |
/host/spi-builder-workspace/.build/checkouts/swift-tools-support-core/Sources/TSCBasic/WritableByteStream.swift:783:12: note: var declared here
781 |
782 | /// Public stdout stream instance.
783 | public var stdoutStream: ThreadSafeOutputByteStream = try! ThreadSafeOutputByteStream(LocalFileOutputByteStream(
    |            `- note: var declared here
784 |     filePointer: TSCLibc.stdout,
785 |     closeOnDeinit: false))
/host/spi-builder-workspace/Sources/xcparse/XCPParser.swift:438:30: error: cannot find 'URLRequest' in scope
436 |         let latestReleaseURL = URL(string: "https://api.github.com/repos/ChargePoint/xcparse/releases/latest")!
437 |
438 |         var releaseRequest = URLRequest(url: latestReleaseURL)
    |                              `- error: cannot find 'URLRequest' in scope
439 |         releaseRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
440 |
/host/spi-builder-workspace/Sources/xcparse/XCPParser.swift:441:20: error: 'URLSession' (aka 'AnyObject') cannot be constructed because it has no accessible initializers
439 |         releaseRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
440 |
441 | 		let urlSession = URLSession(configuration: .ephemeral)
    |                    `- error: 'URLSession' (aka 'AnyObject') cannot be constructed because it has no accessible initializers
442 |         let task = urlSession.dataTask(with: releaseRequest) { (data, response, error) in
443 |             if error != nil || data == nil {
/host/spi-builder-workspace/Sources/xcparse/XCPParser.swift:441:47: error: cannot infer contextual base in reference to member 'ephemeral'
439 |         releaseRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
440 |
441 | 		let urlSession = URLSession(configuration: .ephemeral)
    |                                               `- error: cannot infer contextual base in reference to member 'ephemeral'
442 |         let task = urlSession.dataTask(with: releaseRequest) { (data, response, error) in
443 |             if error != nil || data == nil {
[227/230] Compiling xcparse main.swift
Running build ...
bash -c docker run --pull=always --rm -v "checkouts-4609320-0":/host -w "$PWD" registry.gitlab.com/finestructure/spi-images:basic-6.1-latest swift build --triple x86_64-unknown-linux-gnu 2>&1
basic-6.1-latest: Pulling from finestructure/spi-images
Digest: sha256:3bdcac04179f4ed3e5b8e9dbd6e74bbf5ebc0f4fde48bbaad7d1e5c757e65bcb
Status: Image is up to date for registry.gitlab.com/finestructure/spi-images:basic-6.1-latest
[0/1] Planning build
Building for debugging...
[0/10] Write swift-version-24593BA9C3E375BF.txt
[2/33] Compiling TSCLibc libc.swift
[3/33] Emitting module TSCLibc
[4/37] Compiling testUtility Resource.swift
[5/37] Emitting module testUtility
[6/37] Compiling testUtility FileManagerExtensions.swift
[9/37] Emitting module SystemPackage
[10/39] Compiling SystemPackage Mocking.swift
[11/39] Compiling SystemPackage Syscalls.swift
[12/39] Compiling SystemPackage WindowsSyscallAdapters.swift
[13/39] Compiling SystemPackage PlatformString.swift
[14/39] Compiling SystemPackage SystemString.swift
[15/39] Compiling SystemPackage CInterop.swift
[16/39] Compiling SystemPackage Constants.swift
[17/39] Compiling SystemPackage Exports.swift
[18/39] Compiling SystemPackage FilePathSyntax.swift
[19/39] Compiling SystemPackage FilePathWindows.swift
[20/39] Compiling SystemPackage FilePermissions.swift
[21/39] Compiling SystemPackage Errno.swift
[22/39] Compiling SystemPackage FileDescriptor.swift
[23/39] Compiling SystemPackage FileHelpers.swift
[24/39] Compiling SystemPackage Util.swift
[25/39] Compiling SystemPackage UtilConsumers.swift
[26/39] Compiling SystemPackage FileOperations.swift
[27/39] Compiling SystemPackage FilePath.swift
[28/39] Compiling SystemPackage FilePathComponentView.swift
[29/39] Compiling SystemPackage FilePathComponents.swift
[30/39] Compiling SystemPackage FilePathParsing.swift
[31/39] Compiling SystemPackage FilePathString.swift
[32/40] Wrapping AST for SystemPackage for debugging
[34/80] Compiling TSCBasic CodableResult.swift
[35/80] Compiling TSCBasic CollectionAlgorithms.swift
[36/80] Compiling TSCBasic CollectionExtensions.swift
[37/80] Compiling TSCBasic Condition.swift
[38/80] Compiling TSCBasic DeltaAlgorithm.swift
[39/80] Compiling TSCBasic DiagnosticsEngine.swift
[40/85] Emitting module TSCBasic
[41/85] Compiling TSCBasic Result.swift
[42/85] Compiling TSCBasic SortedArray.swift
[43/85] Compiling TSCBasic StringConversions.swift
[44/85] Compiling TSCBasic SynchronizedQueue.swift
[45/85] Compiling TSCBasic TemporaryFile.swift
[46/85] Compiling TSCBasic PathShims.swift
[47/85] Compiling TSCBasic Process.swift
[48/85] Compiling TSCBasic ProcessEnv.swift
[49/85] Compiling TSCBasic ProcessSet.swift
[50/85] Compiling TSCBasic RegEx.swift
[51/85] Compiling TSCBasic HashAlgorithms.swift
[52/85] Compiling TSCBasic JSON.swift
[53/85] Compiling TSCBasic JSONMapper.swift
[54/85] Compiling TSCBasic KeyedPair.swift
[55/85] Compiling TSCBasic LazyCache.swift
[56/85] Compiling TSCBasic Lock.swift
[57/85] Compiling TSCBasic OSLog.swift
[58/85] Compiling TSCBasic ObjectIdentifierProtocol.swift
[59/85] Compiling TSCBasic OrderedDictionary.swift
[60/85] Compiling TSCBasic OrderedSet.swift
[61/85] Compiling TSCBasic Path.swift
[62/85] Compiling TSCBasic Await.swift
[63/85] Compiling TSCBasic Base64URL.swift
[64/85] Compiling TSCBasic ByteString.swift
[65/85] Compiling TSCBasic CStringArray.swift
[66/85] Compiling TSCBasic CacheableSequence.swift
[67/85] Compiling TSCBasic Closable.swift
[68/85] Compiling TSCBasic DictionaryExtensions.swift
[69/85] Compiling TSCBasic DictionaryLiteralExtensions.swift
[70/85] Compiling TSCBasic EditDistance.swift
[71/85] Compiling TSCBasic FileInfo.swift
[72/85] Compiling TSCBasic FileSystem.swift
[73/85] Compiling TSCBasic GraphAlgorithms.swift
[74/85] Compiling TSCBasic TerminalController.swift
[75/85] Compiling TSCBasic Thread.swift
[76/85] Compiling TSCBasic Tuple.swift
[77/85] Compiling TSCBasic WritableByteStream.swift
[78/85] Compiling TSCBasic misc.swift
[79/86] Wrapping AST for TSCBasic for debugging
[81/122] Emitting module TSCUtility
[82/127] Compiling TSCUtility PolymorphicCodable.swift
[83/127] Compiling TSCUtility ProgressAnimation.swift
[84/127] Compiling TSCUtility SQLite.swift
[85/127] Compiling TSCUtility SerializedDiagnostics.swift
[86/127] Compiling TSCUtility SimplePersistence.swift
[87/127] Compiling TSCUtility Context.swift
[88/127] Compiling TSCUtility Diagnostics.swift
[89/127] Compiling TSCUtility FSWatch.swift
[90/127] Compiling TSCUtility FloatingPointExtensions.swift
[91/127] Compiling TSCUtility Git.swift
[92/127] Compiling TSCUtility StringExtensions.swift
[93/127] Compiling TSCUtility StringMangling.swift
[94/127] Compiling TSCUtility Tracing.swift
[95/127] Compiling TSCUtility Triple.swift
[96/127] Compiling TSCUtility URL.swift
[97/127] Compiling TSCUtility OSLog.swift
[98/127] Compiling TSCUtility OrderedZip.swift
[99/127] Compiling TSCUtility PersistenceCache.swift
[100/127] Compiling TSCUtility PkgConfig.swift
[101/127] Compiling TSCUtility Platform.swift
[102/127] Compiling TSCUtility Hex.swift
[103/127] Compiling TSCUtility IndexStore.swift
[104/127] Compiling TSCUtility InterruptHandler.swift
[105/127] Compiling TSCUtility JSONMessageStreamingParser.swift
[106/127] Compiling TSCUtility Netrc.swift
[107/127] Compiling TSCUtility Bitstream.swift
[108/127] Compiling TSCUtility BitstreamReader.swift
[109/127] Compiling TSCUtility BitstreamWriter.swift
[110/127] Compiling TSCUtility BuildFlags.swift
[111/127] Compiling TSCUtility CollectionExtensions.swift
[112/127] Compiling TSCUtility Archiver.swift
[113/127] Compiling TSCUtility ArgumentParser.swift
[114/127] Compiling TSCUtility ArgumentParserShellCompletion.swift
[115/127] Compiling TSCUtility Array+Extensions.swift
[116/127] Compiling TSCUtility Bits.swift
[117/127] Compiling TSCUtility Verbosity.swift
[118/127] Compiling TSCUtility Version.swift
[119/127] Compiling TSCUtility Versioning.swift
[120/127] Compiling TSCUtility dlopen.swift
[121/127] Compiling TSCUtility misc.swift
[122/128] Wrapping AST for TSCUtility for debugging
[124/185] Compiling XCParseCore ActivityLogAnalyzerControlFlowStep.swift
[125/185] Compiling XCParseCore ActivityLogAnalyzerControlFlowStepEdge.swift
[126/185] Compiling XCParseCore ActivityLogAnalyzerEventStep.swift
[127/185] Compiling XCParseCore ActivityLogAnalyzerResultMessage.swift
[128/185] Compiling XCParseCore ActivityLogAnalyzerStep.swift
[129/185] Compiling XCParseCore ActivityLogAnalyzerWarningMessage.swift
[130/185] Compiling XCParseCore ActivityLogCommandInvocationSection.swift
[131/185] Compiling XCParseCore ActivityLogMajorSection.swift
[132/185] Compiling XCParseCore ConsoleLogItem.swift
[133/185] Compiling XCParseCore ConsoleLogSection.swift
[134/185] Compiling XCParseCore DocumentLocation.swift
[135/185] Compiling XCParseCore EntityIdentifier.swift
[136/185] Compiling XCParseCore String+ASCII.swift
[137/185] Compiling XCParseCore URL+Directory.swift
[138/185] Compiling XCParseCore IssueSummary.swift
[139/185] Compiling XCParseCore ObjectID.swift
[140/193] Compiling XCParseCore ActivityLogMessage.swift
[141/193] Compiling XCParseCore ActivityLogMessageAnnotation.swift
[142/193] Compiling XCParseCore ActivityLogSection.swift
[143/193] Compiling XCParseCore ActivityLogTargetBuildSection.swift
[144/193] Compiling XCParseCore ActivityLogUnitTestSection.swift
[145/193] Compiling XCParseCore ArchiveInfo.swift
[146/193] Compiling XCParseCore CodeCoverageInfo.swift
[147/193] Compiling XCParseCore Console.swift
[148/193] Compiling XCParseCore ActionTestAttachment.swift
[149/193] Compiling XCParseCore ActionTestConfiguration.swift
[150/193] Compiling XCParseCore ActionTestExpectedFailure.swift
[151/193] Compiling XCParseCore ActionTestFailureSummary.swift
[152/193] Compiling XCParseCore ActionTestMetadata.swift
[153/193] Compiling XCParseCore ActionTestNoticeSummary.swift
[154/193] Compiling XCParseCore ActionTestPerformanceMetricSummary.swift
[155/193] Compiling XCParseCore ActionTestPlanRunSummaries.swift
[156/193] Compiling XCParseCore Reference.swift
[157/193] Compiling XCParseCore ResultIssueSummaries.swift
[158/193] Compiling XCParseCore ResultMetrics.swift
[159/193] Compiling XCParseCore SortedKeyValueArray.swift
[160/193] Compiling XCParseCore SortedKeyValueArrayPair.swift
[161/193] Compiling XCParseCore SourceCodeContext.swift
[162/193] Compiling XCParseCore SourceCodeFrame.swift
[163/193] Compiling XCParseCore SourceCodeLocation.swift
[164/193] Compiling XCParseCore ActionAbstractTestSummary.swift
[165/193] Compiling XCParseCore ActionDeviceRecord.swift
[166/193] Compiling XCParseCore ActionPlatformRecord.swift
[167/193] Compiling XCParseCore ActionRecord.swift
[168/193] Compiling XCParseCore ActionResult.swift
[169/193] Compiling XCParseCore ActionRunDestinationRecord.swift
[170/193] Compiling XCParseCore ActionSDKRecord.swift
[171/193] Compiling XCParseCore ActionTestActivitySummary.swift
[172/193] Compiling XCParseCore ActionTestPlanRunSummary.swift
[173/193] Compiling XCParseCore ActionTestRepetitionPolicySummary.swift
[174/193] Compiling XCParseCore ActionTestSummary.swift
[175/193] Compiling XCParseCore ActionTestSummaryGroup.swift
[176/193] Compiling XCParseCore ActionTestSummaryIdentifiableObject.swift
[177/193] Compiling XCParseCore ActionTestableSummary.swift
[178/193] Compiling XCParseCore ActionsInvocationMetadata.swift
[179/193] Compiling XCParseCore ActionsInvocationRecord.swift
[180/193] Emitting module XCParseCore
[181/193] Compiling XCParseCore SourceCodeSymbolInfo.swift
/host/spi-builder-workspace/Sources/XCParseCore/Version+XCPTooling.swift:38:47: warning: 'init(string:)' is deprecated: replaced by 'init(_:)'
36 |                         xcresulttoolVersion = Version(xcresulttoolVersionInt, 0, 0)
37 |                     } else {
38 |                         xcresulttoolVersion = Version(string: xcresulttoolVersionString)
   |                                               |- warning: 'init(string:)' is deprecated: replaced by 'init(_:)'
   |                                               `- note: use 'init(_:)' instead
39 |                     }
40 |
[182/193] Compiling XCParseCore TestAssociatedError.swift
/host/spi-builder-workspace/Sources/XCParseCore/Version+XCPTooling.swift:38:47: warning: 'init(string:)' is deprecated: replaced by 'init(_:)'
36 |                         xcresulttoolVersion = Version(xcresulttoolVersionInt, 0, 0)
37 |                     } else {
38 |                         xcresulttoolVersion = Version(string: xcresulttoolVersionString)
   |                                               |- warning: 'init(string:)' is deprecated: replaced by 'init(_:)'
   |                                               `- note: use 'init(_:)' instead
39 |                     }
40 |
[183/193] Compiling XCParseCore TestFailureIssueSummary.swift
/host/spi-builder-workspace/Sources/XCParseCore/Version+XCPTooling.swift:38:47: warning: 'init(string:)' is deprecated: replaced by 'init(_:)'
36 |                         xcresulttoolVersion = Version(xcresulttoolVersionInt, 0, 0)
37 |                     } else {
38 |                         xcresulttoolVersion = Version(string: xcresulttoolVersionString)
   |                                               |- warning: 'init(string:)' is deprecated: replaced by 'init(_:)'
   |                                               `- note: use 'init(_:)' instead
39 |                     }
40 |
[184/193] Compiling XCParseCore TypeDefinition.swift
/host/spi-builder-workspace/Sources/XCParseCore/Version+XCPTooling.swift:38:47: warning: 'init(string:)' is deprecated: replaced by 'init(_:)'
36 |                         xcresulttoolVersion = Version(xcresulttoolVersionInt, 0, 0)
37 |                     } else {
38 |                         xcresulttoolVersion = Version(string: xcresulttoolVersionString)
   |                                               |- warning: 'init(string:)' is deprecated: replaced by 'init(_:)'
   |                                               `- note: use 'init(_:)' instead
39 |                     }
40 |
[185/193] Compiling XCParseCore Version+XCPTooling.swift
/host/spi-builder-workspace/Sources/XCParseCore/Version+XCPTooling.swift:38:47: warning: 'init(string:)' is deprecated: replaced by 'init(_:)'
36 |                         xcresulttoolVersion = Version(xcresulttoolVersionInt, 0, 0)
37 |                     } else {
38 |                         xcresulttoolVersion = Version(string: xcresulttoolVersionString)
   |                                               |- warning: 'init(string:)' is deprecated: replaced by 'init(_:)'
   |                                               `- note: use 'init(_:)' instead
39 |                     }
40 |
[186/193] Compiling XCParseCore XCPResultDecoding.swift
/host/spi-builder-workspace/Sources/XCParseCore/Version+XCPTooling.swift:38:47: warning: 'init(string:)' is deprecated: replaced by 'init(_:)'
36 |                         xcresulttoolVersion = Version(xcresulttoolVersionInt, 0, 0)
37 |                     } else {
38 |                         xcresulttoolVersion = Version(string: xcresulttoolVersionString)
   |                                               |- warning: 'init(string:)' is deprecated: replaced by 'init(_:)'
   |                                               `- note: use 'init(_:)' instead
39 |                     }
40 |
[187/193] Compiling XCParseCore XCResult.swift
/host/spi-builder-workspace/Sources/XCParseCore/Version+XCPTooling.swift:38:47: warning: 'init(string:)' is deprecated: replaced by 'init(_:)'
36 |                         xcresulttoolVersion = Version(xcresulttoolVersionInt, 0, 0)
37 |                     } else {
38 |                         xcresulttoolVersion = Version(string: xcresulttoolVersionString)
   |                                               |- warning: 'init(string:)' is deprecated: replaced by 'init(_:)'
   |                                               `- note: use 'init(_:)' instead
39 |                     }
40 |
[188/193] Compiling XCParseCore XCResultToolCommand.swift
/host/spi-builder-workspace/Sources/XCParseCore/Version+XCPTooling.swift:38:47: warning: 'init(string:)' is deprecated: replaced by 'init(_:)'
36 |                         xcresulttoolVersion = Version(xcresulttoolVersionInt, 0, 0)
37 |                     } else {
38 |                         xcresulttoolVersion = Version(string: xcresulttoolVersionString)
   |                                               |- warning: 'init(string:)' is deprecated: replaced by 'init(_:)'
   |                                               `- note: use 'init(_:)' instead
39 |                     }
40 |
[190/203] Compiling Converter DeviceModel.swift
[191/204] Compiling Converter ReportConverter.swift
[192/204] Compiling Converter AppSizeParser.swift
[193/204] Compiling Converter VariantModel.swift
[194/204] Compiling Converter VariantDescriptorParser.swift
[195/204] Compiling Converter FileController.swift
[196/204] Compiling Converter MemorySize.swift
[197/204] Emitting module Converter
[198/204] Compiling Converter ResultFactory.swift
[199/204] Compiling Converter AppSizeModel.swift
[200/204] Compiling Converter VariantParser.swift
[202/215] Compiling xcparse ConverterCommand.swift
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:18:23: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
16 |     let usage = "[OPTIONS] appSizeReport outputDirectory"
17 |
18 |     var flagVariants: OptionArgument<String>
   |                       `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
19 |     var reportPath: PositionalArgument<PathArgument>
20 |     var resultPath: PositionalArgument<PathArgument>
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:19:21: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
17 |
18 |     var flagVariants: OptionArgument<String>
19 |     var reportPath: PositionalArgument<PathArgument>
   |                     `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
20 |     var resultPath: PositionalArgument<PathArgument>
21 |
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:19:40: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
17 |
18 |     var flagVariants: OptionArgument<String>
19 |     var reportPath: PositionalArgument<PathArgument>
   |                                        `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
20 |     var resultPath: PositionalArgument<PathArgument>
21 |
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:20:21: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
18 |     var flagVariants: OptionArgument<String>
19 |     var reportPath: PositionalArgument<PathArgument>
20 |     var resultPath: PositionalArgument<PathArgument>
   |                     `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
21 |
22 |     init(parser: ArgumentParser) {
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:20:40: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
18 |     var flagVariants: OptionArgument<String>
19 |     var reportPath: PositionalArgument<PathArgument>
20 |     var resultPath: PositionalArgument<PathArgument>
   |                                        `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
21 |
22 |     init(parser: ArgumentParser) {
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:22:18: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
20 |     var resultPath: PositionalArgument<PathArgument>
21 |
22 |     init(parser: ArgumentParser) {
   |                  `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
23 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
24 |
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:33:30: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
31 |     }
32 |
33 |     func run(with arguments: ArgumentParser.Result) throws {
   |                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
34 |         let xcpParser = XCPParser()
35 |
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:25:34: warning: conformance of 'String' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
23 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
24 |
25 |         flagVariants = subparser.add(option: "--flag-variants", kind: String.self, usage: "Flag variants above the specified size limit [optional, example: \"--flag-variants 10MB\"]")
   |                                  `- warning: conformance of 'String' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
26 |         reportPath = subparser.add(positional: "appSizeReport", kind: PathArgument.self,
27 |                              optional: false, usage: "Path to App Thinning Size Report", completion: .filename)
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:26:71: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
24 |
25 |         flagVariants = subparser.add(option: "--flag-variants", kind: String.self, usage: "Flag variants above the specified size limit [optional, example: \"--flag-variants 10MB\"]")
26 |         reportPath = subparser.add(positional: "appSizeReport", kind: PathArgument.self,
   |                                                                       `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
27 |                              optional: false, usage: "Path to App Thinning Size Report", completion: .filename)
28 |         resultPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:28:73: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
26 |         reportPath = subparser.add(positional: "appSizeReport", kind: PathArgument.self,
27 |                              optional: false, usage: "Path to App Thinning Size Report", completion: .filename)
28 |         resultPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
   |                                                                         `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
29 |                                    optional: true, usage: "Folder to export results to", completion: .filename)
30 |
[203/215] Compiling xcparse GitHubLatestReleaseResponse.swift
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:18:23: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
16 |     let usage = "[OPTIONS] appSizeReport outputDirectory"
17 |
18 |     var flagVariants: OptionArgument<String>
   |                       `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
19 |     var reportPath: PositionalArgument<PathArgument>
20 |     var resultPath: PositionalArgument<PathArgument>
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:19:21: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
17 |
18 |     var flagVariants: OptionArgument<String>
19 |     var reportPath: PositionalArgument<PathArgument>
   |                     `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
20 |     var resultPath: PositionalArgument<PathArgument>
21 |
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:19:40: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
17 |
18 |     var flagVariants: OptionArgument<String>
19 |     var reportPath: PositionalArgument<PathArgument>
   |                                        `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
20 |     var resultPath: PositionalArgument<PathArgument>
21 |
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:20:21: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
18 |     var flagVariants: OptionArgument<String>
19 |     var reportPath: PositionalArgument<PathArgument>
20 |     var resultPath: PositionalArgument<PathArgument>
   |                     `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
21 |
22 |     init(parser: ArgumentParser) {
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:20:40: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
18 |     var flagVariants: OptionArgument<String>
19 |     var reportPath: PositionalArgument<PathArgument>
20 |     var resultPath: PositionalArgument<PathArgument>
   |                                        `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
21 |
22 |     init(parser: ArgumentParser) {
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:22:18: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
20 |     var resultPath: PositionalArgument<PathArgument>
21 |
22 |     init(parser: ArgumentParser) {
   |                  `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
23 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
24 |
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:33:30: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
31 |     }
32 |
33 |     func run(with arguments: ArgumentParser.Result) throws {
   |                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
34 |         let xcpParser = XCPParser()
35 |
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:25:34: warning: conformance of 'String' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
23 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
24 |
25 |         flagVariants = subparser.add(option: "--flag-variants", kind: String.self, usage: "Flag variants above the specified size limit [optional, example: \"--flag-variants 10MB\"]")
   |                                  `- warning: conformance of 'String' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
26 |         reportPath = subparser.add(positional: "appSizeReport", kind: PathArgument.self,
27 |                              optional: false, usage: "Path to App Thinning Size Report", completion: .filename)
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:26:71: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
24 |
25 |         flagVariants = subparser.add(option: "--flag-variants", kind: String.self, usage: "Flag variants above the specified size limit [optional, example: \"--flag-variants 10MB\"]")
26 |         reportPath = subparser.add(positional: "appSizeReport", kind: PathArgument.self,
   |                                                                       `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
27 |                              optional: false, usage: "Path to App Thinning Size Report", completion: .filename)
28 |         resultPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:28:73: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
26 |         reportPath = subparser.add(positional: "appSizeReport", kind: PathArgument.self,
27 |                              optional: false, usage: "Path to App Thinning Size Report", completion: .filename)
28 |         resultPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
   |                                                                         `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
29 |                                    optional: true, usage: "Folder to export results to", completion: .filename)
30 |
[204/215] Compiling xcparse AttachmentsCommand.swift
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:18:15: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
 17 |
 18 |     var path: PositionalArgument<PathArgument>
    |               `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 19 |     var outputPath: PositionalArgument<PathArgument>
 20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:18:34: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
 17 |
 18 |     var path: PositionalArgument<PathArgument>
    |                                  `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 19 |     var outputPath: PositionalArgument<PathArgument>
 20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:19:21: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 17 |
 18 |     var path: PositionalArgument<PathArgument>
 19 |     var outputPath: PositionalArgument<PathArgument>
    |                     `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 20 |     var verbose: OptionArgument<Bool>
 21 |
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:19:40: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 17 |
 18 |     var path: PositionalArgument<PathArgument>
 19 |     var outputPath: PositionalArgument<PathArgument>
    |                                        `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 20 |     var verbose: OptionArgument<Bool>
 21 |
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:20:18: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 18 |     var path: PositionalArgument<PathArgument>
 19 |     var outputPath: PositionalArgument<PathArgument>
 20 |     var verbose: OptionArgument<Bool>
    |                  `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 21 |
 22 |     var divideByModel: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:22:24: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 20 |     var verbose: OptionArgument<Bool>
 21 |
 22 |     var divideByModel: OptionArgument<Bool>
    |                        `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 23 |     var divideByOS: OptionArgument<Bool>
 24 |     var divideByTestRun: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:23:21: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 21 |
 22 |     var divideByModel: OptionArgument<Bool>
 23 |     var divideByOS: OptionArgument<Bool>
    |                     `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 24 |     var divideByTestRun: OptionArgument<Bool>
 25 |     var divideByTestPlanConfig: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:24:26: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 22 |     var divideByModel: OptionArgument<Bool>
 23 |     var divideByOS: OptionArgument<Bool>
 24 |     var divideByTestRun: OptionArgument<Bool>
    |                          `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 25 |     var divideByTestPlanConfig: OptionArgument<Bool>
 26 |     var divideByLanguage: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:25:33: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 23 |     var divideByOS: OptionArgument<Bool>
 24 |     var divideByTestRun: OptionArgument<Bool>
 25 |     var divideByTestPlanConfig: OptionArgument<Bool>
    |                                 `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 26 |     var divideByLanguage: OptionArgument<Bool>
 27 |     var divideByRegion: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:26:27: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 24 |     var divideByTestRun: OptionArgument<Bool>
 25 |     var divideByTestPlanConfig: OptionArgument<Bool>
 26 |     var divideByLanguage: OptionArgument<Bool>
    |                           `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 27 |     var divideByRegion: OptionArgument<Bool>
 28 |     var divideByTest: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:27:25: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 25 |     var divideByTestPlanConfig: OptionArgument<Bool>
 26 |     var divideByLanguage: OptionArgument<Bool>
 27 |     var divideByRegion: OptionArgument<Bool>
    |                         `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 28 |     var divideByTest: OptionArgument<Bool>
 29 |
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:28:23: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 26 |     var divideByLanguage: OptionArgument<Bool>
 27 |     var divideByRegion: OptionArgument<Bool>
 28 |     var divideByTest: OptionArgument<Bool>
    |                       `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 29 |
 30 |     var utiWhitelist: OptionArgument<[String]>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:30:23: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 28 |     var divideByTest: OptionArgument<Bool>
 29 |
 30 |     var utiWhitelist: OptionArgument<[String]>
    |                       `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 31 |     var activityTypeWhitelist: OptionArgument<[String]>
 32 |
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:31:32: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 29 |
 30 |     var utiWhitelist: OptionArgument<[String]>
 31 |     var activityTypeWhitelist: OptionArgument<[String]>
    |                                `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 32 |
 33 |     init(parser: ArgumentParser) {
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:33:18: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 31 |     var activityTypeWhitelist: OptionArgument<[String]>
 32 |
 33 |     init(parser: ArgumentParser) {
    |                  `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 34 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
 35 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:55:30: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 53 |     }
 54 |
 55 |     func run(with arguments: ArgumentParser.Result) throws {
    |                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 56 |         guard let xcresultPathArgument = arguments.get(path) else {
 57 |             print("Missing xcresult path")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:35:60: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 33 |     init(parser: ArgumentParser) {
 34 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
 35 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
    |                                                            `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 36 |                              optional: false, usage: "Path to the xcresult file", completion: .filename)
 37 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:37:73: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 35 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
 36 |                              optional: false, usage: "Path to the xcresult file", completion: .filename)
 37 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
    |                                                                         `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 38 |                                    optional: true, usage: "Folder to export results to", completion: .filename)
 39 |         verbose = subparser.add(option: "--verbose", shortName: "-v", kind: Bool.self, usage: "Enable verbose logging")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:39:29: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 37 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
 38 |                                    optional: true, usage: "Folder to export results to", completion: .filename)
 39 |         verbose = subparser.add(option: "--verbose", shortName: "-v", kind: Bool.self, usage: "Enable verbose logging")
    |                             `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 40 |
 41 |         divideByModel = subparser.add(option: "--model", shortName: nil, kind: Bool.self, usage: "Divide attachments by model")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:41:35: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 39 |         verbose = subparser.add(option: "--verbose", shortName: "-v", kind: Bool.self, usage: "Enable verbose logging")
 40 |
 41 |         divideByModel = subparser.add(option: "--model", shortName: nil, kind: Bool.self, usage: "Divide attachments by model")
    |                                   `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 42 |         divideByOS = subparser.add(option: "--os", shortName: nil, kind: Bool.self, usage: "Divide attachments by OS")
 43 |         divideByTestRun = subparser.add(option: "--test-run", shortName: nil, kind: Bool.self, usage: "Deprecated. Use --test-plan-config")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:42:32: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 40 |
 41 |         divideByModel = subparser.add(option: "--model", shortName: nil, kind: Bool.self, usage: "Divide attachments by model")
 42 |         divideByOS = subparser.add(option: "--os", shortName: nil, kind: Bool.self, usage: "Divide attachments by OS")
    |                                `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 43 |         divideByTestRun = subparser.add(option: "--test-run", shortName: nil, kind: Bool.self, usage: "Deprecated. Use --test-plan-config")
 44 |         divideByTestPlanConfig = subparser.add(option: "--test-plan-config", shortName: nil, kind: Bool.self, usage: "Divide attachments by test plan configuration")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:43:37: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 41 |         divideByModel = subparser.add(option: "--model", shortName: nil, kind: Bool.self, usage: "Divide attachments by model")
 42 |         divideByOS = subparser.add(option: "--os", shortName: nil, kind: Bool.self, usage: "Divide attachments by OS")
 43 |         divideByTestRun = subparser.add(option: "--test-run", shortName: nil, kind: Bool.self, usage: "Deprecated. Use --test-plan-config")
    |                                     `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 44 |         divideByTestPlanConfig = subparser.add(option: "--test-plan-config", shortName: nil, kind: Bool.self, usage: "Divide attachments by test plan configuration")
 45 |         divideByLanguage = subparser.add(option: "--language", shortName: nil, kind: Bool.self, usage: "Divide attachments by test language")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:44:44: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 42 |         divideByOS = subparser.add(option: "--os", shortName: nil, kind: Bool.self, usage: "Divide attachments by OS")
 43 |         divideByTestRun = subparser.add(option: "--test-run", shortName: nil, kind: Bool.self, usage: "Deprecated. Use --test-plan-config")
 44 |         divideByTestPlanConfig = subparser.add(option: "--test-plan-config", shortName: nil, kind: Bool.self, usage: "Divide attachments by test plan configuration")
    |                                            `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 45 |         divideByLanguage = subparser.add(option: "--language", shortName: nil, kind: Bool.self, usage: "Divide attachments by test language")
 46 |         divideByRegion = subparser.add(option: "--region", shortName: nil, kind: Bool.self, usage: "Divide attachments by test region")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:45:38: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 43 |         divideByTestRun = subparser.add(option: "--test-run", shortName: nil, kind: Bool.self, usage: "Deprecated. Use --test-plan-config")
 44 |         divideByTestPlanConfig = subparser.add(option: "--test-plan-config", shortName: nil, kind: Bool.self, usage: "Divide attachments by test plan configuration")
 45 |         divideByLanguage = subparser.add(option: "--language", shortName: nil, kind: Bool.self, usage: "Divide attachments by test language")
    |                                      `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 46 |         divideByRegion = subparser.add(option: "--region", shortName: nil, kind: Bool.self, usage: "Divide attachments by test region")
 47 |         divideByTest = subparser.add(option: "--test", shortName: nil, kind: Bool.self, usage: "Divide attachments by test")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:46:36: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 44 |         divideByTestPlanConfig = subparser.add(option: "--test-plan-config", shortName: nil, kind: Bool.self, usage: "Divide attachments by test plan configuration")
 45 |         divideByLanguage = subparser.add(option: "--language", shortName: nil, kind: Bool.self, usage: "Divide attachments by test language")
 46 |         divideByRegion = subparser.add(option: "--region", shortName: nil, kind: Bool.self, usage: "Divide attachments by test region")
    |                                    `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 47 |         divideByTest = subparser.add(option: "--test", shortName: nil, kind: Bool.self, usage: "Divide attachments by test")
 48 |
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:47:34: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 45 |         divideByLanguage = subparser.add(option: "--language", shortName: nil, kind: Bool.self, usage: "Divide attachments by test language")
 46 |         divideByRegion = subparser.add(option: "--region", shortName: nil, kind: Bool.self, usage: "Divide attachments by test region")
 47 |         divideByTest = subparser.add(option: "--test", shortName: nil, kind: Bool.self, usage: "Divide attachments by test")
    |                                  `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 48 |
 49 |         utiWhitelist = subparser.add(option: "--uti", shortName: nil, kind: [String].self, strategy: .upToNextOption,
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:49:34: warning: conformance of 'String' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 47 |         divideByTest = subparser.add(option: "--test", shortName: nil, kind: Bool.self, usage: "Divide attachments by test")
 48 |
 49 |         utiWhitelist = subparser.add(option: "--uti", shortName: nil, kind: [String].self, strategy: .upToNextOption,
    |                                  `- warning: conformance of 'String' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 50 |                                      usage: "Whitelist of uniform type identifiers (UTI) attachments must conform to [optional, example: \"--uti public.image public.plain-text\"]")
 51 |         activityTypeWhitelist = subparser.add(option: "--activity-type", shortName: nil, kind: [String].self, strategy: .upToNextOption,
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:51:43: warning: conformance of 'String' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 49 |         utiWhitelist = subparser.add(option: "--uti", shortName: nil, kind: [String].self, strategy: .upToNextOption,
 50 |                                      usage: "Whitelist of uniform type identifiers (UTI) attachments must conform to [optional, example: \"--uti public.image public.plain-text\"]")
 51 |         activityTypeWhitelist = subparser.add(option: "--activity-type", shortName: nil, kind: [String].self, strategy: .upToNextOption,
    |                                           `- warning: conformance of 'String' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 52 |                                               usage: "Whitelist of acceptable activity types for attachments. If value does not specify domain, \"com.apple.dt.xctest.activity-type.\" is assumed and prefixed to the value [optional, example: \"--activity-type userCreated attachmentContainer com.apple.dt.xctest.activity-type.testAssertionFailure\"]")
 53 |     }
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:93:24: error: cannot find 'UTTypeConformsTo' in scope
 91 |                 let attachmentUTI = $0.uniformTypeIdentifier as CFString
 92 |                 for allowedUTI in allowedUTIsToExport {
 93 |                     if UTTypeConformsTo(attachmentUTI, allowedUTI as CFString) {
    |                        `- error: cannot find 'UTTypeConformsTo' in scope
 94 |                         return true
 95 |                     }
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:91:65: error: cannot find type 'CFString' in scope
 89 |         if let allowedUTIsToExport = arguments.get(self.utiWhitelist) {
 90 |             options.attachmentFilter = {
 91 |                 let attachmentUTI = $0.uniformTypeIdentifier as CFString
    |                                                                 `- error: cannot find type 'CFString' in scope
 92 |                 for allowedUTI in allowedUTIsToExport {
 93 |                     if UTTypeConformsTo(attachmentUTI, allowedUTI as CFString) {
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:93:70: error: cannot find type 'CFString' in scope
 91 |                 let attachmentUTI = $0.uniformTypeIdentifier as CFString
 92 |                 for allowedUTI in allowedUTIsToExport {
 93 |                     if UTTypeConformsTo(attachmentUTI, allowedUTI as CFString) {
    |                                                                      `- error: cannot find type 'CFString' in scope
 94 |                         return true
 95 |                     }
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:18:15: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
17 |
18 |     var path: PositionalArgument<PathArgument>
   |               `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
19 |     var outputPath: PositionalArgument<PathArgument>
20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:18:34: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
17 |
18 |     var path: PositionalArgument<PathArgument>
   |                                  `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
19 |     var outputPath: PositionalArgument<PathArgument>
20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:19:21: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
17 |
18 |     var path: PositionalArgument<PathArgument>
19 |     var outputPath: PositionalArgument<PathArgument>
   |                     `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
20 |     var verbose: OptionArgument<Bool>
21 |
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:19:40: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
17 |
18 |     var path: PositionalArgument<PathArgument>
19 |     var outputPath: PositionalArgument<PathArgument>
   |                                        `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
20 |     var verbose: OptionArgument<Bool>
21 |
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:20:18: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
18 |     var path: PositionalArgument<PathArgument>
19 |     var outputPath: PositionalArgument<PathArgument>
20 |     var verbose: OptionArgument<Bool>
   |                  `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
21 |
22 |     init(parser: ArgumentParser) {
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:22:18: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
20 |     var verbose: OptionArgument<Bool>
21 |
22 |     init(parser: ArgumentParser) {
   |                  `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
23 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
24 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:31:30: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
29 |     }
30 |
31 |     func run(with arguments: ArgumentParser.Result) throws {
   |                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
32 |         guard let xcresultPathArgument = arguments.get(path) else {
33 |             print("Missing xcresult path")
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:24:60: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
22 |     init(parser: ArgumentParser) {
23 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
24 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
   |                                                            `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
25 |                              optional: false, usage: "Path to the xcresult file", completion: .filename)
26 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:26:73: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
24 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
25 |                              optional: false, usage: "Path to the xcresult file", completion: .filename)
26 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
   |                                                                         `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
27 |                                    optional: true, usage: "Folder to export results to", completion: .filename)
28 |         verbose = subparser.add(option: "--verbose", shortName: "-v", kind: Bool.self, usage: "Enable verbose logging")
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:28:29: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
26 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
27 |                                    optional: true, usage: "Folder to export results to", completion: .filename)
28 |         verbose = subparser.add(option: "--verbose", shortName: "-v", kind: Bool.self, usage: "Enable verbose logging")
   |                             `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
29 |     }
30 |
[205/215] Compiling xcparse CodeCoverageCommand.swift
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:18:15: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
 17 |
 18 |     var path: PositionalArgument<PathArgument>
    |               `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 19 |     var outputPath: PositionalArgument<PathArgument>
 20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:18:34: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
 17 |
 18 |     var path: PositionalArgument<PathArgument>
    |                                  `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 19 |     var outputPath: PositionalArgument<PathArgument>
 20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:19:21: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 17 |
 18 |     var path: PositionalArgument<PathArgument>
 19 |     var outputPath: PositionalArgument<PathArgument>
    |                     `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 20 |     var verbose: OptionArgument<Bool>
 21 |
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:19:40: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 17 |
 18 |     var path: PositionalArgument<PathArgument>
 19 |     var outputPath: PositionalArgument<PathArgument>
    |                                        `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 20 |     var verbose: OptionArgument<Bool>
 21 |
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:20:18: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 18 |     var path: PositionalArgument<PathArgument>
 19 |     var outputPath: PositionalArgument<PathArgument>
 20 |     var verbose: OptionArgument<Bool>
    |                  `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 21 |
 22 |     var divideByModel: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:22:24: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 20 |     var verbose: OptionArgument<Bool>
 21 |
 22 |     var divideByModel: OptionArgument<Bool>
    |                        `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 23 |     var divideByOS: OptionArgument<Bool>
 24 |     var divideByTestRun: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:23:21: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 21 |
 22 |     var divideByModel: OptionArgument<Bool>
 23 |     var divideByOS: OptionArgument<Bool>
    |                     `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 24 |     var divideByTestRun: OptionArgument<Bool>
 25 |     var divideByTestPlanConfig: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:24:26: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 22 |     var divideByModel: OptionArgument<Bool>
 23 |     var divideByOS: OptionArgument<Bool>
 24 |     var divideByTestRun: OptionArgument<Bool>
    |                          `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 25 |     var divideByTestPlanConfig: OptionArgument<Bool>
 26 |     var divideByLanguage: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:25:33: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 23 |     var divideByOS: OptionArgument<Bool>
 24 |     var divideByTestRun: OptionArgument<Bool>
 25 |     var divideByTestPlanConfig: OptionArgument<Bool>
    |                                 `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 26 |     var divideByLanguage: OptionArgument<Bool>
 27 |     var divideByRegion: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:26:27: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 24 |     var divideByTestRun: OptionArgument<Bool>
 25 |     var divideByTestPlanConfig: OptionArgument<Bool>
 26 |     var divideByLanguage: OptionArgument<Bool>
    |                           `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 27 |     var divideByRegion: OptionArgument<Bool>
 28 |     var divideByTest: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:27:25: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 25 |     var divideByTestPlanConfig: OptionArgument<Bool>
 26 |     var divideByLanguage: OptionArgument<Bool>
 27 |     var divideByRegion: OptionArgument<Bool>
    |                         `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 28 |     var divideByTest: OptionArgument<Bool>
 29 |
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:28:23: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 26 |     var divideByLanguage: OptionArgument<Bool>
 27 |     var divideByRegion: OptionArgument<Bool>
 28 |     var divideByTest: OptionArgument<Bool>
    |                       `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 29 |
 30 |     var utiWhitelist: OptionArgument<[String]>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:30:23: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 28 |     var divideByTest: OptionArgument<Bool>
 29 |
 30 |     var utiWhitelist: OptionArgument<[String]>
    |                       `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 31 |     var activityTypeWhitelist: OptionArgument<[String]>
 32 |
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:31:32: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 29 |
 30 |     var utiWhitelist: OptionArgument<[String]>
 31 |     var activityTypeWhitelist: OptionArgument<[String]>
    |                                `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 32 |
 33 |     init(parser: ArgumentParser) {
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:33:18: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 31 |     var activityTypeWhitelist: OptionArgument<[String]>
 32 |
 33 |     init(parser: ArgumentParser) {
    |                  `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 34 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
 35 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:55:30: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 53 |     }
 54 |
 55 |     func run(with arguments: ArgumentParser.Result) throws {
    |                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 56 |         guard let xcresultPathArgument = arguments.get(path) else {
 57 |             print("Missing xcresult path")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:35:60: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 33 |     init(parser: ArgumentParser) {
 34 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
 35 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
    |                                                            `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 36 |                              optional: false, usage: "Path to the xcresult file", completion: .filename)
 37 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:37:73: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 35 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
 36 |                              optional: false, usage: "Path to the xcresult file", completion: .filename)
 37 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
    |                                                                         `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 38 |                                    optional: true, usage: "Folder to export results to", completion: .filename)
 39 |         verbose = subparser.add(option: "--verbose", shortName: "-v", kind: Bool.self, usage: "Enable verbose logging")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:39:29: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 37 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
 38 |                                    optional: true, usage: "Folder to export results to", completion: .filename)
 39 |         verbose = subparser.add(option: "--verbose", shortName: "-v", kind: Bool.self, usage: "Enable verbose logging")
    |                             `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 40 |
 41 |         divideByModel = subparser.add(option: "--model", shortName: nil, kind: Bool.self, usage: "Divide attachments by model")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:41:35: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 39 |         verbose = subparser.add(option: "--verbose", shortName: "-v", kind: Bool.self, usage: "Enable verbose logging")
 40 |
 41 |         divideByModel = subparser.add(option: "--model", shortName: nil, kind: Bool.self, usage: "Divide attachments by model")
    |                                   `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 42 |         divideByOS = subparser.add(option: "--os", shortName: nil, kind: Bool.self, usage: "Divide attachments by OS")
 43 |         divideByTestRun = subparser.add(option: "--test-run", shortName: nil, kind: Bool.self, usage: "Deprecated. Use --test-plan-config")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:42:32: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 40 |
 41 |         divideByModel = subparser.add(option: "--model", shortName: nil, kind: Bool.self, usage: "Divide attachments by model")
 42 |         divideByOS = subparser.add(option: "--os", shortName: nil, kind: Bool.self, usage: "Divide attachments by OS")
    |                                `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 43 |         divideByTestRun = subparser.add(option: "--test-run", shortName: nil, kind: Bool.self, usage: "Deprecated. Use --test-plan-config")
 44 |         divideByTestPlanConfig = subparser.add(option: "--test-plan-config", shortName: nil, kind: Bool.self, usage: "Divide attachments by test plan configuration")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:43:37: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 41 |         divideByModel = subparser.add(option: "--model", shortName: nil, kind: Bool.self, usage: "Divide attachments by model")
 42 |         divideByOS = subparser.add(option: "--os", shortName: nil, kind: Bool.self, usage: "Divide attachments by OS")
 43 |         divideByTestRun = subparser.add(option: "--test-run", shortName: nil, kind: Bool.self, usage: "Deprecated. Use --test-plan-config")
    |                                     `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 44 |         divideByTestPlanConfig = subparser.add(option: "--test-plan-config", shortName: nil, kind: Bool.self, usage: "Divide attachments by test plan configuration")
 45 |         divideByLanguage = subparser.add(option: "--language", shortName: nil, kind: Bool.self, usage: "Divide attachments by test language")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:44:44: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 42 |         divideByOS = subparser.add(option: "--os", shortName: nil, kind: Bool.self, usage: "Divide attachments by OS")
 43 |         divideByTestRun = subparser.add(option: "--test-run", shortName: nil, kind: Bool.self, usage: "Deprecated. Use --test-plan-config")
 44 |         divideByTestPlanConfig = subparser.add(option: "--test-plan-config", shortName: nil, kind: Bool.self, usage: "Divide attachments by test plan configuration")
    |                                            `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 45 |         divideByLanguage = subparser.add(option: "--language", shortName: nil, kind: Bool.self, usage: "Divide attachments by test language")
 46 |         divideByRegion = subparser.add(option: "--region", shortName: nil, kind: Bool.self, usage: "Divide attachments by test region")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:45:38: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 43 |         divideByTestRun = subparser.add(option: "--test-run", shortName: nil, kind: Bool.self, usage: "Deprecated. Use --test-plan-config")
 44 |         divideByTestPlanConfig = subparser.add(option: "--test-plan-config", shortName: nil, kind: Bool.self, usage: "Divide attachments by test plan configuration")
 45 |         divideByLanguage = subparser.add(option: "--language", shortName: nil, kind: Bool.self, usage: "Divide attachments by test language")
    |                                      `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 46 |         divideByRegion = subparser.add(option: "--region", shortName: nil, kind: Bool.self, usage: "Divide attachments by test region")
 47 |         divideByTest = subparser.add(option: "--test", shortName: nil, kind: Bool.self, usage: "Divide attachments by test")
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:46:36: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 44 |         divideByTestPlanConfig = subparser.add(option: "--test-plan-config", shortName: nil, kind: Bool.self, usage: "Divide attachments by test plan configuration")
 45 |         divideByLanguage = subparser.add(option: "--language", shortName: nil, kind: Bool.self, usage: "Divide attachments by test language")
 46 |         divideByRegion = subparser.add(option: "--region", shortName: nil, kind: Bool.self, usage: "Divide attachments by test region")
    |                                    `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 47 |         divideByTest = subparser.add(option: "--test", shortName: nil, kind: Bool.self, usage: "Divide attachments by test")
 48 |
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:47:34: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 45 |         divideByLanguage = subparser.add(option: "--language", shortName: nil, kind: Bool.self, usage: "Divide attachments by test language")
 46 |         divideByRegion = subparser.add(option: "--region", shortName: nil, kind: Bool.self, usage: "Divide attachments by test region")
 47 |         divideByTest = subparser.add(option: "--test", shortName: nil, kind: Bool.self, usage: "Divide attachments by test")
    |                                  `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 48 |
 49 |         utiWhitelist = subparser.add(option: "--uti", shortName: nil, kind: [String].self, strategy: .upToNextOption,
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:49:34: warning: conformance of 'String' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 47 |         divideByTest = subparser.add(option: "--test", shortName: nil, kind: Bool.self, usage: "Divide attachments by test")
 48 |
 49 |         utiWhitelist = subparser.add(option: "--uti", shortName: nil, kind: [String].self, strategy: .upToNextOption,
    |                                  `- warning: conformance of 'String' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 50 |                                      usage: "Whitelist of uniform type identifiers (UTI) attachments must conform to [optional, example: \"--uti public.image public.plain-text\"]")
 51 |         activityTypeWhitelist = subparser.add(option: "--activity-type", shortName: nil, kind: [String].self, strategy: .upToNextOption,
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:51:43: warning: conformance of 'String' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 49 |         utiWhitelist = subparser.add(option: "--uti", shortName: nil, kind: [String].self, strategy: .upToNextOption,
 50 |                                      usage: "Whitelist of uniform type identifiers (UTI) attachments must conform to [optional, example: \"--uti public.image public.plain-text\"]")
 51 |         activityTypeWhitelist = subparser.add(option: "--activity-type", shortName: nil, kind: [String].self, strategy: .upToNextOption,
    |                                           `- warning: conformance of 'String' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 52 |                                               usage: "Whitelist of acceptable activity types for attachments. If value does not specify domain, \"com.apple.dt.xctest.activity-type.\" is assumed and prefixed to the value [optional, example: \"--activity-type userCreated attachmentContainer com.apple.dt.xctest.activity-type.testAssertionFailure\"]")
 53 |     }
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:93:24: error: cannot find 'UTTypeConformsTo' in scope
 91 |                 let attachmentUTI = $0.uniformTypeIdentifier as CFString
 92 |                 for allowedUTI in allowedUTIsToExport {
 93 |                     if UTTypeConformsTo(attachmentUTI, allowedUTI as CFString) {
    |                        `- error: cannot find 'UTTypeConformsTo' in scope
 94 |                         return true
 95 |                     }
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:91:65: error: cannot find type 'CFString' in scope
 89 |         if let allowedUTIsToExport = arguments.get(self.utiWhitelist) {
 90 |             options.attachmentFilter = {
 91 |                 let attachmentUTI = $0.uniformTypeIdentifier as CFString
    |                                                                 `- error: cannot find type 'CFString' in scope
 92 |                 for allowedUTI in allowedUTIsToExport {
 93 |                     if UTTypeConformsTo(attachmentUTI, allowedUTI as CFString) {
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:93:70: error: cannot find type 'CFString' in scope
 91 |                 let attachmentUTI = $0.uniformTypeIdentifier as CFString
 92 |                 for allowedUTI in allowedUTIsToExport {
 93 |                     if UTTypeConformsTo(attachmentUTI, allowedUTI as CFString) {
    |                                                                      `- error: cannot find type 'CFString' in scope
 94 |                         return true
 95 |                     }
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:18:15: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
17 |
18 |     var path: PositionalArgument<PathArgument>
   |               `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
19 |     var outputPath: PositionalArgument<PathArgument>
20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:18:34: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
17 |
18 |     var path: PositionalArgument<PathArgument>
   |                                  `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
19 |     var outputPath: PositionalArgument<PathArgument>
20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:19:21: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
17 |
18 |     var path: PositionalArgument<PathArgument>
19 |     var outputPath: PositionalArgument<PathArgument>
   |                     `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
20 |     var verbose: OptionArgument<Bool>
21 |
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:19:40: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
17 |
18 |     var path: PositionalArgument<PathArgument>
19 |     var outputPath: PositionalArgument<PathArgument>
   |                                        `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
20 |     var verbose: OptionArgument<Bool>
21 |
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:20:18: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
18 |     var path: PositionalArgument<PathArgument>
19 |     var outputPath: PositionalArgument<PathArgument>
20 |     var verbose: OptionArgument<Bool>
   |                  `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
21 |
22 |     init(parser: ArgumentParser) {
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:22:18: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
20 |     var verbose: OptionArgument<Bool>
21 |
22 |     init(parser: ArgumentParser) {
   |                  `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
23 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
24 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:31:30: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
29 |     }
30 |
31 |     func run(with arguments: ArgumentParser.Result) throws {
   |                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
32 |         guard let xcresultPathArgument = arguments.get(path) else {
33 |             print("Missing xcresult path")
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:24:60: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
22 |     init(parser: ArgumentParser) {
23 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
24 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
   |                                                            `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
25 |                              optional: false, usage: "Path to the xcresult file", completion: .filename)
26 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:26:73: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
24 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
25 |                              optional: false, usage: "Path to the xcresult file", completion: .filename)
26 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
   |                                                                         `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
27 |                                    optional: true, usage: "Folder to export results to", completion: .filename)
28 |         verbose = subparser.add(option: "--verbose", shortName: "-v", kind: Bool.self, usage: "Enable verbose logging")
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:28:29: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
26 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
27 |                                    optional: true, usage: "Folder to export results to", completion: .filename)
28 |         verbose = subparser.add(option: "--verbose", shortName: "-v", kind: Bool.self, usage: "Enable verbose logging")
   |                             `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
29 |     }
30 |
[206/215] Compiling xcparse Command.swift
/host/spi-builder-workspace/Sources/xcparse/Command.swift:19:18: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
17 |     var usage: String { get }
18 |
19 |     init(parser: ArgumentParser)
   |                  `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
20 |     func run(with arguments: ArgumentParser.Result) throws
21 | }
/host/spi-builder-workspace/Sources/xcparse/Command.swift:20:30: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
18 |
19 |     init(parser: ArgumentParser)
20 |     func run(with arguments: ArgumentParser.Result) throws
   |                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
21 | }
22 |
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:16:25: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 14 | // https://www.enekoalonso.com/articles/handling-commands-with-swift-package-manager
 15 | struct CommandRegistry {
 16 |     private let parser: ArgumentParser
    |                         `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 17 |     private var commands: [Command] = []
 18 |
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:19:36: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 17 |     private var commands: [Command] = []
 18 |
 19 |     private var legacyScreenshots: OptionArgument<[PathArgument]>
    |                                    `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 20 |     private var legacyXcov: OptionArgument<[PathArgument]>
 21 |
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:19:52: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 17 |     private var commands: [Command] = []
 18 |
 19 |     private var legacyScreenshots: OptionArgument<[PathArgument]>
    |                                                    `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 20 |     private var legacyXcov: OptionArgument<[PathArgument]>
 21 |
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:20:29: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 18 |
 19 |     private var legacyScreenshots: OptionArgument<[PathArgument]>
 20 |     private var legacyXcov: OptionArgument<[PathArgument]>
    |                             `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 21 |
 22 |     init(usage: String, overview: String) {
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:20:45: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 18 |
 19 |     private var legacyScreenshots: OptionArgument<[PathArgument]>
 20 |     private var legacyXcov: OptionArgument<[PathArgument]>
    |                                             `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 21 |
 22 |     init(usage: String, overview: String) {
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:48:100: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 46 |     }
 47 |
 48 |     private func parse(_ arguments: [String] = Array(CommandLine.arguments.dropFirst())) throws -> ArgumentParser.Result {
    |                                                                                                    `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 49 |         return try parser.parse(arguments)
 50 |     }
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:52:60: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 50 |     }
 51 |
 52 |     private func processLegacyScreenshotCommand(arguments: ArgumentParser.Result) -> Bool {
    |                                                            `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 53 |         guard let legacyScreenshotPaths = arguments.get(self.legacyScreenshots) else {
 54 |             return false
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:85:62: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 83 |     }
 84 |
 85 |     private func processLegacyCodeCoverageCommand(arguments: ArgumentParser.Result) -> Bool {
    |                                                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 86 |         guard let legacyCodeCovPaths = arguments.get(self.legacyXcov) else {
 87 |             return false
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:105:37: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
103 |     }
104 |
105 |     private func process(arguments: ArgumentParser.Result) throws {
    |                                     `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
106 |         // Check to see if it's a legacy command
107 |         if self.processLegacyScreenshotCommand(arguments: arguments) == true {
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:23:18: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 21 |
 22 |     init(usage: String, overview: String) {
 23 |         parser = ArgumentParser(usage: usage, overview: overview)
    |                  `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 24 |
 25 |         legacyScreenshots = parser.add(option: "--screenshots", shortName: "-s", kind: [PathArgument].self,
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:25:89: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 23 |         parser = ArgumentParser(usage: usage, overview: overview)
 24 |
 25 |         legacyScreenshots = parser.add(option: "--screenshots", shortName: "-s", kind: [PathArgument].self,
    |                                                                                         `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 26 |                                        strategy: .upToNextOption, usage: "Legacy screenshots command. Use \"screenshots\" subcommand instead.", completion: .filename)
 27 |         legacyXcov = parser.add(option: "--xcov", shortName: "-x", kind: [PathArgument].self,
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:27:75: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 25 |         legacyScreenshots = parser.add(option: "--screenshots", shortName: "-s", kind: [PathArgument].self,
 26 |                                        strategy: .upToNextOption, usage: "Legacy screenshots command. Use \"screenshots\" subcommand instead.", completion: .filename)
 27 |         legacyXcov = parser.add(option: "--xcov", shortName: "-x", kind: [PathArgument].self,
    |                                                                           `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 28 |                                 strategy: .upToNextOption, usage: "Legacy code coverage command. Use \"codecov\" subcommand instead.", completion: .filename)
 29 |     }
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:41:25: warning: 'description' is deprecated: use swift-argument-parser instead
 39 |         }
 40 |         catch let error as ArgumentParserError {
 41 |             print(error.description)
    |                         `- warning: 'description' is deprecated: use swift-argument-parser instead
 42 |         }
 43 |         catch let error {
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:40:28: warning: 'ArgumentParserError' is deprecated: use swift-argument-parser instead
 38 |             try process(arguments: parsedArguments)
 39 |         }
 40 |         catch let error as ArgumentParserError {
    |                            `- warning: 'ArgumentParserError' is deprecated: use swift-argument-parser instead
 41 |             print(error.description)
 42 |         }
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:40:28: warning: 'ArgumentParserError' is deprecated: use swift-argument-parser instead
 38 |             try process(arguments: parsedArguments)
 39 |         }
 40 |         catch let error as ArgumentParserError {
    |                            `- warning: 'ArgumentParserError' is deprecated: use swift-argument-parser instead
 41 |             print(error.description)
 42 |         }
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:73:60: error: cannot find 'UTTypeConformsTo' in scope
 71 |                                                   xcresulttoolCompatability: xcresulttoolCompatability,
 72 |                                                   attachmentFilter: {
 73 |                                                     return UTTypeConformsTo($0.uniformTypeIdentifier as CFString, "public.image" as CFString)
    |                                                            `- error: cannot find 'UTTypeConformsTo' in scope
 74 |             })
 75 |             try xcpParser.extractAttachments(xcresultPath: legacyScreenshotPaths[0].path.pathString,
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:73:105: error: cannot find type 'CFString' in scope
 71 |                                                   xcresulttoolCompatability: xcresulttoolCompatability,
 72 |                                                   attachmentFilter: {
 73 |                                                     return UTTypeConformsTo($0.uniformTypeIdentifier as CFString, "public.image" as CFString)
    |                                                                                                         `- error: cannot find type 'CFString' in scope
 74 |             })
 75 |             try xcpParser.extractAttachments(xcresultPath: legacyScreenshotPaths[0].path.pathString,
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:73:133: error: cannot find type 'CFString' in scope
 71 |                                                   xcresulttoolCompatability: xcresulttoolCompatability,
 72 |                                                   attachmentFilter: {
 73 |                                                     return UTTypeConformsTo($0.uniformTypeIdentifier as CFString, "public.image" as CFString)
    |                                                                                                                                     `- error: cannot find type 'CFString' in scope
 74 |             })
 75 |             try xcpParser.extractAttachments(xcresultPath: legacyScreenshotPaths[0].path.pathString,
[207/215] Compiling xcparse CommandRegistry.swift
/host/spi-builder-workspace/Sources/xcparse/Command.swift:19:18: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
17 |     var usage: String { get }
18 |
19 |     init(parser: ArgumentParser)
   |                  `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
20 |     func run(with arguments: ArgumentParser.Result) throws
21 | }
/host/spi-builder-workspace/Sources/xcparse/Command.swift:20:30: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
18 |
19 |     init(parser: ArgumentParser)
20 |     func run(with arguments: ArgumentParser.Result) throws
   |                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
21 | }
22 |
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:16:25: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 14 | // https://www.enekoalonso.com/articles/handling-commands-with-swift-package-manager
 15 | struct CommandRegistry {
 16 |     private let parser: ArgumentParser
    |                         `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 17 |     private var commands: [Command] = []
 18 |
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:19:36: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 17 |     private var commands: [Command] = []
 18 |
 19 |     private var legacyScreenshots: OptionArgument<[PathArgument]>
    |                                    `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 20 |     private var legacyXcov: OptionArgument<[PathArgument]>
 21 |
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:19:52: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 17 |     private var commands: [Command] = []
 18 |
 19 |     private var legacyScreenshots: OptionArgument<[PathArgument]>
    |                                                    `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 20 |     private var legacyXcov: OptionArgument<[PathArgument]>
 21 |
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:20:29: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 18 |
 19 |     private var legacyScreenshots: OptionArgument<[PathArgument]>
 20 |     private var legacyXcov: OptionArgument<[PathArgument]>
    |                             `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 21 |
 22 |     init(usage: String, overview: String) {
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:20:45: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 18 |
 19 |     private var legacyScreenshots: OptionArgument<[PathArgument]>
 20 |     private var legacyXcov: OptionArgument<[PathArgument]>
    |                                             `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 21 |
 22 |     init(usage: String, overview: String) {
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:48:100: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 46 |     }
 47 |
 48 |     private func parse(_ arguments: [String] = Array(CommandLine.arguments.dropFirst())) throws -> ArgumentParser.Result {
    |                                                                                                    `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 49 |         return try parser.parse(arguments)
 50 |     }
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:52:60: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 50 |     }
 51 |
 52 |     private func processLegacyScreenshotCommand(arguments: ArgumentParser.Result) -> Bool {
    |                                                            `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 53 |         guard let legacyScreenshotPaths = arguments.get(self.legacyScreenshots) else {
 54 |             return false
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:85:62: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 83 |     }
 84 |
 85 |     private func processLegacyCodeCoverageCommand(arguments: ArgumentParser.Result) -> Bool {
    |                                                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 86 |         guard let legacyCodeCovPaths = arguments.get(self.legacyXcov) else {
 87 |             return false
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:105:37: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
103 |     }
104 |
105 |     private func process(arguments: ArgumentParser.Result) throws {
    |                                     `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
106 |         // Check to see if it's a legacy command
107 |         if self.processLegacyScreenshotCommand(arguments: arguments) == true {
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:23:18: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 21 |
 22 |     init(usage: String, overview: String) {
 23 |         parser = ArgumentParser(usage: usage, overview: overview)
    |                  `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 24 |
 25 |         legacyScreenshots = parser.add(option: "--screenshots", shortName: "-s", kind: [PathArgument].self,
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:25:89: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 23 |         parser = ArgumentParser(usage: usage, overview: overview)
 24 |
 25 |         legacyScreenshots = parser.add(option: "--screenshots", shortName: "-s", kind: [PathArgument].self,
    |                                                                                         `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 26 |                                        strategy: .upToNextOption, usage: "Legacy screenshots command. Use \"screenshots\" subcommand instead.", completion: .filename)
 27 |         legacyXcov = parser.add(option: "--xcov", shortName: "-x", kind: [PathArgument].self,
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:27:75: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 25 |         legacyScreenshots = parser.add(option: "--screenshots", shortName: "-s", kind: [PathArgument].self,
 26 |                                        strategy: .upToNextOption, usage: "Legacy screenshots command. Use \"screenshots\" subcommand instead.", completion: .filename)
 27 |         legacyXcov = parser.add(option: "--xcov", shortName: "-x", kind: [PathArgument].self,
    |                                                                           `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 28 |                                 strategy: .upToNextOption, usage: "Legacy code coverage command. Use \"codecov\" subcommand instead.", completion: .filename)
 29 |     }
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:41:25: warning: 'description' is deprecated: use swift-argument-parser instead
 39 |         }
 40 |         catch let error as ArgumentParserError {
 41 |             print(error.description)
    |                         `- warning: 'description' is deprecated: use swift-argument-parser instead
 42 |         }
 43 |         catch let error {
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:40:28: warning: 'ArgumentParserError' is deprecated: use swift-argument-parser instead
 38 |             try process(arguments: parsedArguments)
 39 |         }
 40 |         catch let error as ArgumentParserError {
    |                            `- warning: 'ArgumentParserError' is deprecated: use swift-argument-parser instead
 41 |             print(error.description)
 42 |         }
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:40:28: warning: 'ArgumentParserError' is deprecated: use swift-argument-parser instead
 38 |             try process(arguments: parsedArguments)
 39 |         }
 40 |         catch let error as ArgumentParserError {
    |                            `- warning: 'ArgumentParserError' is deprecated: use swift-argument-parser instead
 41 |             print(error.description)
 42 |         }
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:73:60: error: cannot find 'UTTypeConformsTo' in scope
 71 |                                                   xcresulttoolCompatability: xcresulttoolCompatability,
 72 |                                                   attachmentFilter: {
 73 |                                                     return UTTypeConformsTo($0.uniformTypeIdentifier as CFString, "public.image" as CFString)
    |                                                            `- error: cannot find 'UTTypeConformsTo' in scope
 74 |             })
 75 |             try xcpParser.extractAttachments(xcresultPath: legacyScreenshotPaths[0].path.pathString,
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:73:105: error: cannot find type 'CFString' in scope
 71 |                                                   xcresulttoolCompatability: xcresulttoolCompatability,
 72 |                                                   attachmentFilter: {
 73 |                                                     return UTTypeConformsTo($0.uniformTypeIdentifier as CFString, "public.image" as CFString)
    |                                                                                                         `- error: cannot find type 'CFString' in scope
 74 |             })
 75 |             try xcpParser.extractAttachments(xcresultPath: legacyScreenshotPaths[0].path.pathString,
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:73:133: error: cannot find type 'CFString' in scope
 71 |                                                   xcresulttoolCompatability: xcresulttoolCompatability,
 72 |                                                   attachmentFilter: {
 73 |                                                     return UTTypeConformsTo($0.uniformTypeIdentifier as CFString, "public.image" as CFString)
    |                                                                                                                                     `- error: cannot find type 'CFString' in scope
 74 |             })
 75 |             try xcpParser.extractAttachments(xcresultPath: legacyScreenshotPaths[0].path.pathString,
[208/216] Compiling xcparse LogsCommand.swift
/host/spi-builder-workspace/Sources/xcparse/LogsCommand.swift:18:15: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
17 |
18 |     var path: PositionalArgument<PathArgument>
   |               `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
19 |     var outputPath: PositionalArgument<PathArgument>
20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/LogsCommand.swift:18:34: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
17 |
18 |     var path: PositionalArgument<PathArgument>
   |                                  `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
19 |     var outputPath: PositionalArgument<PathArgument>
20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/LogsCommand.swift:19:21: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
17 |
18 |     var path: PositionalArgument<PathArgument>
19 |     var outputPath: PositionalArgument<PathArgument>
   |                     `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
20 |     var verbose: OptionArgument<Bool>
21 |
/host/spi-builder-workspace/Sources/xcparse/LogsCommand.swift:19:40: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
17 |
18 |     var path: PositionalArgument<PathArgument>
19 |     var outputPath: PositionalArgument<PathArgument>
   |                                        `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
20 |     var verbose: OptionArgument<Bool>
21 |
/host/spi-builder-workspace/Sources/xcparse/LogsCommand.swift:20:18: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
18 |     var path: PositionalArgument<PathArgument>
19 |     var outputPath: PositionalArgument<PathArgument>
20 |     var verbose: OptionArgument<Bool>
   |                  `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
21 |
22 |     init(parser: ArgumentParser) {
/host/spi-builder-workspace/Sources/xcparse/LogsCommand.swift:22:18: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
20 |     var verbose: OptionArgument<Bool>
21 |
22 |     init(parser: ArgumentParser) {
   |                  `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
23 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
24 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
/host/spi-builder-workspace/Sources/xcparse/LogsCommand.swift:31:30: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
29 |     }
30 |
31 |     func run(with arguments: ArgumentParser.Result) throws {
   |                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
32 |         guard let xcresultPathArgument = arguments.get(path) else {
33 |             print("Missing xcresult path")
/host/spi-builder-workspace/Sources/xcparse/LogsCommand.swift:24:60: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
22 |     init(parser: ArgumentParser) {
23 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
24 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
   |                                                            `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
25 |                              optional: false, usage: "Path to the xcresult file", completion: .filename)
26 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
/host/spi-builder-workspace/Sources/xcparse/LogsCommand.swift:26:73: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
24 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
25 |                              optional: false, usage: "Path to the xcresult file", completion: .filename)
26 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
   |                                                                         `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
27 |                                    optional: true, usage: "Folder to export results to", completion: .filename)
28 |         verbose = subparser.add(option: "--verbose", shortName: "-v", kind: Bool.self, usage: "Enable verbose logging")
/host/spi-builder-workspace/Sources/xcparse/LogsCommand.swift:28:29: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
26 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
27 |                                    optional: true, usage: "Folder to export results to", completion: .filename)
28 |         verbose = subparser.add(option: "--verbose", shortName: "-v", kind: Bool.self, usage: "Enable verbose logging")
   |                             `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
29 |     }
30 |
[209/216] Compiling xcparse VersionCommand.swift
/host/spi-builder-workspace/Sources/xcparse/VersionCommand.swift:18:18: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
16 |     let usage = ""
17 |
18 |     init(parser: ArgumentParser) {
   |                  `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
19 |         _ = parser.add(subparser: command, usage: usage, overview: overview)
20 |     }
/host/spi-builder-workspace/Sources/xcparse/VersionCommand.swift:22:30: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
20 |     }
21 |
22 |     func run(with arguments: ArgumentParser.Result) throws {
   |                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
23 |         let xcpParser = XCPParser()
24 |         xcpParser.printVersion()
[210/216] Emitting module xcparse
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:18:15: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
 17 |
 18 |     var path: PositionalArgument<PathArgument>
    |               `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 19 |     var outputPath: PositionalArgument<PathArgument>
 20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:18:34: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
 17 |
 18 |     var path: PositionalArgument<PathArgument>
    |                                  `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 19 |     var outputPath: PositionalArgument<PathArgument>
 20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:19:21: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 17 |
 18 |     var path: PositionalArgument<PathArgument>
 19 |     var outputPath: PositionalArgument<PathArgument>
    |                     `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 20 |     var verbose: OptionArgument<Bool>
 21 |
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:19:40: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 17 |
 18 |     var path: PositionalArgument<PathArgument>
 19 |     var outputPath: PositionalArgument<PathArgument>
    |                                        `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 20 |     var verbose: OptionArgument<Bool>
 21 |
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:20:18: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 18 |     var path: PositionalArgument<PathArgument>
 19 |     var outputPath: PositionalArgument<PathArgument>
 20 |     var verbose: OptionArgument<Bool>
    |                  `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 21 |
 22 |     var divideByModel: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:22:24: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 20 |     var verbose: OptionArgument<Bool>
 21 |
 22 |     var divideByModel: OptionArgument<Bool>
    |                        `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 23 |     var divideByOS: OptionArgument<Bool>
 24 |     var divideByTestRun: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:23:21: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 21 |
 22 |     var divideByModel: OptionArgument<Bool>
 23 |     var divideByOS: OptionArgument<Bool>
    |                     `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 24 |     var divideByTestRun: OptionArgument<Bool>
 25 |     var divideByTestPlanConfig: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:24:26: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 22 |     var divideByModel: OptionArgument<Bool>
 23 |     var divideByOS: OptionArgument<Bool>
 24 |     var divideByTestRun: OptionArgument<Bool>
    |                          `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 25 |     var divideByTestPlanConfig: OptionArgument<Bool>
 26 |     var divideByLanguage: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:25:33: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 23 |     var divideByOS: OptionArgument<Bool>
 24 |     var divideByTestRun: OptionArgument<Bool>
 25 |     var divideByTestPlanConfig: OptionArgument<Bool>
    |                                 `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 26 |     var divideByLanguage: OptionArgument<Bool>
 27 |     var divideByRegion: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:26:27: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 24 |     var divideByTestRun: OptionArgument<Bool>
 25 |     var divideByTestPlanConfig: OptionArgument<Bool>
 26 |     var divideByLanguage: OptionArgument<Bool>
    |                           `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 27 |     var divideByRegion: OptionArgument<Bool>
 28 |     var divideByTest: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:27:25: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 25 |     var divideByTestPlanConfig: OptionArgument<Bool>
 26 |     var divideByLanguage: OptionArgument<Bool>
 27 |     var divideByRegion: OptionArgument<Bool>
    |                         `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 28 |     var divideByTest: OptionArgument<Bool>
 29 |
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:28:23: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 26 |     var divideByLanguage: OptionArgument<Bool>
 27 |     var divideByRegion: OptionArgument<Bool>
 28 |     var divideByTest: OptionArgument<Bool>
    |                       `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 29 |
 30 |     var utiWhitelist: OptionArgument<[String]>
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:30:23: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 28 |     var divideByTest: OptionArgument<Bool>
 29 |
 30 |     var utiWhitelist: OptionArgument<[String]>
    |                       `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 31 |     var activityTypeWhitelist: OptionArgument<[String]>
 32 |
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:31:32: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 29 |
 30 |     var utiWhitelist: OptionArgument<[String]>
 31 |     var activityTypeWhitelist: OptionArgument<[String]>
    |                                `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 32 |
 33 |     init(parser: ArgumentParser) {
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:33:18: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 31 |     var activityTypeWhitelist: OptionArgument<[String]>
 32 |
 33 |     init(parser: ArgumentParser) {
    |                  `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 34 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
 35 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
/host/spi-builder-workspace/Sources/xcparse/AttachmentsCommand.swift:55:30: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 53 |     }
 54 |
 55 |     func run(with arguments: ArgumentParser.Result) throws {
    |                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 56 |         guard let xcresultPathArgument = arguments.get(path) else {
 57 |             print("Missing xcresult path")
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:18:15: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
17 |
18 |     var path: PositionalArgument<PathArgument>
   |               `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
19 |     var outputPath: PositionalArgument<PathArgument>
20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:18:34: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
17 |
18 |     var path: PositionalArgument<PathArgument>
   |                                  `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
19 |     var outputPath: PositionalArgument<PathArgument>
20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:19:21: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
17 |
18 |     var path: PositionalArgument<PathArgument>
19 |     var outputPath: PositionalArgument<PathArgument>
   |                     `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
20 |     var verbose: OptionArgument<Bool>
21 |
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:19:40: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
17 |
18 |     var path: PositionalArgument<PathArgument>
19 |     var outputPath: PositionalArgument<PathArgument>
   |                                        `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
20 |     var verbose: OptionArgument<Bool>
21 |
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:20:18: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
18 |     var path: PositionalArgument<PathArgument>
19 |     var outputPath: PositionalArgument<PathArgument>
20 |     var verbose: OptionArgument<Bool>
   |                  `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
21 |
22 |     init(parser: ArgumentParser) {
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:22:18: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
20 |     var verbose: OptionArgument<Bool>
21 |
22 |     init(parser: ArgumentParser) {
   |                  `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
23 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
24 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
/host/spi-builder-workspace/Sources/xcparse/CodeCoverageCommand.swift:31:30: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
29 |     }
30 |
31 |     func run(with arguments: ArgumentParser.Result) throws {
   |                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
32 |         guard let xcresultPathArgument = arguments.get(path) else {
33 |             print("Missing xcresult path")
/host/spi-builder-workspace/Sources/xcparse/Command.swift:19:18: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
17 |     var usage: String { get }
18 |
19 |     init(parser: ArgumentParser)
   |                  `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
20 |     func run(with arguments: ArgumentParser.Result) throws
21 | }
/host/spi-builder-workspace/Sources/xcparse/Command.swift:20:30: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
18 |
19 |     init(parser: ArgumentParser)
20 |     func run(with arguments: ArgumentParser.Result) throws
   |                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
21 | }
22 |
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:16:25: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 14 | // https://www.enekoalonso.com/articles/handling-commands-with-swift-package-manager
 15 | struct CommandRegistry {
 16 |     private let parser: ArgumentParser
    |                         `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 17 |     private var commands: [Command] = []
 18 |
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:19:36: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 17 |     private var commands: [Command] = []
 18 |
 19 |     private var legacyScreenshots: OptionArgument<[PathArgument]>
    |                                    `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 20 |     private var legacyXcov: OptionArgument<[PathArgument]>
 21 |
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:19:52: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 17 |     private var commands: [Command] = []
 18 |
 19 |     private var legacyScreenshots: OptionArgument<[PathArgument]>
    |                                                    `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 20 |     private var legacyXcov: OptionArgument<[PathArgument]>
 21 |
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:20:29: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 18 |
 19 |     private var legacyScreenshots: OptionArgument<[PathArgument]>
 20 |     private var legacyXcov: OptionArgument<[PathArgument]>
    |                             `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 21 |
 22 |     init(usage: String, overview: String) {
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:20:45: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 18 |
 19 |     private var legacyScreenshots: OptionArgument<[PathArgument]>
 20 |     private var legacyXcov: OptionArgument<[PathArgument]>
    |                                             `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 21 |
 22 |     init(usage: String, overview: String) {
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:48:100: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 46 |     }
 47 |
 48 |     private func parse(_ arguments: [String] = Array(CommandLine.arguments.dropFirst())) throws -> ArgumentParser.Result {
    |                                                                                                    `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 49 |         return try parser.parse(arguments)
 50 |     }
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:52:60: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 50 |     }
 51 |
 52 |     private func processLegacyScreenshotCommand(arguments: ArgumentParser.Result) -> Bool {
    |                                                            `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 53 |         guard let legacyScreenshotPaths = arguments.get(self.legacyScreenshots) else {
 54 |             return false
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:85:62: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 83 |     }
 84 |
 85 |     private func processLegacyCodeCoverageCommand(arguments: ArgumentParser.Result) -> Bool {
    |                                                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 86 |         guard let legacyCodeCovPaths = arguments.get(self.legacyXcov) else {
 87 |             return false
/host/spi-builder-workspace/Sources/xcparse/CommandRegistry.swift:105:37: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
103 |     }
104 |
105 |     private func process(arguments: ArgumentParser.Result) throws {
    |                                     `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
106 |         // Check to see if it's a legacy command
107 |         if self.processLegacyScreenshotCommand(arguments: arguments) == true {
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:18:23: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
16 |     let usage = "[OPTIONS] appSizeReport outputDirectory"
17 |
18 |     var flagVariants: OptionArgument<String>
   |                       `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
19 |     var reportPath: PositionalArgument<PathArgument>
20 |     var resultPath: PositionalArgument<PathArgument>
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:19:21: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
17 |
18 |     var flagVariants: OptionArgument<String>
19 |     var reportPath: PositionalArgument<PathArgument>
   |                     `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
20 |     var resultPath: PositionalArgument<PathArgument>
21 |
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:19:40: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
17 |
18 |     var flagVariants: OptionArgument<String>
19 |     var reportPath: PositionalArgument<PathArgument>
   |                                        `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
20 |     var resultPath: PositionalArgument<PathArgument>
21 |
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:20:21: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
18 |     var flagVariants: OptionArgument<String>
19 |     var reportPath: PositionalArgument<PathArgument>
20 |     var resultPath: PositionalArgument<PathArgument>
   |                     `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
21 |
22 |     init(parser: ArgumentParser) {
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:20:40: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
18 |     var flagVariants: OptionArgument<String>
19 |     var reportPath: PositionalArgument<PathArgument>
20 |     var resultPath: PositionalArgument<PathArgument>
   |                                        `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
21 |
22 |     init(parser: ArgumentParser) {
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:22:18: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
20 |     var resultPath: PositionalArgument<PathArgument>
21 |
22 |     init(parser: ArgumentParser) {
   |                  `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
23 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
24 |
/host/spi-builder-workspace/Sources/xcparse/ConverterCommand.swift:33:30: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
31 |     }
32 |
33 |     func run(with arguments: ArgumentParser.Result) throws {
   |                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
34 |         let xcpParser = XCPParser()
35 |
/host/spi-builder-workspace/Sources/xcparse/LogsCommand.swift:18:15: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
17 |
18 |     var path: PositionalArgument<PathArgument>
   |               `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
19 |     var outputPath: PositionalArgument<PathArgument>
20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/LogsCommand.swift:18:34: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
17 |
18 |     var path: PositionalArgument<PathArgument>
   |                                  `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
19 |     var outputPath: PositionalArgument<PathArgument>
20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/LogsCommand.swift:19:21: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
17 |
18 |     var path: PositionalArgument<PathArgument>
19 |     var outputPath: PositionalArgument<PathArgument>
   |                     `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
20 |     var verbose: OptionArgument<Bool>
21 |
/host/spi-builder-workspace/Sources/xcparse/LogsCommand.swift:19:40: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
17 |
18 |     var path: PositionalArgument<PathArgument>
19 |     var outputPath: PositionalArgument<PathArgument>
   |                                        `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
20 |     var verbose: OptionArgument<Bool>
21 |
/host/spi-builder-workspace/Sources/xcparse/LogsCommand.swift:20:18: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
18 |     var path: PositionalArgument<PathArgument>
19 |     var outputPath: PositionalArgument<PathArgument>
20 |     var verbose: OptionArgument<Bool>
   |                  `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
21 |
22 |     init(parser: ArgumentParser) {
/host/spi-builder-workspace/Sources/xcparse/LogsCommand.swift:22:18: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
20 |     var verbose: OptionArgument<Bool>
21 |
22 |     init(parser: ArgumentParser) {
   |                  `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
23 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
24 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
/host/spi-builder-workspace/Sources/xcparse/LogsCommand.swift:31:30: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
29 |     }
30 |
31 |     func run(with arguments: ArgumentParser.Result) throws {
   |                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
32 |         guard let xcresultPathArgument = arguments.get(path) else {
33 |             print("Missing xcresult path")
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:18:15: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
 17 |
 18 |     var path: PositionalArgument<PathArgument>
    |               `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 19 |     var outputPath: PositionalArgument<PathArgument>
 20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:18:34: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
 17 |
 18 |     var path: PositionalArgument<PathArgument>
    |                                  `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 19 |     var outputPath: PositionalArgument<PathArgument>
 20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:19:21: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 17 |
 18 |     var path: PositionalArgument<PathArgument>
 19 |     var outputPath: PositionalArgument<PathArgument>
    |                     `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 20 |     var verbose: OptionArgument<Bool>
 21 |
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:19:40: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 17 |
 18 |     var path: PositionalArgument<PathArgument>
 19 |     var outputPath: PositionalArgument<PathArgument>
    |                                        `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 20 |     var verbose: OptionArgument<Bool>
 21 |
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:20:18: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 18 |     var path: PositionalArgument<PathArgument>
 19 |     var outputPath: PositionalArgument<PathArgument>
 20 |     var verbose: OptionArgument<Bool>
    |                  `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 21 |
 22 |     var addTestScreenshotDirectory: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:22:37: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 20 |     var verbose: OptionArgument<Bool>
 21 |
 22 |     var addTestScreenshotDirectory: OptionArgument<Bool>
    |                                     `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 23 |     var divideByModel: OptionArgument<Bool>
 24 |     var divideByOS: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:23:24: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 21 |
 22 |     var addTestScreenshotDirectory: OptionArgument<Bool>
 23 |     var divideByModel: OptionArgument<Bool>
    |                        `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 24 |     var divideByOS: OptionArgument<Bool>
 25 |     var divideByTestRun: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:24:21: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 22 |     var addTestScreenshotDirectory: OptionArgument<Bool>
 23 |     var divideByModel: OptionArgument<Bool>
 24 |     var divideByOS: OptionArgument<Bool>
    |                     `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 25 |     var divideByTestRun: OptionArgument<Bool>
 26 |     var divideByTestPlanConfig: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:25:26: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 23 |     var divideByModel: OptionArgument<Bool>
 24 |     var divideByOS: OptionArgument<Bool>
 25 |     var divideByTestRun: OptionArgument<Bool>
    |                          `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 26 |     var divideByTestPlanConfig: OptionArgument<Bool>
 27 |     var divideByLanguage: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:26:33: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 24 |     var divideByOS: OptionArgument<Bool>
 25 |     var divideByTestRun: OptionArgument<Bool>
 26 |     var divideByTestPlanConfig: OptionArgument<Bool>
    |                                 `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 27 |     var divideByLanguage: OptionArgument<Bool>
 28 |     var divideByRegion: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:27:27: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 25 |     var divideByTestRun: OptionArgument<Bool>
 26 |     var divideByTestPlanConfig: OptionArgument<Bool>
 27 |     var divideByLanguage: OptionArgument<Bool>
    |                           `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 28 |     var divideByRegion: OptionArgument<Bool>
 29 |     var divideByTest: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:28:25: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 26 |     var divideByTestPlanConfig: OptionArgument<Bool>
 27 |     var divideByLanguage: OptionArgument<Bool>
 28 |     var divideByRegion: OptionArgument<Bool>
    |                         `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 29 |     var divideByTest: OptionArgument<Bool>
 30 |
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:29:23: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 27 |     var divideByLanguage: OptionArgument<Bool>
 28 |     var divideByRegion: OptionArgument<Bool>
 29 |     var divideByTest: OptionArgument<Bool>
    |                       `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 30 |
 31 |     var testStatusWhitelist: OptionArgument<[String]>
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:31:30: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 29 |     var divideByTest: OptionArgument<Bool>
 30 |
 31 |     var testStatusWhitelist: OptionArgument<[String]>
    |                              `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 32 |     var activityTypeWhitelist: OptionArgument<[String]>
 33 |
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:32:32: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 30 |
 31 |     var testStatusWhitelist: OptionArgument<[String]>
 32 |     var activityTypeWhitelist: OptionArgument<[String]>
    |                                `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 33 |
 34 |     init(parser: ArgumentParser) {
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:34:18: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 32 |     var activityTypeWhitelist: OptionArgument<[String]>
 33 |
 34 |     init(parser: ArgumentParser) {
    |                  `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 35 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
 36 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:57:30: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 55 |     }
 56 |
 57 |     func run(with arguments: ArgumentParser.Result) throws {
    |                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 58 |         guard let xcresultPathArgument = arguments.get(path) else {
 59 |             print("Missing xcresult path")
/host/spi-builder-workspace/Sources/xcparse/VersionCommand.swift:18:18: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
16 |     let usage = ""
17 |
18 |     init(parser: ArgumentParser) {
   |                  `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
19 |         _ = parser.add(subparser: command, usage: usage, overview: overview)
20 |     }
/host/spi-builder-workspace/Sources/xcparse/VersionCommand.swift:22:30: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
20 |     }
21 |
22 |     func run(with arguments: ArgumentParser.Result) throws {
   |                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
23 |         let xcpParser = XCPParser()
24 |         xcpParser.printVersion()
[211/216] Compiling xcparse ScreenshotsCommand.swift
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:18:15: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
 17 |
 18 |     var path: PositionalArgument<PathArgument>
    |               `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 19 |     var outputPath: PositionalArgument<PathArgument>
 20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:18:34: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 16 |     let usage = "[OPTIONS] xcresult [outputDirectory]"
 17 |
 18 |     var path: PositionalArgument<PathArgument>
    |                                  `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 19 |     var outputPath: PositionalArgument<PathArgument>
 20 |     var verbose: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:19:21: warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 17 |
 18 |     var path: PositionalArgument<PathArgument>
 19 |     var outputPath: PositionalArgument<PathArgument>
    |                     `- warning: 'PositionalArgument' is deprecated: use swift-argument-parser instead
 20 |     var verbose: OptionArgument<Bool>
 21 |
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:19:40: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 17 |
 18 |     var path: PositionalArgument<PathArgument>
 19 |     var outputPath: PositionalArgument<PathArgument>
    |                                        `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 20 |     var verbose: OptionArgument<Bool>
 21 |
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:20:18: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 18 |     var path: PositionalArgument<PathArgument>
 19 |     var outputPath: PositionalArgument<PathArgument>
 20 |     var verbose: OptionArgument<Bool>
    |                  `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 21 |
 22 |     var addTestScreenshotDirectory: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:22:37: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 20 |     var verbose: OptionArgument<Bool>
 21 |
 22 |     var addTestScreenshotDirectory: OptionArgument<Bool>
    |                                     `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 23 |     var divideByModel: OptionArgument<Bool>
 24 |     var divideByOS: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:23:24: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 21 |
 22 |     var addTestScreenshotDirectory: OptionArgument<Bool>
 23 |     var divideByModel: OptionArgument<Bool>
    |                        `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 24 |     var divideByOS: OptionArgument<Bool>
 25 |     var divideByTestRun: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:24:21: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 22 |     var addTestScreenshotDirectory: OptionArgument<Bool>
 23 |     var divideByModel: OptionArgument<Bool>
 24 |     var divideByOS: OptionArgument<Bool>
    |                     `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 25 |     var divideByTestRun: OptionArgument<Bool>
 26 |     var divideByTestPlanConfig: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:25:26: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 23 |     var divideByModel: OptionArgument<Bool>
 24 |     var divideByOS: OptionArgument<Bool>
 25 |     var divideByTestRun: OptionArgument<Bool>
    |                          `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 26 |     var divideByTestPlanConfig: OptionArgument<Bool>
 27 |     var divideByLanguage: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:26:33: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 24 |     var divideByOS: OptionArgument<Bool>
 25 |     var divideByTestRun: OptionArgument<Bool>
 26 |     var divideByTestPlanConfig: OptionArgument<Bool>
    |                                 `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 27 |     var divideByLanguage: OptionArgument<Bool>
 28 |     var divideByRegion: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:27:27: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 25 |     var divideByTestRun: OptionArgument<Bool>
 26 |     var divideByTestPlanConfig: OptionArgument<Bool>
 27 |     var divideByLanguage: OptionArgument<Bool>
    |                           `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 28 |     var divideByRegion: OptionArgument<Bool>
 29 |     var divideByTest: OptionArgument<Bool>
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:28:25: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 26 |     var divideByTestPlanConfig: OptionArgument<Bool>
 27 |     var divideByLanguage: OptionArgument<Bool>
 28 |     var divideByRegion: OptionArgument<Bool>
    |                         `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 29 |     var divideByTest: OptionArgument<Bool>
 30 |
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:29:23: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 27 |     var divideByLanguage: OptionArgument<Bool>
 28 |     var divideByRegion: OptionArgument<Bool>
 29 |     var divideByTest: OptionArgument<Bool>
    |                       `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 30 |
 31 |     var testStatusWhitelist: OptionArgument<[String]>
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:31:30: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 29 |     var divideByTest: OptionArgument<Bool>
 30 |
 31 |     var testStatusWhitelist: OptionArgument<[String]>
    |                              `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 32 |     var activityTypeWhitelist: OptionArgument<[String]>
 33 |
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:32:32: warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 30 |
 31 |     var testStatusWhitelist: OptionArgument<[String]>
 32 |     var activityTypeWhitelist: OptionArgument<[String]>
    |                                `- warning: 'OptionArgument' is deprecated: use swift-argument-parser instead
 33 |
 34 |     init(parser: ArgumentParser) {
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:34:18: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 32 |     var activityTypeWhitelist: OptionArgument<[String]>
 33 |
 34 |     init(parser: ArgumentParser) {
    |                  `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 35 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
 36 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:57:30: warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 55 |     }
 56 |
 57 |     func run(with arguments: ArgumentParser.Result) throws {
    |                              `- warning: 'ArgumentParser' is deprecated: use swift-argument-parser instead
 58 |         guard let xcresultPathArgument = arguments.get(path) else {
 59 |             print("Missing xcresult path")
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:36:60: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 34 |     init(parser: ArgumentParser) {
 35 |         let subparser = parser.add(subparser: command, usage: usage, overview: overview)
 36 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
    |                                                            `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 37 |                              optional: false, usage: "Path to the xcresult file", completion: .filename)
 38 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:38:73: warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 36 |         path = subparser.add(positional: "xcresult", kind: PathArgument.self,
 37 |                              optional: false, usage: "Path to the xcresult file", completion: .filename)
 38 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
    |                                                                         `- warning: 'PathArgument' is deprecated: use swift-argument-parser instead
 39 |                                    optional: true, usage: "Folder to export results to", completion: .filename)
 40 |         verbose = subparser.add(option: "--verbose", shortName: "-v", kind: Bool.self, usage: "Enable verbose logging")
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:40:29: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 38 |         outputPath = subparser.add(positional: "outputDirectory", kind: PathArgument.self,
 39 |                                    optional: true, usage: "Folder to export results to", completion: .filename)
 40 |         verbose = subparser.add(option: "--verbose", shortName: "-v", kind: Bool.self, usage: "Enable verbose logging")
    |                             `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 41 |
 42 |         addTestScreenshotDirectory = subparser.add(option: "--legacy", shortName: nil, kind: Bool.self, usage: "Create \"testScreenshots\" directory in outputDirectory & put screenshots in there")
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:42:48: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 40 |         verbose = subparser.add(option: "--verbose", shortName: "-v", kind: Bool.self, usage: "Enable verbose logging")
 41 |
 42 |         addTestScreenshotDirectory = subparser.add(option: "--legacy", shortName: nil, kind: Bool.self, usage: "Create \"testScreenshots\" directory in outputDirectory & put screenshots in there")
    |                                                `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 43 |         divideByModel = subparser.add(option: "--model", shortName: nil, kind: Bool.self, usage: "Divide screenshots by model")
 44 |         divideByOS = subparser.add(option: "--os", shortName: nil, kind: Bool.self, usage: "Divide screenshots by OS")
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:43:35: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 41 |
 42 |         addTestScreenshotDirectory = subparser.add(option: "--legacy", shortName: nil, kind: Bool.self, usage: "Create \"testScreenshots\" directory in outputDirectory & put screenshots in there")
 43 |         divideByModel = subparser.add(option: "--model", shortName: nil, kind: Bool.self, usage: "Divide screenshots by model")
    |                                   `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 44 |         divideByOS = subparser.add(option: "--os", shortName: nil, kind: Bool.self, usage: "Divide screenshots by OS")
 45 |         divideByTestRun = subparser.add(option: "--test-run", shortName: nil, kind: Bool.self, usage: "Deprecated. Use --test-plan-config")
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:44:32: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 42 |         addTestScreenshotDirectory = subparser.add(option: "--legacy", shortName: nil, kind: Bool.self, usage: "Create \"testScreenshots\" directory in outputDirectory & put screenshots in there")
 43 |         divideByModel = subparser.add(option: "--model", shortName: nil, kind: Bool.self, usage: "Divide screenshots by model")
 44 |         divideByOS = subparser.add(option: "--os", shortName: nil, kind: Bool.self, usage: "Divide screenshots by OS")
    |                                `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 45 |         divideByTestRun = subparser.add(option: "--test-run", shortName: nil, kind: Bool.self, usage: "Deprecated. Use --test-plan-config")
 46 |         divideByTestPlanConfig = subparser.add(option: "--test-plan-config", shortName: nil, kind: Bool.self, usage: "Divide attachments by test plan configuration")
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:45:37: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 43 |         divideByModel = subparser.add(option: "--model", shortName: nil, kind: Bool.self, usage: "Divide screenshots by model")
 44 |         divideByOS = subparser.add(option: "--os", shortName: nil, kind: Bool.self, usage: "Divide screenshots by OS")
 45 |         divideByTestRun = subparser.add(option: "--test-run", shortName: nil, kind: Bool.self, usage: "Deprecated. Use --test-plan-config")
    |                                     `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 46 |         divideByTestPlanConfig = subparser.add(option: "--test-plan-config", shortName: nil, kind: Bool.self, usage: "Divide attachments by test plan configuration")
 47 |         divideByLanguage = subparser.add(option: "--language", shortName: nil, kind: Bool.self, usage: "Divide attachments by test language")
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:46:44: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 44 |         divideByOS = subparser.add(option: "--os", shortName: nil, kind: Bool.self, usage: "Divide screenshots by OS")
 45 |         divideByTestRun = subparser.add(option: "--test-run", shortName: nil, kind: Bool.self, usage: "Deprecated. Use --test-plan-config")
 46 |         divideByTestPlanConfig = subparser.add(option: "--test-plan-config", shortName: nil, kind: Bool.self, usage: "Divide attachments by test plan configuration")
    |                                            `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 47 |         divideByLanguage = subparser.add(option: "--language", shortName: nil, kind: Bool.self, usage: "Divide attachments by test language")
 48 |         divideByRegion = subparser.add(option: "--region", shortName: nil, kind: Bool.self, usage: "Divide attachments by test region")
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:47:38: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 45 |         divideByTestRun = subparser.add(option: "--test-run", shortName: nil, kind: Bool.self, usage: "Deprecated. Use --test-plan-config")
 46 |         divideByTestPlanConfig = subparser.add(option: "--test-plan-config", shortName: nil, kind: Bool.self, usage: "Divide attachments by test plan configuration")
 47 |         divideByLanguage = subparser.add(option: "--language", shortName: nil, kind: Bool.self, usage: "Divide attachments by test language")
    |                                      `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 48 |         divideByRegion = subparser.add(option: "--region", shortName: nil, kind: Bool.self, usage: "Divide attachments by test region")
 49 |         divideByTest = subparser.add(option: "--test", shortName: nil, kind: Bool.self, usage: "Divide screenshots by test")
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:48:36: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 46 |         divideByTestPlanConfig = subparser.add(option: "--test-plan-config", shortName: nil, kind: Bool.self, usage: "Divide attachments by test plan configuration")
 47 |         divideByLanguage = subparser.add(option: "--language", shortName: nil, kind: Bool.self, usage: "Divide attachments by test language")
 48 |         divideByRegion = subparser.add(option: "--region", shortName: nil, kind: Bool.self, usage: "Divide attachments by test region")
    |                                    `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 49 |         divideByTest = subparser.add(option: "--test", shortName: nil, kind: Bool.self, usage: "Divide screenshots by test")
 50 |
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:49:34: warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 47 |         divideByLanguage = subparser.add(option: "--language", shortName: nil, kind: Bool.self, usage: "Divide attachments by test language")
 48 |         divideByRegion = subparser.add(option: "--region", shortName: nil, kind: Bool.self, usage: "Divide attachments by test region")
 49 |         divideByTest = subparser.add(option: "--test", shortName: nil, kind: Bool.self, usage: "Divide screenshots by test")
    |                                  `- warning: conformance of 'Bool' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 50 |
 51 |         testStatusWhitelist = subparser.add(option: "--test-status", shortName: nil, kind: [String].self, strategy: .upToNextOption,
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:51:41: warning: conformance of 'String' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 49 |         divideByTest = subparser.add(option: "--test", shortName: nil, kind: Bool.self, usage: "Divide screenshots by test")
 50 |
 51 |         testStatusWhitelist = subparser.add(option: "--test-status", shortName: nil, kind: [String].self, strategy: .upToNextOption,
    |                                         `- warning: conformance of 'String' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 52 |                                             usage: "Whitelist of acceptable test statuses for screenshots [optional, example: \"--test-status Success Failure\"]")
 53 |         activityTypeWhitelist = subparser.add(option: "--activity-type", shortName: nil, kind: [String].self, strategy: .upToNextOption,
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:53:43: warning: conformance of 'String' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 51 |         testStatusWhitelist = subparser.add(option: "--test-status", shortName: nil, kind: [String].self, strategy: .upToNextOption,
 52 |                                             usage: "Whitelist of acceptable test statuses for screenshots [optional, example: \"--test-status Success Failure\"]")
 53 |         activityTypeWhitelist = subparser.add(option: "--activity-type", shortName: nil, kind: [String].self, strategy: .upToNextOption,
    |                                           `- warning: conformance of 'String' to 'ArgumentKind' is deprecated: use swift-argument-parser instead
 54 |                                               usage: "Whitelist of acceptable activity types for screenshots. If value does not specify domain, \"com.apple.dt.xctest.activity-type.\" is assumed and prefixed to the value [optional, example: \"--activity-type userCreated attachmentContainer com.apple.dt.xctest.activity-type.testAssertionFailure\"]")
 55 |     }
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:92:56: error: cannot find 'UTTypeConformsTo' in scope
 90 |                                               divideByTest: arguments.get(self.divideByTest) ?? false,
 91 |                                               attachmentFilter: {
 92 |                                                 return UTTypeConformsTo($0.uniformTypeIdentifier as CFString, "public.image" as CFString)
    |                                                        `- error: cannot find 'UTTypeConformsTo' in scope
 93 |         })
 94 |         if let allowedTestStatuses = arguments.get(self.testStatusWhitelist) {
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:92:101: error: cannot find type 'CFString' in scope
 90 |                                               divideByTest: arguments.get(self.divideByTest) ?? false,
 91 |                                               attachmentFilter: {
 92 |                                                 return UTTypeConformsTo($0.uniformTypeIdentifier as CFString, "public.image" as CFString)
    |                                                                                                     `- error: cannot find type 'CFString' in scope
 93 |         })
 94 |         if let allowedTestStatuses = arguments.get(self.testStatusWhitelist) {
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:92:129: error: cannot find type 'CFString' in scope
 90 |                                               divideByTest: arguments.get(self.divideByTest) ?? false,
 91 |                                               attachmentFilter: {
 92 |                                                 return UTTypeConformsTo($0.uniformTypeIdentifier as CFString, "public.image" as CFString)
    |                                                                                                                                 `- error: cannot find type 'CFString' in scope
 93 |         })
 94 |         if let allowedTestStatuses = arguments.get(self.testStatusWhitelist) {
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:95:41: error: cannot infer type of closure parameter '$0' without a type annotation
 93 |         })
 94 |         if let allowedTestStatuses = arguments.get(self.testStatusWhitelist) {
 95 |             options.testSummaryFilter = { allowedTestStatuses.contains($0.testStatus) }
    |                                         `- error: cannot infer type of closure parameter '$0' without a type annotation
 96 |         }
 97 |         if let allowedActivityTypes = arguments.get(self.activityTypeWhitelist) {
/host/spi-builder-workspace/Sources/xcparse/ScreenshotsCommand.swift:106:45: error: cannot infer type of closure parameter '$0' without a type annotation
104 |             }
105 |
106 |             options.activitySummaryFilter = { additionalActivityTypes.contains($0.activityType) }
    |                                             `- error: cannot infer type of closure parameter '$0' without a type annotation
107 |         }
108 |
[212/216] Compiling xcparse XCPParser.swift
/host/spi-builder-workspace/Sources/xcparse/XCPParser.swift:438:30: error: cannot find 'URLRequest' in scope
436 |         let latestReleaseURL = URL(string: "https://api.github.com/repos/ChargePoint/xcparse/releases/latest")!
437 |
438 |         var releaseRequest = URLRequest(url: latestReleaseURL)
    |                              `- error: cannot find 'URLRequest' in scope
439 |         releaseRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
440 |
/host/spi-builder-workspace/Sources/xcparse/XCPParser.swift:441:20: error: 'URLSession' (aka 'AnyObject') cannot be constructed because it has no accessible initializers
439 |         releaseRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
440 |
441 | 		let urlSession = URLSession(configuration: .ephemeral)
    |                    `- error: 'URLSession' (aka 'AnyObject') cannot be constructed because it has no accessible initializers
442 |         let task = urlSession.dataTask(with: releaseRequest) { (data, response, error) in
443 |             if error != nil || data == nil {
/host/spi-builder-workspace/Sources/xcparse/XCPParser.swift:441:47: error: cannot infer contextual base in reference to member 'ephemeral'
439 |         releaseRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
440 |
441 | 		let urlSession = URLSession(configuration: .ephemeral)
    |                                               `- error: cannot infer contextual base in reference to member 'ephemeral'
442 |         let task = urlSession.dataTask(with: releaseRequest) { (data, response, error) in
443 |             if error != nil || data == nil {
[213/216] Compiling xcparse main.swift
BUILD FAILURE 6.1 linux