Swift Package Index

Build Information

Failed to build SwiftFormat, reference main (44cfb4), with Swift 6.3 for Wasm on 14 Oct 2026 12:07:31 UTC.

Build Command

bash -c docker run --pull=always --rm -v "checkouts-53886768-0":/host -w "$PWD" -e JAVA_HOME="/root/.sdkman/candidates/java/current" -e SPI_BUILD="1" -e SPI_PROCESSING="1" registry.gitlab.com/saguaro1/spi-images:wasm-6.3-latest swift build --swift-sdk swift-6.3.2-RELEASE_wasm 2>&1

Build Log

 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:871:40: error: cannot infer contextual base in reference to member 'userInitiated'
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:923:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 921 |             if let reportURL {
 922 |                 print("Writing report file to \(reportURL.path)", as: .info)
 923 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 924 |             } else {
 925 |                 print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:1361:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1359 |         do {
1360 |             let data = try JSONEncoder().encode(cache)
1361 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1362 |         } catch {
1363 |             if FileManager.default.fileExists(atPath: cacheDirectory.path) {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:834:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 832 |                         if let reportURL {
 833 |                             print("Writing report file to \(reportURL.path)", as: .info)
 834 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 835 |                         } else {
 836 |                             print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:871:13: error: cannot find 'DispatchQueue' in scope
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:871:40: error: cannot infer contextual base in reference to member 'userInitiated'
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:923:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 921 |             if let reportURL {
 922 |                 print("Writing report file to \(reportURL.path)", as: .info)
 923 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 924 |             } else {
 925 |                 print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:1361:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1359 |         do {
1360 |             let data = try JSONEncoder().encode(cache)
1361 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1362 |         } catch {
1363 |             if FileManager.default.fileExists(atPath: cacheDirectory.path) {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:834:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 832 |                         if let reportURL {
 833 |                             print("Writing report file to \(reportURL.path)", as: .info)
 834 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 835 |                         } else {
 836 |                             print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:871:13: error: cannot find 'DispatchQueue' in scope
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:871:40: error: cannot infer contextual base in reference to member 'userInitiated'
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:923:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 921 |             if let reportURL {
 922 |                 print("Writing report file to \(reportURL.path)", as: .info)
 923 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 924 |             } else {
 925 |                 print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:1361:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1359 |         do {
1360 |             let data = try JSONEncoder().encode(cache)
1361 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1362 |         } catch {
1363 |             if FileManager.default.fileExists(atPath: cacheDirectory.path) {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:834:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 832 |                         if let reportURL {
 833 |                             print("Writing report file to \(reportURL.path)", as: .info)
 834 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 835 |                         } else {
 836 |                             print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:871:13: error: cannot find 'DispatchQueue' in scope
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:871:40: error: cannot infer contextual base in reference to member 'userInitiated'
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:923:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 921 |             if let reportURL {
 922 |                 print("Writing report file to \(reportURL.path)", as: .info)
 923 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 924 |             } else {
 925 |                 print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:1361:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1359 |         do {
1360 |             let data = try JSONEncoder().encode(cache)
1361 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1362 |         } catch {
1363 |             if FileManager.default.fileExists(atPath: cacheDirectory.path) {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:834:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 832 |                         if let reportURL {
 833 |                             print("Writing report file to \(reportURL.path)", as: .info)
 834 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 835 |                         } else {
 836 |                             print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:871:13: error: cannot find 'DispatchQueue' in scope
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:871:40: error: cannot infer contextual base in reference to member 'userInitiated'
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:923:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 921 |             if let reportURL {
 922 |                 print("Writing report file to \(reportURL.path)", as: .info)
 923 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 924 |             } else {
 925 |                 print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:1361:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1359 |         do {
1360 |             let data = try JSONEncoder().encode(cache)
1361 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1362 |         } catch {
1363 |             if FileManager.default.fileExists(atPath: cacheDirectory.path) {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:834:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 832 |                         if let reportURL {
 833 |                             print("Writing report file to \(reportURL.path)", as: .info)
 834 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 835 |                         } else {
 836 |                             print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:871:13: error: cannot find 'DispatchQueue' in scope
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:871:40: error: cannot infer contextual base in reference to member 'userInitiated'
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:923:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 921 |             if let reportURL {
 922 |                 print("Writing report file to \(reportURL.path)", as: .info)
 923 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 924 |             } else {
 925 |                 print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:1361:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1359 |         do {
1360 |             let data = try JSONEncoder().encode(cache)
1361 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1362 |         } catch {
1363 |             if FileManager.default.fileExists(atPath: cacheDirectory.path) {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:834:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 832 |                         if let reportURL {
 833 |                             print("Writing report file to \(reportURL.path)", as: .info)
 834 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 835 |                         } else {
 836 |                             print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:871:13: error: cannot find 'DispatchQueue' in scope
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:871:40: error: cannot infer contextual base in reference to member 'userInitiated'
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:923:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 921 |             if let reportURL {
 922 |                 print("Writing report file to \(reportURL.path)", as: .info)
 923 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 924 |             } else {
 925 |                 print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:1361:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1359 |         do {
1360 |             let data = try JSONEncoder().encode(cache)
1361 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1362 |         } catch {
1363 |             if FileManager.default.fileExists(atPath: cacheDirectory.path) {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:834:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 832 |                         if let reportURL {
 833 |                             print("Writing report file to \(reportURL.path)", as: .info)
 834 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 835 |                         } else {
 836 |                             print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:871:13: error: cannot find 'DispatchQueue' in scope
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:871:40: error: cannot infer contextual base in reference to member 'userInitiated'
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:923:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 921 |             if let reportURL {
 922 |                 print("Writing report file to \(reportURL.path)", as: .info)
 923 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 924 |             } else {
 925 |                 print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:1361:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1359 |         do {
1360 |             let data = try JSONEncoder().encode(cache)
1361 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1362 |         } catch {
1363 |             if FileManager.default.fileExists(atPath: cacheDirectory.path) {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:834:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 832 |                         if let reportURL {
 833 |                             print("Writing report file to \(reportURL.path)", as: .info)
 834 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 835 |                         } else {
 836 |                             print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:871:13: error: cannot find 'DispatchQueue' in scope
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:871:40: error: cannot infer contextual base in reference to member 'userInitiated'
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:923:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 921 |             if let reportURL {
 922 |                 print("Writing report file to \(reportURL.path)", as: .info)
 923 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 924 |             } else {
 925 |                 print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:1361:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1359 |         do {
1360 |             let data = try JSONEncoder().encode(cache)
1361 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1362 |         } catch {
1363 |             if FileManager.default.fileExists(atPath: cacheDirectory.path) {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:834:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 832 |                         if let reportURL {
 833 |                             print("Writing report file to \(reportURL.path)", as: .info)
 834 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 835 |                         } else {
 836 |                             print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:871:13: error: cannot find 'DispatchQueue' in scope
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:871:40: error: cannot infer contextual base in reference to member 'userInitiated'
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:923:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 921 |             if let reportURL {
 922 |                 print("Writing report file to \(reportURL.path)", as: .info)
 923 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 924 |             } else {
 925 |                 print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:1361:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1359 |         do {
1360 |             let data = try JSONEncoder().encode(cache)
1361 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1362 |         } catch {
1363 |             if FileManager.default.fileExists(atPath: cacheDirectory.path) {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:834:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 832 |                         if let reportURL {
 833 |                             print("Writing report file to \(reportURL.path)", as: .info)
 834 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 835 |                         } else {
 836 |                             print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:871:13: error: cannot find 'DispatchQueue' in scope
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:871:40: error: cannot infer contextual base in reference to member 'userInitiated'
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:923:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 921 |             if let reportURL {
 922 |                 print("Writing report file to \(reportURL.path)", as: .info)
 923 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 924 |             } else {
 925 |                 print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:1361:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1359 |         do {
1360 |             let data = try JSONEncoder().encode(cache)
1361 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1362 |         } catch {
1363 |             if FileManager.default.fileExists(atPath: cacheDirectory.path) {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:834:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 832 |                         if let reportURL {
 833 |                             print("Writing report file to \(reportURL.path)", as: .info)
 834 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 835 |                         } else {
 836 |                             print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:871:13: error: cannot find 'DispatchQueue' in scope
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:871:40: error: cannot infer contextual base in reference to member 'userInitiated'
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:923:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 921 |             if let reportURL {
 922 |                 print("Writing report file to \(reportURL.path)", as: .info)
 923 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 924 |             } else {
 925 |                 print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:1361:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1359 |         do {
1360 |             let data = try JSONEncoder().encode(cache)
1361 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1362 |         } catch {
1363 |             if FileManager.default.fileExists(atPath: cacheDirectory.path) {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:834:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 832 |                         if let reportURL {
 833 |                             print("Writing report file to \(reportURL.path)", as: .info)
 834 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 835 |                         } else {
 836 |                             print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:871:13: error: cannot find 'DispatchQueue' in scope
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:871:40: error: cannot infer contextual base in reference to member 'userInitiated'
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:923:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 921 |             if let reportURL {
 922 |                 print("Writing report file to \(reportURL.path)", as: .info)
 923 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 924 |             } else {
 925 |                 print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:1361:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1359 |         do {
1360 |             let data = try JSONEncoder().encode(cache)
1361 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1362 |         } catch {
1363 |             if FileManager.default.fileExists(atPath: cacheDirectory.path) {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:834:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 832 |                         if let reportURL {
 833 |                             print("Writing report file to \(reportURL.path)", as: .info)
 834 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 835 |                         } else {
 836 |                             print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:871:13: error: cannot find 'DispatchQueue' in scope
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:871:40: error: cannot infer contextual base in reference to member 'userInitiated'
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:923:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 921 |             if let reportURL {
 922 |                 print("Writing report file to \(reportURL.path)", as: .info)
 923 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 924 |             } else {
 925 |                 print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:1361:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1359 |         do {
1360 |             let data = try JSONEncoder().encode(cache)
1361 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1362 |         } catch {
1363 |             if FileManager.default.fileExists(atPath: cacheDirectory.path) {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:834:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 832 |                         if let reportURL {
 833 |                             print("Writing report file to \(reportURL.path)", as: .info)
 834 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 835 |                         } else {
 836 |                             print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:871:13: error: cannot find 'DispatchQueue' in scope
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:871:40: error: cannot infer contextual base in reference to member 'userInitiated'
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:923:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 921 |             if let reportURL {
 922 |                 print("Writing report file to \(reportURL.path)", as: .info)
 923 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 924 |             } else {
 925 |                 print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:1361:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1359 |         do {
1360 |             let data = try JSONEncoder().encode(cache)
1361 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1362 |         } catch {
1363 |             if FileManager.default.fileExists(atPath: cacheDirectory.path) {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:834:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 832 |                         if let reportURL {
 833 |                             print("Writing report file to \(reportURL.path)", as: .info)
 834 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 835 |                         } else {
 836 |                             print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:871:13: error: cannot find 'DispatchQueue' in scope
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:871:40: error: cannot infer contextual base in reference to member 'userInitiated'
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:923:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 921 |             if let reportURL {
 922 |                 print("Writing report file to \(reportURL.path)", as: .info)
 923 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 924 |             } else {
 925 |                 print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:1361:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1359 |         do {
1360 |             let data = try JSONEncoder().encode(cache)
1361 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1362 |         } catch {
1363 |             if FileManager.default.fileExists(atPath: cacheDirectory.path) {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:834:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 832 |                         if let reportURL {
 833 |                             print("Writing report file to \(reportURL.path)", as: .info)
 834 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 835 |                         } else {
 836 |                             print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:871:13: error: cannot find 'DispatchQueue' in scope
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:871:40: error: cannot infer contextual base in reference to member 'userInitiated'
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:923:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 921 |             if let reportURL {
 922 |                 print("Writing report file to \(reportURL.path)", as: .info)
 923 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 924 |             } else {
 925 |                 print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:1361:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1359 |         do {
1360 |             let data = try JSONEncoder().encode(cache)
1361 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1362 |         } catch {
1363 |             if FileManager.default.fileExists(atPath: cacheDirectory.path) {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:834:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 832 |                         if let reportURL {
 833 |                             print("Writing report file to \(reportURL.path)", as: .info)
 834 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 835 |                         } else {
 836 |                             print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:871:13: error: cannot find 'DispatchQueue' in scope
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:871:40: error: cannot infer contextual base in reference to member 'userInitiated'
 869 |         } else if inputURLs.isEmpty {
 870 |             // If no input file, try stdin
 871 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 872 |                 processFromStdin()
 873 |             }
/host/spi-builder-workspace/Sources/CommandLine.swift:923:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 921 |             if let reportURL {
 922 |                 print("Writing report file to \(reportURL.path)", as: .info)
 923 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 924 |             } else {
 925 |                 print(String(decoding: reporterOutput, as: UTF8.self), as: .raw)
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/CommandLine.swift:1361:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1359 |         do {
1360 |             let data = try JSONEncoder().encode(cache)
1361 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1362 |         } catch {
1363 |             if FileManager.default.fileExists(atPath: cacheDirectory.path) {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 |   struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 |     public static let atomic: Data.WritingOptions  }
  |                       `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
[302/372] Compiling SwiftFormat WrapAttributes.swift
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:27: error: cannot find 'DispatchQueue' in scope
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                           `- error: cannot find 'DispatchQueue' in scope
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:76: error: cannot infer contextual base in reference to member 'userInteractive'
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                                                                            `- error: cannot infer contextual base in reference to member 'userInteractive'
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:146:17: error: cannot find 'DispatchGroup' in scope
144 |     ]
145 |
146 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
/host/spi-builder-workspace/Sources/SwiftFormat.swift:148:27: error: cannot find 'DispatchQueue' in scope
146 |     let group = DispatchGroup()
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
    |                           `- error: cannot find 'DispatchQueue' in scope
149 |     func onComplete(_ block: @escaping () throws -> Void) {
150 |         completionQueue.async(group: group) {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:30: error: cannot find 'DispatchQueue' in scope
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                              `- error: cannot find 'DispatchQueue' in scope
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:57: error: cannot infer contextual base in reference to member 'userInitiated'
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                                                         `- error: cannot infer contextual base in reference to member 'userInitiated'
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:624:17: error: cannot find 'DispatchGroup' in scope
622 |
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:17: error: cannot find 'DispatchQueue' in scope
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:70: error: cannot infer contextual base in reference to member 'userInteractive'
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:40: error: cannot call value of non-function type 'Date'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:61: error: cannot infer contextual base in reference to member 'timedOut'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
[303/372] Compiling SwiftFormat WrapCaseBodies.swift
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:27: error: cannot find 'DispatchQueue' in scope
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                           `- error: cannot find 'DispatchQueue' in scope
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:76: error: cannot infer contextual base in reference to member 'userInteractive'
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                                                                            `- error: cannot infer contextual base in reference to member 'userInteractive'
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:146:17: error: cannot find 'DispatchGroup' in scope
144 |     ]
145 |
146 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
/host/spi-builder-workspace/Sources/SwiftFormat.swift:148:27: error: cannot find 'DispatchQueue' in scope
146 |     let group = DispatchGroup()
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
    |                           `- error: cannot find 'DispatchQueue' in scope
149 |     func onComplete(_ block: @escaping () throws -> Void) {
150 |         completionQueue.async(group: group) {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:30: error: cannot find 'DispatchQueue' in scope
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                              `- error: cannot find 'DispatchQueue' in scope
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:57: error: cannot infer contextual base in reference to member 'userInitiated'
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                                                         `- error: cannot infer contextual base in reference to member 'userInitiated'
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:624:17: error: cannot find 'DispatchGroup' in scope
622 |
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:17: error: cannot find 'DispatchQueue' in scope
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:70: error: cannot infer contextual base in reference to member 'userInteractive'
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:40: error: cannot call value of non-function type 'Date'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:61: error: cannot infer contextual base in reference to member 'timedOut'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
[304/372] Compiling SwiftFormat WrapConditionalBodies.swift
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:27: error: cannot find 'DispatchQueue' in scope
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                           `- error: cannot find 'DispatchQueue' in scope
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:76: error: cannot infer contextual base in reference to member 'userInteractive'
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                                                                            `- error: cannot infer contextual base in reference to member 'userInteractive'
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:146:17: error: cannot find 'DispatchGroup' in scope
144 |     ]
145 |
146 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
/host/spi-builder-workspace/Sources/SwiftFormat.swift:148:27: error: cannot find 'DispatchQueue' in scope
146 |     let group = DispatchGroup()
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
    |                           `- error: cannot find 'DispatchQueue' in scope
149 |     func onComplete(_ block: @escaping () throws -> Void) {
150 |         completionQueue.async(group: group) {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:30: error: cannot find 'DispatchQueue' in scope
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                              `- error: cannot find 'DispatchQueue' in scope
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:57: error: cannot infer contextual base in reference to member 'userInitiated'
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                                                         `- error: cannot infer contextual base in reference to member 'userInitiated'
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:624:17: error: cannot find 'DispatchGroup' in scope
622 |
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:17: error: cannot find 'DispatchQueue' in scope
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:70: error: cannot infer contextual base in reference to member 'userInteractive'
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:40: error: cannot call value of non-function type 'Date'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:61: error: cannot infer contextual base in reference to member 'timedOut'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
[305/372] Compiling SwiftFormat WrapEnumCases.swift
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:27: error: cannot find 'DispatchQueue' in scope
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                           `- error: cannot find 'DispatchQueue' in scope
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:76: error: cannot infer contextual base in reference to member 'userInteractive'
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                                                                            `- error: cannot infer contextual base in reference to member 'userInteractive'
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:146:17: error: cannot find 'DispatchGroup' in scope
144 |     ]
145 |
146 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
/host/spi-builder-workspace/Sources/SwiftFormat.swift:148:27: error: cannot find 'DispatchQueue' in scope
146 |     let group = DispatchGroup()
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
    |                           `- error: cannot find 'DispatchQueue' in scope
149 |     func onComplete(_ block: @escaping () throws -> Void) {
150 |         completionQueue.async(group: group) {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:30: error: cannot find 'DispatchQueue' in scope
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                              `- error: cannot find 'DispatchQueue' in scope
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:57: error: cannot infer contextual base in reference to member 'userInitiated'
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                                                         `- error: cannot infer contextual base in reference to member 'userInitiated'
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:624:17: error: cannot find 'DispatchGroup' in scope
622 |
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:17: error: cannot find 'DispatchQueue' in scope
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:70: error: cannot infer contextual base in reference to member 'userInteractive'
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:40: error: cannot call value of non-function type 'Date'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:61: error: cannot infer contextual base in reference to member 'timedOut'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
[306/372] Compiling SwiftFormat WrapFunctionBodies.swift
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:27: error: cannot find 'DispatchQueue' in scope
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                           `- error: cannot find 'DispatchQueue' in scope
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:76: error: cannot infer contextual base in reference to member 'userInteractive'
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                                                                            `- error: cannot infer contextual base in reference to member 'userInteractive'
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:146:17: error: cannot find 'DispatchGroup' in scope
144 |     ]
145 |
146 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
/host/spi-builder-workspace/Sources/SwiftFormat.swift:148:27: error: cannot find 'DispatchQueue' in scope
146 |     let group = DispatchGroup()
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
    |                           `- error: cannot find 'DispatchQueue' in scope
149 |     func onComplete(_ block: @escaping () throws -> Void) {
150 |         completionQueue.async(group: group) {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:30: error: cannot find 'DispatchQueue' in scope
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                              `- error: cannot find 'DispatchQueue' in scope
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:57: error: cannot infer contextual base in reference to member 'userInitiated'
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                                                         `- error: cannot infer contextual base in reference to member 'userInitiated'
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:624:17: error: cannot find 'DispatchGroup' in scope
622 |
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:17: error: cannot find 'DispatchQueue' in scope
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:70: error: cannot infer contextual base in reference to member 'userInteractive'
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:40: error: cannot call value of non-function type 'Date'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:61: error: cannot infer contextual base in reference to member 'timedOut'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
[307/372] Compiling SwiftFormat WrapGuardStatementBodies.swift
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:27: error: cannot find 'DispatchQueue' in scope
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                           `- error: cannot find 'DispatchQueue' in scope
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:76: error: cannot infer contextual base in reference to member 'userInteractive'
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                                                                            `- error: cannot infer contextual base in reference to member 'userInteractive'
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:146:17: error: cannot find 'DispatchGroup' in scope
144 |     ]
145 |
146 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
/host/spi-builder-workspace/Sources/SwiftFormat.swift:148:27: error: cannot find 'DispatchQueue' in scope
146 |     let group = DispatchGroup()
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
    |                           `- error: cannot find 'DispatchQueue' in scope
149 |     func onComplete(_ block: @escaping () throws -> Void) {
150 |         completionQueue.async(group: group) {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:30: error: cannot find 'DispatchQueue' in scope
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                              `- error: cannot find 'DispatchQueue' in scope
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:57: error: cannot infer contextual base in reference to member 'userInitiated'
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                                                         `- error: cannot infer contextual base in reference to member 'userInitiated'
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:624:17: error: cannot find 'DispatchGroup' in scope
622 |
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:17: error: cannot find 'DispatchQueue' in scope
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:70: error: cannot infer contextual base in reference to member 'userInteractive'
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:40: error: cannot call value of non-function type 'Date'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:61: error: cannot infer contextual base in reference to member 'timedOut'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
[308/372] Compiling SwiftFormat WrapIfExpressionBodies.swift
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:27: error: cannot find 'DispatchQueue' in scope
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                           `- error: cannot find 'DispatchQueue' in scope
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:76: error: cannot infer contextual base in reference to member 'userInteractive'
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                                                                            `- error: cannot infer contextual base in reference to member 'userInteractive'
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:146:17: error: cannot find 'DispatchGroup' in scope
144 |     ]
145 |
146 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
/host/spi-builder-workspace/Sources/SwiftFormat.swift:148:27: error: cannot find 'DispatchQueue' in scope
146 |     let group = DispatchGroup()
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
    |                           `- error: cannot find 'DispatchQueue' in scope
149 |     func onComplete(_ block: @escaping () throws -> Void) {
150 |         completionQueue.async(group: group) {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:30: error: cannot find 'DispatchQueue' in scope
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                              `- error: cannot find 'DispatchQueue' in scope
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:57: error: cannot infer contextual base in reference to member 'userInitiated'
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                                                         `- error: cannot infer contextual base in reference to member 'userInitiated'
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:624:17: error: cannot find 'DispatchGroup' in scope
622 |
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:17: error: cannot find 'DispatchQueue' in scope
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:70: error: cannot infer contextual base in reference to member 'userInteractive'
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:40: error: cannot call value of non-function type 'Date'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:61: error: cannot infer contextual base in reference to member 'timedOut'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
[309/372] Compiling SwiftFormat WrapIfStatementBodies.swift
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:27: error: cannot find 'DispatchQueue' in scope
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                           `- error: cannot find 'DispatchQueue' in scope
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:76: error: cannot infer contextual base in reference to member 'userInteractive'
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                                                                            `- error: cannot infer contextual base in reference to member 'userInteractive'
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:146:17: error: cannot find 'DispatchGroup' in scope
144 |     ]
145 |
146 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
/host/spi-builder-workspace/Sources/SwiftFormat.swift:148:27: error: cannot find 'DispatchQueue' in scope
146 |     let group = DispatchGroup()
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
    |                           `- error: cannot find 'DispatchQueue' in scope
149 |     func onComplete(_ block: @escaping () throws -> Void) {
150 |         completionQueue.async(group: group) {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:30: error: cannot find 'DispatchQueue' in scope
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                              `- error: cannot find 'DispatchQueue' in scope
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:57: error: cannot infer contextual base in reference to member 'userInitiated'
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                                                         `- error: cannot infer contextual base in reference to member 'userInitiated'
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:624:17: error: cannot find 'DispatchGroup' in scope
622 |
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:17: error: cannot find 'DispatchQueue' in scope
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:70: error: cannot infer contextual base in reference to member 'userInteractive'
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:40: error: cannot call value of non-function type 'Date'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:61: error: cannot infer contextual base in reference to member 'timedOut'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
[310/372] Compiling SwiftFormat WrapLoopBodies.swift
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:27: error: cannot find 'DispatchQueue' in scope
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                           `- error: cannot find 'DispatchQueue' in scope
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:76: error: cannot infer contextual base in reference to member 'userInteractive'
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                                                                            `- error: cannot infer contextual base in reference to member 'userInteractive'
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:146:17: error: cannot find 'DispatchGroup' in scope
144 |     ]
145 |
146 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
/host/spi-builder-workspace/Sources/SwiftFormat.swift:148:27: error: cannot find 'DispatchQueue' in scope
146 |     let group = DispatchGroup()
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
    |                           `- error: cannot find 'DispatchQueue' in scope
149 |     func onComplete(_ block: @escaping () throws -> Void) {
150 |         completionQueue.async(group: group) {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:30: error: cannot find 'DispatchQueue' in scope
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                              `- error: cannot find 'DispatchQueue' in scope
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:57: error: cannot infer contextual base in reference to member 'userInitiated'
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                                                         `- error: cannot infer contextual base in reference to member 'userInitiated'
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:624:17: error: cannot find 'DispatchGroup' in scope
622 |
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:17: error: cannot find 'DispatchQueue' in scope
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:70: error: cannot infer contextual base in reference to member 'userInteractive'
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:40: error: cannot call value of non-function type 'Date'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:61: error: cannot infer contextual base in reference to member 'timedOut'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
[311/372] Compiling SwiftFormat WrapMultilineConditionalAssignment.swift
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:27: error: cannot find 'DispatchQueue' in scope
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                           `- error: cannot find 'DispatchQueue' in scope
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:76: error: cannot infer contextual base in reference to member 'userInteractive'
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                                                                            `- error: cannot infer contextual base in reference to member 'userInteractive'
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:146:17: error: cannot find 'DispatchGroup' in scope
144 |     ]
145 |
146 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
/host/spi-builder-workspace/Sources/SwiftFormat.swift:148:27: error: cannot find 'DispatchQueue' in scope
146 |     let group = DispatchGroup()
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
    |                           `- error: cannot find 'DispatchQueue' in scope
149 |     func onComplete(_ block: @escaping () throws -> Void) {
150 |         completionQueue.async(group: group) {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:30: error: cannot find 'DispatchQueue' in scope
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                              `- error: cannot find 'DispatchQueue' in scope
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:57: error: cannot infer contextual base in reference to member 'userInitiated'
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                                                         `- error: cannot infer contextual base in reference to member 'userInitiated'
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:624:17: error: cannot find 'DispatchGroup' in scope
622 |
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:17: error: cannot find 'DispatchQueue' in scope
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:70: error: cannot infer contextual base in reference to member 'userInteractive'
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:40: error: cannot call value of non-function type 'Date'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:61: error: cannot infer contextual base in reference to member 'timedOut'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
[312/372] Compiling SwiftFormat WrapMultilineFunctionChains.swift
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:27: error: cannot find 'DispatchQueue' in scope
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                           `- error: cannot find 'DispatchQueue' in scope
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:76: error: cannot infer contextual base in reference to member 'userInteractive'
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                                                                            `- error: cannot infer contextual base in reference to member 'userInteractive'
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:146:17: error: cannot find 'DispatchGroup' in scope
144 |     ]
145 |
146 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
/host/spi-builder-workspace/Sources/SwiftFormat.swift:148:27: error: cannot find 'DispatchQueue' in scope
146 |     let group = DispatchGroup()
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
    |                           `- error: cannot find 'DispatchQueue' in scope
149 |     func onComplete(_ block: @escaping () throws -> Void) {
150 |         completionQueue.async(group: group) {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:30: error: cannot find 'DispatchQueue' in scope
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                              `- error: cannot find 'DispatchQueue' in scope
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:57: error: cannot infer contextual base in reference to member 'userInitiated'
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                                                         `- error: cannot infer contextual base in reference to member 'userInitiated'
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:624:17: error: cannot find 'DispatchGroup' in scope
622 |
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:17: error: cannot find 'DispatchQueue' in scope
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:70: error: cannot infer contextual base in reference to member 'userInteractive'
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:40: error: cannot call value of non-function type 'Date'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:61: error: cannot infer contextual base in reference to member 'timedOut'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
[313/372] Compiling SwiftFormat WrapMultilineStatementBraces.swift
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:27: error: cannot find 'DispatchQueue' in scope
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                           `- error: cannot find 'DispatchQueue' in scope
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:76: error: cannot infer contextual base in reference to member 'userInteractive'
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                                                                            `- error: cannot infer contextual base in reference to member 'userInteractive'
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:146:17: error: cannot find 'DispatchGroup' in scope
144 |     ]
145 |
146 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
/host/spi-builder-workspace/Sources/SwiftFormat.swift:148:27: error: cannot find 'DispatchQueue' in scope
146 |     let group = DispatchGroup()
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
    |                           `- error: cannot find 'DispatchQueue' in scope
149 |     func onComplete(_ block: @escaping () throws -> Void) {
150 |         completionQueue.async(group: group) {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:30: error: cannot find 'DispatchQueue' in scope
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                              `- error: cannot find 'DispatchQueue' in scope
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:57: error: cannot infer contextual base in reference to member 'userInitiated'
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                                                         `- error: cannot infer contextual base in reference to member 'userInitiated'
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:624:17: error: cannot find 'DispatchGroup' in scope
622 |
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:17: error: cannot find 'DispatchQueue' in scope
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:70: error: cannot infer contextual base in reference to member 'userInteractive'
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:40: error: cannot call value of non-function type 'Date'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:61: error: cannot infer contextual base in reference to member 'timedOut'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
[314/372] Compiling SwiftFormat WrapPropertyBodies.swift
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:27: error: cannot find 'DispatchQueue' in scope
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                           `- error: cannot find 'DispatchQueue' in scope
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:76: error: cannot infer contextual base in reference to member 'userInteractive'
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                                                                            `- error: cannot infer contextual base in reference to member 'userInteractive'
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:146:17: error: cannot find 'DispatchGroup' in scope
144 |     ]
145 |
146 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
/host/spi-builder-workspace/Sources/SwiftFormat.swift:148:27: error: cannot find 'DispatchQueue' in scope
146 |     let group = DispatchGroup()
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
    |                           `- error: cannot find 'DispatchQueue' in scope
149 |     func onComplete(_ block: @escaping () throws -> Void) {
150 |         completionQueue.async(group: group) {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:30: error: cannot find 'DispatchQueue' in scope
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                              `- error: cannot find 'DispatchQueue' in scope
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:57: error: cannot infer contextual base in reference to member 'userInitiated'
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                                                         `- error: cannot infer contextual base in reference to member 'userInitiated'
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:624:17: error: cannot find 'DispatchGroup' in scope
622 |
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:17: error: cannot find 'DispatchQueue' in scope
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:70: error: cannot infer contextual base in reference to member 'userInteractive'
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:40: error: cannot call value of non-function type 'Date'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:61: error: cannot infer contextual base in reference to member 'timedOut'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
[315/372] Compiling SwiftFormat WrapSingleLineComments.swift
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:27: error: cannot find 'DispatchQueue' in scope
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                           `- error: cannot find 'DispatchQueue' in scope
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:76: error: cannot infer contextual base in reference to member 'userInteractive'
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                                                                            `- error: cannot infer contextual base in reference to member 'userInteractive'
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:146:17: error: cannot find 'DispatchGroup' in scope
144 |     ]
145 |
146 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
/host/spi-builder-workspace/Sources/SwiftFormat.swift:148:27: error: cannot find 'DispatchQueue' in scope
146 |     let group = DispatchGroup()
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
    |                           `- error: cannot find 'DispatchQueue' in scope
149 |     func onComplete(_ block: @escaping () throws -> Void) {
150 |         completionQueue.async(group: group) {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:30: error: cannot find 'DispatchQueue' in scope
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                              `- error: cannot find 'DispatchQueue' in scope
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:57: error: cannot infer contextual base in reference to member 'userInitiated'
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                                                         `- error: cannot infer contextual base in reference to member 'userInitiated'
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:624:17: error: cannot find 'DispatchGroup' in scope
622 |
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:17: error: cannot find 'DispatchQueue' in scope
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:70: error: cannot infer contextual base in reference to member 'userInteractive'
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:40: error: cannot call value of non-function type 'Date'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:61: error: cannot infer contextual base in reference to member 'timedOut'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
[316/372] Compiling SwiftFormat WrapSwitchCases.swift
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:27: error: cannot find 'DispatchQueue' in scope
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                           `- error: cannot find 'DispatchQueue' in scope
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:76: error: cannot infer contextual base in reference to member 'userInteractive'
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                                                                            `- error: cannot infer contextual base in reference to member 'userInteractive'
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:146:17: error: cannot find 'DispatchGroup' in scope
144 |     ]
145 |
146 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
/host/spi-builder-workspace/Sources/SwiftFormat.swift:148:27: error: cannot find 'DispatchQueue' in scope
146 |     let group = DispatchGroup()
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
    |                           `- error: cannot find 'DispatchQueue' in scope
149 |     func onComplete(_ block: @escaping () throws -> Void) {
150 |         completionQueue.async(group: group) {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:30: error: cannot find 'DispatchQueue' in scope
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                              `- error: cannot find 'DispatchQueue' in scope
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:57: error: cannot infer contextual base in reference to member 'userInitiated'
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                                                         `- error: cannot infer contextual base in reference to member 'userInitiated'
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:624:17: error: cannot find 'DispatchGroup' in scope
622 |
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:17: error: cannot find 'DispatchQueue' in scope
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:70: error: cannot infer contextual base in reference to member 'userInteractive'
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:40: error: cannot call value of non-function type 'Date'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:61: error: cannot infer contextual base in reference to member 'timedOut'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
[317/372] Compiling SwiftFormat YodaConditions.swift
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:27: error: cannot find 'DispatchQueue' in scope
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                           `- error: cannot find 'DispatchQueue' in scope
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:76: error: cannot infer contextual base in reference to member 'userInteractive'
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                                                                            `- error: cannot infer contextual base in reference to member 'userInteractive'
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:146:17: error: cannot find 'DispatchGroup' in scope
144 |     ]
145 |
146 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
/host/spi-builder-workspace/Sources/SwiftFormat.swift:148:27: error: cannot find 'DispatchQueue' in scope
146 |     let group = DispatchGroup()
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
    |                           `- error: cannot find 'DispatchQueue' in scope
149 |     func onComplete(_ block: @escaping () throws -> Void) {
150 |         completionQueue.async(group: group) {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:30: error: cannot find 'DispatchQueue' in scope
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                              `- error: cannot find 'DispatchQueue' in scope
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:57: error: cannot infer contextual base in reference to member 'userInitiated'
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                                                         `- error: cannot infer contextual base in reference to member 'userInitiated'
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:624:17: error: cannot find 'DispatchGroup' in scope
622 |
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:17: error: cannot find 'DispatchQueue' in scope
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:70: error: cannot infer contextual base in reference to member 'userInteractive'
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:40: error: cannot call value of non-function type 'Date'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:61: error: cannot infer contextual base in reference to member 'timedOut'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
[318/372] Compiling SwiftFormat SARIFReporter.swift
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:27: error: cannot find 'DispatchQueue' in scope
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                           `- error: cannot find 'DispatchQueue' in scope
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:76: error: cannot infer contextual base in reference to member 'userInteractive'
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                                                                            `- error: cannot infer contextual base in reference to member 'userInteractive'
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:146:17: error: cannot find 'DispatchGroup' in scope
144 |     ]
145 |
146 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
/host/spi-builder-workspace/Sources/SwiftFormat.swift:148:27: error: cannot find 'DispatchQueue' in scope
146 |     let group = DispatchGroup()
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
    |                           `- error: cannot find 'DispatchQueue' in scope
149 |     func onComplete(_ block: @escaping () throws -> Void) {
150 |         completionQueue.async(group: group) {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:30: error: cannot find 'DispatchQueue' in scope
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                              `- error: cannot find 'DispatchQueue' in scope
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:57: error: cannot infer contextual base in reference to member 'userInitiated'
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                                                         `- error: cannot infer contextual base in reference to member 'userInitiated'
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:624:17: error: cannot find 'DispatchGroup' in scope
622 |
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:17: error: cannot find 'DispatchQueue' in scope
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:70: error: cannot infer contextual base in reference to member 'userInteractive'
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:40: error: cannot call value of non-function type 'Date'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:61: error: cannot infer contextual base in reference to member 'timedOut'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
[319/372] Compiling SwiftFormat Singularize.swift
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:27: error: cannot find 'DispatchQueue' in scope
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                           `- error: cannot find 'DispatchQueue' in scope
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:76: error: cannot infer contextual base in reference to member 'userInteractive'
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                                                                            `- error: cannot infer contextual base in reference to member 'userInteractive'
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:146:17: error: cannot find 'DispatchGroup' in scope
144 |     ]
145 |
146 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
/host/spi-builder-workspace/Sources/SwiftFormat.swift:148:27: error: cannot find 'DispatchQueue' in scope
146 |     let group = DispatchGroup()
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
    |                           `- error: cannot find 'DispatchQueue' in scope
149 |     func onComplete(_ block: @escaping () throws -> Void) {
150 |         completionQueue.async(group: group) {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:30: error: cannot find 'DispatchQueue' in scope
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                              `- error: cannot find 'DispatchQueue' in scope
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:57: error: cannot infer contextual base in reference to member 'userInitiated'
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                                                         `- error: cannot infer contextual base in reference to member 'userInitiated'
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:624:17: error: cannot find 'DispatchGroup' in scope
622 |
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:17: error: cannot find 'DispatchQueue' in scope
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:70: error: cannot infer contextual base in reference to member 'userInteractive'
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:40: error: cannot call value of non-function type 'Date'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:61: error: cannot infer contextual base in reference to member 'timedOut'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
[320/372] Compiling SwiftFormat SwiftFormat.swift
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:27: error: cannot find 'DispatchQueue' in scope
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                           `- error: cannot find 'DispatchQueue' in scope
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:76: error: cannot infer contextual base in reference to member 'userInteractive'
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                                                                            `- error: cannot infer contextual base in reference to member 'userInteractive'
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:146:17: error: cannot find 'DispatchGroup' in scope
144 |     ]
145 |
146 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
/host/spi-builder-workspace/Sources/SwiftFormat.swift:148:27: error: cannot find 'DispatchQueue' in scope
146 |     let group = DispatchGroup()
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
    |                           `- error: cannot find 'DispatchQueue' in scope
149 |     func onComplete(_ block: @escaping () throws -> Void) {
150 |         completionQueue.async(group: group) {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:30: error: cannot find 'DispatchQueue' in scope
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                              `- error: cannot find 'DispatchQueue' in scope
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:57: error: cannot infer contextual base in reference to member 'userInitiated'
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                                                         `- error: cannot infer contextual base in reference to member 'userInitiated'
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:624:17: error: cannot find 'DispatchGroup' in scope
622 |
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:17: error: cannot find 'DispatchQueue' in scope
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:70: error: cannot infer contextual base in reference to member 'userInteractive'
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:40: error: cannot call value of non-function type 'Date'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:61: error: cannot infer contextual base in reference to member 'timedOut'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
[321/372] Compiling SwiftFormat Tokenizer.swift
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:27: error: cannot find 'DispatchQueue' in scope
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                           `- error: cannot find 'DispatchQueue' in scope
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:76: error: cannot infer contextual base in reference to member 'userInteractive'
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                                                                            `- error: cannot infer contextual base in reference to member 'userInteractive'
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:146:17: error: cannot find 'DispatchGroup' in scope
144 |     ]
145 |
146 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
/host/spi-builder-workspace/Sources/SwiftFormat.swift:148:27: error: cannot find 'DispatchQueue' in scope
146 |     let group = DispatchGroup()
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
    |                           `- error: cannot find 'DispatchQueue' in scope
149 |     func onComplete(_ block: @escaping () throws -> Void) {
150 |         completionQueue.async(group: group) {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:30: error: cannot find 'DispatchQueue' in scope
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                              `- error: cannot find 'DispatchQueue' in scope
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:57: error: cannot infer contextual base in reference to member 'userInitiated'
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                                                         `- error: cannot infer contextual base in reference to member 'userInitiated'
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:624:17: error: cannot find 'DispatchGroup' in scope
622 |
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:17: error: cannot find 'DispatchQueue' in scope
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:70: error: cannot infer contextual base in reference to member 'userInteractive'
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:40: error: cannot call value of non-function type 'Date'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:61: error: cannot infer contextual base in reference to member 'timedOut'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
[322/372] Compiling SwiftFormat TypeName.swift
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:27: error: cannot find 'DispatchQueue' in scope
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                           `- error: cannot find 'DispatchQueue' in scope
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:76: error: cannot infer contextual base in reference to member 'userInteractive'
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                                                                            `- error: cannot infer contextual base in reference to member 'userInteractive'
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:146:17: error: cannot find 'DispatchGroup' in scope
144 |     ]
145 |
146 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
/host/spi-builder-workspace/Sources/SwiftFormat.swift:148:27: error: cannot find 'DispatchQueue' in scope
146 |     let group = DispatchGroup()
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
    |                           `- error: cannot find 'DispatchQueue' in scope
149 |     func onComplete(_ block: @escaping () throws -> Void) {
150 |         completionQueue.async(group: group) {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:30: error: cannot find 'DispatchQueue' in scope
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                              `- error: cannot find 'DispatchQueue' in scope
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:57: error: cannot infer contextual base in reference to member 'userInitiated'
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                                                         `- error: cannot infer contextual base in reference to member 'userInitiated'
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:624:17: error: cannot find 'DispatchGroup' in scope
622 |
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:17: error: cannot find 'DispatchQueue' in scope
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:70: error: cannot infer contextual base in reference to member 'userInteractive'
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:40: error: cannot call value of non-function type 'Date'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:61: error: cannot infer contextual base in reference to member 'timedOut'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
[323/372] Compiling SwiftFormat XMLReporter.swift
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:27: error: cannot find 'DispatchQueue' in scope
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                           `- error: cannot find 'DispatchQueue' in scope
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:347:76: error: cannot infer contextual base in reference to member 'userInteractive'
345 | /// Process configuration files in specified directory.
346 | private var configCache = [URL: [[String: String]]]()
347 | private let configQueue = DispatchQueue(label: "swiftformat.config", qos: .userInteractive)
    |                                                                            `- error: cannot infer contextual base in reference to member 'userInteractive'
348 | private func processDirectory(_ inputURL: URL, with options: inout Options, logger: Logger?) throws {
349 |     let inputURL = inputURL.standardizedFileURL
/host/spi-builder-workspace/Sources/SwiftFormat.swift:146:17: error: cannot find 'DispatchGroup' in scope
144 |     ]
145 |
146 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
/host/spi-builder-workspace/Sources/SwiftFormat.swift:148:27: error: cannot find 'DispatchQueue' in scope
146 |     let group = DispatchGroup()
147 |     var completionBlocks = [() throws -> Void]()
148 |     let completionQueue = DispatchQueue(label: "swiftformat.enumeration")
    |                           `- error: cannot find 'DispatchQueue' in scope
149 |     func onComplete(_ block: @escaping () throws -> Void) {
150 |         completionQueue.async(group: group) {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:30: error: cannot find 'DispatchQueue' in scope
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                              `- error: cannot find 'DispatchQueue' in scope
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:155:57: error: cannot infer contextual base in reference to member 'userInitiated'
153 |     }
154 |
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
    |                                                         `- error: cannot infer contextual base in reference to member 'userInitiated'
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
/host/spi-builder-workspace/Sources/SwiftFormat.swift:624:17: error: cannot find 'DispatchGroup' in scope
622 |
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:17: error: cannot find 'DispatchQueue' in scope
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:625:70: error: cannot infer contextual base in reference to member 'userInteractive'
623 |     // Recursively apply rules until no changes are detected
624 |     let group = DispatchGroup()
625 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
626 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
627 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:40: error: cannot call value of non-function type 'Date'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:636:61: error: cannot infer contextual base in reference to member 'timedOut'
634 |                 rule.apply(with: formatter)
635 |             }
636 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
637 |                 throw FormatError.writing("\(rule.name) rule timed out")
638 |             }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:151:13: warning: mutation of captured var 'completionBlocks' in concurrently-executing code; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
149 |     func onComplete(_ block: @escaping () throws -> Void) {
150 |         completionQueue.async(group: group) {
151 |             completionBlocks.append(block)
    |             `- warning: mutation of captured var 'completionBlocks' in concurrently-executing code; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
152 |         }
153 |     }
/host/spi-builder-workspace/Sources/SwiftFormat.swift:206:10: warning: concurrently-executed local function 'enumerate(inputURL:outputURL:options:)' must be marked as '@Sendable'; this is an error in the Swift 6 language mode
204 |     }
205 |
206 |     func enumerate(inputURL: URL,
    |          `- warning: concurrently-executed local function 'enumerate(inputURL:outputURL:options:)' must be marked as '@Sendable'; this is an error in the Swift 6 language mode
207 |                    outputURL: URL?,
208 |                    options: Options)
/host/spi-builder-workspace/Sources/SwiftFormat.swift:157:10: warning: concurrently-executed local function 'resolveInputURL(_:options:)' must be marked as '@Sendable'; this is an error in the Swift 6 language mode
155 |     let queue = concurrent ? DispatchQueue.global(qos: .userInitiated) : completionQueue
156 |
157 |     func resolveInputURL(_ inputURL: URL, options: Options) -> (URL, URLResourceValues, Options)? {
    |          `- warning: concurrently-executed local function 'resolveInputURL(_:options:)' must be marked as '@Sendable'; this is an error in the Swift 6 language mode
158 |         let fileOptions = options.fileOptions ?? .default
159 |         let inputURL = inputURL.standardizedFileURL
BUILD FAILURE 6.3 wasm