Swift Package Index

Build Information

Failed to build SwiftFormatterPlugin, reference main (53d24a), with Swift 6.3 for Wasm on 13 Apr 2026 06:08:38 UTC.

Build Command

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

Build Log

 831 |                         } else {
 832 |                             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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:13: error: cannot find 'DispatchQueue' in scope
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:40: error: cannot infer contextual base in reference to member 'userInitiated'
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:919:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 917 |             if let reportURL {
 918 |                 print("Writing report file to \(reportURL.path)", as: .info)
 919 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 920 |             } else {
 921 |                 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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:1357:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1355 |         do {
1356 |             let data = try JSONEncoder().encode(cache)
1357 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1358 |         } catch {
1359 |             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 |
[268/355] Compiling SwiftFormat Formatter.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:830:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 828 |                         if let reportURL {
 829 |                             print("Writing report file to \(reportURL.path)", as: .info)
 830 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 831 |                         } else {
 832 |                             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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:13: error: cannot find 'DispatchQueue' in scope
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:40: error: cannot infer contextual base in reference to member 'userInitiated'
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:919:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 917 |             if let reportURL {
 918 |                 print("Writing report file to \(reportURL.path)", as: .info)
 919 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 920 |             } else {
 921 |                 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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:1357:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1355 |         do {
1356 |             let data = try JSONEncoder().encode(cache)
1357 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1358 |         } catch {
1359 |             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 |
[269/355] Compiling SwiftFormat FormattingHelpers.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:830:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 828 |                         if let reportURL {
 829 |                             print("Writing report file to \(reportURL.path)", as: .info)
 830 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 831 |                         } else {
 832 |                             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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:13: error: cannot find 'DispatchQueue' in scope
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:40: error: cannot infer contextual base in reference to member 'userInitiated'
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:919:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 917 |             if let reportURL {
 918 |                 print("Writing report file to \(reportURL.path)", as: .info)
 919 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 920 |             } else {
 921 |                 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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:1357:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1355 |         do {
1356 |             let data = try JSONEncoder().encode(cache)
1357 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1358 |         } catch {
1359 |             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 |
[270/355] Compiling SwiftFormat GitFileInfo.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:830:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 828 |                         if let reportURL {
 829 |                             print("Writing report file to \(reportURL.path)", as: .info)
 830 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 831 |                         } else {
 832 |                             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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:13: error: cannot find 'DispatchQueue' in scope
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:40: error: cannot infer contextual base in reference to member 'userInitiated'
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:919:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 917 |             if let reportURL {
 918 |                 print("Writing report file to \(reportURL.path)", as: .info)
 919 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 920 |             } else {
 921 |                 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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:1357:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1355 |         do {
1356 |             let data = try JSONEncoder().encode(cache)
1357 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1358 |         } catch {
1359 |             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 |
[271/355] Compiling SwiftFormat GithubActionsLogReporter.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:830:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 828 |                         if let reportURL {
 829 |                             print("Writing report file to \(reportURL.path)", as: .info)
 830 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 831 |                         } else {
 832 |                             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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:13: error: cannot find 'DispatchQueue' in scope
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:40: error: cannot infer contextual base in reference to member 'userInitiated'
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:919:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 917 |             if let reportURL {
 918 |                 print("Writing report file to \(reportURL.path)", as: .info)
 919 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 920 |             } else {
 921 |                 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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:1357:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1355 |         do {
1356 |             let data = try JSONEncoder().encode(cache)
1357 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1358 |         } catch {
1359 |             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 |
[272/355] Compiling SwiftFormat Globs.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:830:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 828 |                         if let reportURL {
 829 |                             print("Writing report file to \(reportURL.path)", as: .info)
 830 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 831 |                         } else {
 832 |                             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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:13: error: cannot find 'DispatchQueue' in scope
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:40: error: cannot infer contextual base in reference to member 'userInitiated'
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:919:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 917 |             if let reportURL {
 918 |                 print("Writing report file to \(reportURL.path)", as: .info)
 919 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 920 |             } else {
 921 |                 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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:1357:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1355 |         do {
1356 |             let data = try JSONEncoder().encode(cache)
1357 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1358 |         } catch {
1359 |             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 |
[273/355] Compiling SwiftFormat Inference.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:830:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 828 |                         if let reportURL {
 829 |                             print("Writing report file to \(reportURL.path)", as: .info)
 830 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 831 |                         } else {
 832 |                             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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:13: error: cannot find 'DispatchQueue' in scope
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:40: error: cannot infer contextual base in reference to member 'userInitiated'
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:919:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 917 |             if let reportURL {
 918 |                 print("Writing report file to \(reportURL.path)", as: .info)
 919 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 920 |             } else {
 921 |                 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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:1357:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1355 |         do {
1356 |             let data = try JSONEncoder().encode(cache)
1357 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1358 |         } catch {
1359 |             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 |
[274/355] Compiling SwiftFormat JSONReporter.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:830:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 828 |                         if let reportURL {
 829 |                             print("Writing report file to \(reportURL.path)", as: .info)
 830 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 831 |                         } else {
 832 |                             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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:13: error: cannot find 'DispatchQueue' in scope
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:40: error: cannot infer contextual base in reference to member 'userInitiated'
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:919:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 917 |             if let reportURL {
 918 |                 print("Writing report file to \(reportURL.path)", as: .info)
 919 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 920 |             } else {
 921 |                 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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:1357:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1355 |         do {
1356 |             let data = try JSONEncoder().encode(cache)
1357 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1358 |         } catch {
1359 |             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 |
[275/355] Compiling SwiftFormat OptionDescriptor.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:830:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 828 |                         if let reportURL {
 829 |                             print("Writing report file to \(reportURL.path)", as: .info)
 830 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 831 |                         } else {
 832 |                             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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:13: error: cannot find 'DispatchQueue' in scope
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:40: error: cannot infer contextual base in reference to member 'userInitiated'
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:919:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 917 |             if let reportURL {
 918 |                 print("Writing report file to \(reportURL.path)", as: .info)
 919 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 920 |             } else {
 921 |                 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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:1357:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1355 |         do {
1356 |             let data = try JSONEncoder().encode(cache)
1357 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1358 |         } catch {
1359 |             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 |
[276/355] Compiling SwiftFormat Options.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:830:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 828 |                         if let reportURL {
 829 |                             print("Writing report file to \(reportURL.path)", as: .info)
 830 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 831 |                         } else {
 832 |                             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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:13: error: cannot find 'DispatchQueue' in scope
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:40: error: cannot infer contextual base in reference to member 'userInitiated'
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:919:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 917 |             if let reportURL {
 918 |                 print("Writing report file to \(reportURL.path)", as: .info)
 919 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 920 |             } else {
 921 |                 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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:1357:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1355 |         do {
1356 |             let data = try JSONEncoder().encode(cache)
1357 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1358 |         } catch {
1359 |             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 |
[277/355] Compiling SwiftFormat ParsingHelpers.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:830:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 828 |                         if let reportURL {
 829 |                             print("Writing report file to \(reportURL.path)", as: .info)
 830 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 831 |                         } else {
 832 |                             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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:13: error: cannot find 'DispatchQueue' in scope
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:40: error: cannot infer contextual base in reference to member 'userInitiated'
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:919:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 917 |             if let reportURL {
 918 |                 print("Writing report file to \(reportURL.path)", as: .info)
 919 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 920 |             } else {
 921 |                 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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:1357:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1355 |         do {
1356 |             let data = try JSONEncoder().encode(cache)
1357 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1358 |         } catch {
1359 |             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 |
[278/355] Compiling SwiftFormat Reporter.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:830:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 828 |                         if let reportURL {
 829 |                             print("Writing report file to \(reportURL.path)", as: .info)
 830 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 831 |                         } else {
 832 |                             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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:13: error: cannot find 'DispatchQueue' in scope
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:40: error: cannot infer contextual base in reference to member 'userInitiated'
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:919:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 917 |             if let reportURL {
 918 |                 print("Writing report file to \(reportURL.path)", as: .info)
 919 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 920 |             } else {
 921 |                 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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:1357:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1355 |         do {
1356 |             let data = try JSONEncoder().encode(cache)
1357 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1358 |         } catch {
1359 |             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 |
[279/355] Compiling SwiftFormat RuleRegistry.generated.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:830:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 828 |                         if let reportURL {
 829 |                             print("Writing report file to \(reportURL.path)", as: .info)
 830 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 831 |                         } else {
 832 |                             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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:13: error: cannot find 'DispatchQueue' in scope
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:40: error: cannot infer contextual base in reference to member 'userInitiated'
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:919:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 917 |             if let reportURL {
 918 |                 print("Writing report file to \(reportURL.path)", as: .info)
 919 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 920 |             } else {
 921 |                 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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:1357:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1355 |         do {
1356 |             let data = try JSONEncoder().encode(cache)
1357 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1358 |         } catch {
1359 |             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 |
[280/355] Compiling SwiftFormat Acronyms.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:830:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 828 |                         if let reportURL {
 829 |                             print("Writing report file to \(reportURL.path)", as: .info)
 830 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 831 |                         } else {
 832 |                             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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:13: error: cannot find 'DispatchQueue' in scope
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:40: error: cannot infer contextual base in reference to member 'userInitiated'
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:919:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 917 |             if let reportURL {
 918 |                 print("Writing report file to \(reportURL.path)", as: .info)
 919 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 920 |             } else {
 921 |                 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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:1357:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1355 |         do {
1356 |             let data = try JSONEncoder().encode(cache)
1357 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1358 |         } catch {
1359 |             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 |
[281/355] Compiling SwiftFormat AndOperator.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:830:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 828 |                         if let reportURL {
 829 |                             print("Writing report file to \(reportURL.path)", as: .info)
 830 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 831 |                         } else {
 832 |                             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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:13: error: cannot find 'DispatchQueue' in scope
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:40: error: cannot infer contextual base in reference to member 'userInitiated'
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:919:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 917 |             if let reportURL {
 918 |                 print("Writing report file to \(reportURL.path)", as: .info)
 919 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 920 |             } else {
 921 |                 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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:1357:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1355 |         do {
1356 |             let data = try JSONEncoder().encode(cache)
1357 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1358 |         } catch {
1359 |             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 |
[282/355] Compiling SwiftFormat AnyObjectProtocol.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:830:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 828 |                         if let reportURL {
 829 |                             print("Writing report file to \(reportURL.path)", as: .info)
 830 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 831 |                         } else {
 832 |                             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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:13: error: cannot find 'DispatchQueue' in scope
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:40: error: cannot infer contextual base in reference to member 'userInitiated'
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:919:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 917 |             if let reportURL {
 918 |                 print("Writing report file to \(reportURL.path)", as: .info)
 919 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 920 |             } else {
 921 |                 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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:1357:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1355 |         do {
1356 |             let data = try JSONEncoder().encode(cache)
1357 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1358 |         } catch {
1359 |             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 |
[283/355] Compiling SwiftFormat ApplicationMain.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:830:79: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 828 |                         if let reportURL {
 829 |                             print("Writing report file to \(reportURL.path)", as: .info)
 830 |                             try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                               `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 831 |                         } else {
 832 |                             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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:13: error: cannot find 'DispatchQueue' in scope
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |             `- error: cannot find 'DispatchQueue' in scope
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:867:40: error: cannot infer contextual base in reference to member 'userInitiated'
 865 |         } else if inputURLs.isEmpty {
 866 |             // If no input file, try stdin
 867 |             DispatchQueue.global(qos: .userInitiated).async {
     |                                        `- error: cannot infer contextual base in reference to member 'userInitiated'
 868 |                 processFromStdin()
 869 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:919:67: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 917 |             if let reportURL {
 918 |                 print("Writing report file to \(reportURL.path)", as: .info)
 919 |                 try reporterOutput.write(to: reportURL, options: .atomic)
     |                                                                   `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
 920 |             } else {
 921 |                 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/.build/checkouts/SwiftFormat/Sources/CommandLine.swift:1357:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1355 |         do {
1356 |             let data = try JSONEncoder().encode(cache)
1357 |             try data.write(to: cacheURL, options: .atomic)
     |                                                    `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
1358 |         } catch {
1359 |             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 |
[284/355] Compiling SwiftFormat Wrap.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:614:17: error: cannot find 'DispatchGroup' in scope
612 |
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:17: error: cannot find 'DispatchQueue' in scope
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:70: error: cannot infer contextual base in reference to member 'userInteractive'
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:40: error: cannot call value of non-function type 'Date'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:61: error: cannot infer contextual base in reference to member 'timedOut'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
[285/355] Compiling SwiftFormat WrapArguments.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:614:17: error: cannot find 'DispatchGroup' in scope
612 |
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:17: error: cannot find 'DispatchQueue' in scope
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:70: error: cannot infer contextual base in reference to member 'userInteractive'
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:40: error: cannot call value of non-function type 'Date'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:61: error: cannot infer contextual base in reference to member 'timedOut'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
[286/355] Compiling SwiftFormat WrapAttributes.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:614:17: error: cannot find 'DispatchGroup' in scope
612 |
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:17: error: cannot find 'DispatchQueue' in scope
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:70: error: cannot infer contextual base in reference to member 'userInteractive'
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:40: error: cannot call value of non-function type 'Date'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:61: error: cannot infer contextual base in reference to member 'timedOut'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
[287/355] Compiling SwiftFormat WrapCaseBodies.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:614:17: error: cannot find 'DispatchGroup' in scope
612 |
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:17: error: cannot find 'DispatchQueue' in scope
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:70: error: cannot infer contextual base in reference to member 'userInteractive'
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:40: error: cannot call value of non-function type 'Date'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:61: error: cannot infer contextual base in reference to member 'timedOut'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
[288/355] Compiling SwiftFormat WrapConditionalBodies.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:614:17: error: cannot find 'DispatchGroup' in scope
612 |
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:17: error: cannot find 'DispatchQueue' in scope
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:70: error: cannot infer contextual base in reference to member 'userInteractive'
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:40: error: cannot call value of non-function type 'Date'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:61: error: cannot infer contextual base in reference to member 'timedOut'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
[289/355] Compiling SwiftFormat WrapEnumCases.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:614:17: error: cannot find 'DispatchGroup' in scope
612 |
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:17: error: cannot find 'DispatchQueue' in scope
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:70: error: cannot infer contextual base in reference to member 'userInteractive'
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:40: error: cannot call value of non-function type 'Date'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:61: error: cannot infer contextual base in reference to member 'timedOut'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
[290/355] Compiling SwiftFormat WrapFunctionBodies.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:614:17: error: cannot find 'DispatchGroup' in scope
612 |
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:17: error: cannot find 'DispatchQueue' in scope
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:70: error: cannot infer contextual base in reference to member 'userInteractive'
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:40: error: cannot call value of non-function type 'Date'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:61: error: cannot infer contextual base in reference to member 'timedOut'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
[291/355] Compiling SwiftFormat WrapLoopBodies.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:614:17: error: cannot find 'DispatchGroup' in scope
612 |
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:17: error: cannot find 'DispatchQueue' in scope
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:70: error: cannot infer contextual base in reference to member 'userInteractive'
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:40: error: cannot call value of non-function type 'Date'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:61: error: cannot infer contextual base in reference to member 'timedOut'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
[292/355] Compiling SwiftFormat WrapMultilineConditionalAssignment.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:614:17: error: cannot find 'DispatchGroup' in scope
612 |
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:17: error: cannot find 'DispatchQueue' in scope
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:70: error: cannot infer contextual base in reference to member 'userInteractive'
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:40: error: cannot call value of non-function type 'Date'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:61: error: cannot infer contextual base in reference to member 'timedOut'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
[293/355] Compiling SwiftFormat WrapMultilineFunctionChains.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:614:17: error: cannot find 'DispatchGroup' in scope
612 |
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:17: error: cannot find 'DispatchQueue' in scope
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:70: error: cannot infer contextual base in reference to member 'userInteractive'
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:40: error: cannot call value of non-function type 'Date'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:61: error: cannot infer contextual base in reference to member 'timedOut'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
[294/355] Compiling SwiftFormat WrapMultilineStatementBraces.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:614:17: error: cannot find 'DispatchGroup' in scope
612 |
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:17: error: cannot find 'DispatchQueue' in scope
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:70: error: cannot infer contextual base in reference to member 'userInteractive'
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:40: error: cannot call value of non-function type 'Date'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:61: error: cannot infer contextual base in reference to member 'timedOut'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
[295/355] Compiling SwiftFormat WrapPropertyBodies.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:614:17: error: cannot find 'DispatchGroup' in scope
612 |
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:17: error: cannot find 'DispatchQueue' in scope
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:70: error: cannot infer contextual base in reference to member 'userInteractive'
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:40: error: cannot call value of non-function type 'Date'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:61: error: cannot infer contextual base in reference to member 'timedOut'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
[296/355] Compiling SwiftFormat WrapSingleLineComments.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:614:17: error: cannot find 'DispatchGroup' in scope
612 |
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:17: error: cannot find 'DispatchQueue' in scope
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:70: error: cannot infer contextual base in reference to member 'userInteractive'
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:40: error: cannot call value of non-function type 'Date'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:61: error: cannot infer contextual base in reference to member 'timedOut'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
[297/355] Compiling SwiftFormat WrapSwitchCases.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:614:17: error: cannot find 'DispatchGroup' in scope
612 |
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:17: error: cannot find 'DispatchQueue' in scope
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:70: error: cannot infer contextual base in reference to member 'userInteractive'
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:40: error: cannot call value of non-function type 'Date'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:61: error: cannot infer contextual base in reference to member 'timedOut'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
[298/355] Compiling SwiftFormat YodaConditions.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:614:17: error: cannot find 'DispatchGroup' in scope
612 |
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:17: error: cannot find 'DispatchQueue' in scope
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:70: error: cannot infer contextual base in reference to member 'userInteractive'
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:40: error: cannot call value of non-function type 'Date'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:61: error: cannot infer contextual base in reference to member 'timedOut'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
[299/355] Compiling SwiftFormat SARIFReporter.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:614:17: error: cannot find 'DispatchGroup' in scope
612 |
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:17: error: cannot find 'DispatchQueue' in scope
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:70: error: cannot infer contextual base in reference to member 'userInteractive'
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:40: error: cannot call value of non-function type 'Date'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:61: error: cannot infer contextual base in reference to member 'timedOut'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
[300/355] Compiling SwiftFormat Singularize.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:614:17: error: cannot find 'DispatchGroup' in scope
612 |
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:17: error: cannot find 'DispatchQueue' in scope
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:70: error: cannot infer contextual base in reference to member 'userInteractive'
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:40: error: cannot call value of non-function type 'Date'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:61: error: cannot infer contextual base in reference to member 'timedOut'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
[301/355] Compiling SwiftFormat SwiftFormat.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:614:17: error: cannot find 'DispatchGroup' in scope
612 |
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:17: error: cannot find 'DispatchQueue' in scope
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:70: error: cannot infer contextual base in reference to member 'userInteractive'
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:40: error: cannot call value of non-function type 'Date'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:61: error: cannot infer contextual base in reference to member 'timedOut'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
[302/355] Compiling SwiftFormat Tokenizer.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:614:17: error: cannot find 'DispatchGroup' in scope
612 |
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:17: error: cannot find 'DispatchQueue' in scope
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:70: error: cannot infer contextual base in reference to member 'userInteractive'
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:40: error: cannot call value of non-function type 'Date'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:61: error: cannot infer contextual base in reference to member 'timedOut'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
[303/355] Compiling SwiftFormat TypeName.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:614:17: error: cannot find 'DispatchGroup' in scope
612 |
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:17: error: cannot find 'DispatchQueue' in scope
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:70: error: cannot infer contextual base in reference to member 'userInteractive'
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:40: error: cannot call value of non-function type 'Date'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:61: error: cannot infer contextual base in reference to member 'timedOut'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
[304/355] Compiling SwiftFormat XMLReporter.swift
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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 |     if let args = configQueue.sync(execute: { configCache[inputURL] }) {
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/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/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:614:17: error: cannot find 'DispatchGroup' in scope
612 |
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:17: error: cannot find 'DispatchQueue' in scope
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                 `- error: cannot find 'DispatchQueue' in scope
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:615:70: error: cannot infer contextual base in reference to member 'userInteractive'
613 |     // Recursively apply rules until no changes are detected
614 |     let group = DispatchGroup()
615 |     let queue = DispatchQueue(label: "swiftformat.formatting", qos: .userInteractive)
    |                                                                      `- error: cannot infer contextual base in reference to member 'userInteractive'
616 |     let timeout = options.timeout + TimeInterval(originalTokens.count) / 1000
617 |     var changes = [Formatter.Change]()
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:40: error: cannot call value of non-function type 'Date'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                        `- error: cannot call value of non-function type 'Date'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
/host/spi-builder-workspace/.build/checkouts/SwiftFormat/Sources/SwiftFormat.swift:626:61: error: cannot infer contextual base in reference to member 'timedOut'
624 |                 rule.apply(with: formatter)
625 |             }
626 |             guard group.wait(timeout: .now() + timeout) != .timedOut else {
    |                                                             `- error: cannot infer contextual base in reference to member 'timedOut'
627 |                 throw FormatError.writing("\(rule.name) rule timed out")
628 |             }
BUILD FAILURE 6.3 wasm