From fc7c4ee78b9309894941cdc95a07b647dba03025 Mon Sep 17 00:00:00 2001 From: Yuta Saito Date: Thu, 4 May 2023 01:58:35 +0900 Subject: [PATCH 1/8] Update SwiftPM branch to 5.8 and fix build errors --- Package.resolved | 24 +++++++++---------- Package.swift | 6 ++--- Sources/CartonCLI/Commands/Bundle.swift | 2 +- Sources/CartonCLI/Commands/SDK/Local.swift | 2 +- Sources/CartonCLI/Commands/SDK/Versions.swift | 2 +- .../Commands/TestRunners/NodeTestRunner.swift | 2 +- Sources/CartonKit/Model/Entrypoint.swift | 6 ++--- Sources/SwiftToolchain/Builder.swift | 2 +- Sources/SwiftToolchain/Toolchain.swift | 2 +- .../SwiftToolchain/ToolchainManagement.swift | 6 ++--- .../SwiftToolchain/ToolchainResolver.swift | 8 +++---- Sources/carton-release/HashArchive.swift | 2 +- 12 files changed, 32 insertions(+), 32 deletions(-) diff --git a/Package.resolved b/Package.resolved index b310b7c7..25d7bb47 100644 --- a/Package.resolved +++ b/Package.resolved @@ -105,16 +105,16 @@ "repositoryURL": "https://github.com/apple/swift-crypto.git", "state": { "branch": null, - "revision": "ddb07e896a2a8af79512543b1c7eb9797f8898a5", - "version": "1.1.7" + "revision": "75ec60b8b4cc0f085c3ac414f3dca5625fa3588e", + "version": "2.2.4" } }, { "package": "swift-driver", "repositoryURL": "https://github.com/apple/swift-driver.git", "state": { - "branch": "release/5.7", - "revision": "719426df790661020de657bf38beb2a8b1de5ad3", + "branch": "release/5.8", + "revision": "7cfe0c0b6e6297efe88a3ce34e6138ee7eda969e", "version": null } }, @@ -122,8 +122,8 @@ "package": "llbuild", "repositoryURL": "https://github.com/apple/swift-llbuild.git", "state": { - "branch": "release/5.7", - "revision": "564424db5fdb62dcb5d863bdf7212500ef03a87b", + "branch": "release/5.8", + "revision": "dccfc2e127a34b89a849407594cf2d604b598ba9", "version": null } }, @@ -203,8 +203,8 @@ "package": "SwiftPM", "repositoryURL": "https://github.com/apple/swift-package-manager.git", "state": { - "branch": "release/5.7", - "revision": "63c14b84dc12c943a9d4c102648b7617d8b92f67", + "branch": "release/5.8", + "revision": "fe383ccb099ff65ca1403137e7383aedaf99af87", "version": null } }, @@ -221,8 +221,8 @@ "package": "swift-tools-support-core", "repositoryURL": "https://github.com/apple/swift-tools-support-core.git", "state": { - "branch": "release/5.7", - "revision": "184eba382f6abbb362ffc02942d790ff35019ad4", + "branch": "release/5.8", + "revision": "ac4871e01ef338cb95b5d28328cab0ec1dfae935", "version": null } }, @@ -258,8 +258,8 @@ "repositoryURL": "https://github.com/jpsim/Yams.git", "state": { "branch": null, - "revision": "9ff1cc9327586db4e0c8f46f064b6a82ec1566fa", - "version": "4.0.6" + "revision": "f47ba4838c30dbd59998a4e4c87ab620ff959e8a", + "version": "5.0.5" } } ] diff --git a/Package.swift b/Package.swift index 4a8f5920..3f54b99f 100644 --- a/Package.swift +++ b/Package.swift @@ -27,14 +27,14 @@ let package = Package( .package( name: "SwiftPM", url: "https://github.com/apple/swift-package-manager.git", - .branch("release/5.7") + .branch("release/5.8") ), .package( url: "https://github.com/apple/swift-tools-support-core.git", - .branch("release/5.7") + .branch("release/5.8") ), .package(url: "https://github.com/vapor/vapor.git", from: "4.57.1"), - .package(url: "https://github.com/apple/swift-crypto.git", from: "1.1.0"), + .package(url: "https://github.com/apple/swift-crypto.git", from: "2.2.0"), .package(url: "https://github.com/JohnSundell/Splash.git", from: "0.16.0"), .package( url: "https://github.com/swiftwasm/WasmTransformer", diff --git a/Sources/CartonCLI/Commands/Bundle.swift b/Sources/CartonCLI/Commands/Bundle.swift index 98f098df..28abf80a 100644 --- a/Sources/CartonCLI/Commands/Bundle.swift +++ b/Sources/CartonCLI/Commands/Bundle.swift @@ -156,7 +156,7 @@ struct Bundle: AsyncParsableCommand { try localFileSystem.move(from: wasmOutputFilePath, to: mainModulePath) // Copy the bundle entrypoint, point to the binary, and give it a cachebuster name. - let (_, _, entrypointPath) = dependency.paths(on: localFileSystem) + let (_, _, entrypointPath) = try dependency.paths(on: localFileSystem) let entrypoint = try ByteString( encodingAsUTF8: localFileSystem.readFileContents(entrypointPath) .description diff --git a/Sources/CartonCLI/Commands/SDK/Local.swift b/Sources/CartonCLI/Commands/SDK/Local.swift index 81046ee9..bca2abd4 100644 --- a/Sources/CartonCLI/Commands/SDK/Local.swift +++ b/Sources/CartonCLI/Commands/SDK/Local.swift @@ -27,7 +27,7 @@ struct Local: ParsableCommand { func run() throws { let terminal = InteractiveWriter.stdout - let toolchainSystem = ToolchainSystem(fileSystem: localFileSystem) + let toolchainSystem = try ToolchainSystem(fileSystem: localFileSystem) if let version = version { let versions = try toolchainSystem.fetchAllSwiftVersions() diff --git a/Sources/CartonCLI/Commands/SDK/Versions.swift b/Sources/CartonCLI/Commands/SDK/Versions.swift index b07f1869..a1f640c1 100644 --- a/Sources/CartonCLI/Commands/SDK/Versions.swift +++ b/Sources/CartonCLI/Commands/SDK/Versions.swift @@ -25,7 +25,7 @@ struct Versions: ParsableCommand { func run() throws { let terminal = InteractiveWriter.stdout - let toolchainSystem = ToolchainSystem(fileSystem: localFileSystem) + let toolchainSystem = try ToolchainSystem(fileSystem: localFileSystem) let versions = try toolchainSystem.fetchAllSwiftVersions() let localVersion = try toolchainSystem.fetchLocalSwiftVersion() if versions.count > 0 { diff --git a/Sources/CartonCLI/Commands/TestRunners/NodeTestRunner.swift b/Sources/CartonCLI/Commands/TestRunners/NodeTestRunner.swift index ebf06d97..e699686f 100644 --- a/Sources/CartonCLI/Commands/TestRunners/NodeTestRunner.swift +++ b/Sources/CartonCLI/Commands/TestRunners/NodeTestRunner.swift @@ -32,7 +32,7 @@ struct NodeTestRunner: TestRunner { terminal.write("\nRunning the test bundle with Node.js:\n", inColor: .yellow) try Constants.entrypoint.check(on: localFileSystem, terminal) - let (_, _, entrypointPath) = Constants.entrypoint.paths(on: localFileSystem) + let (_, _, entrypointPath) = try Constants.entrypoint.paths(on: localFileSystem) // Allow Node.js to resolve modules from resource directories by making them relative to the entrypoint path. let buildDirectory = testFilePath.parentDirectory diff --git a/Sources/CartonKit/Model/Entrypoint.swift b/Sources/CartonKit/Model/Entrypoint.swift index 80a3c84f..b7d5c01c 100644 --- a/Sources/CartonKit/Model/Entrypoint.swift +++ b/Sources/CartonKit/Model/Entrypoint.swift @@ -33,14 +33,14 @@ public struct Entrypoint { public func paths( on fileSystem: FileSystem // swiftlint:disable:next large_tuple - ) -> (cartonDir: AbsolutePath, staticDir: AbsolutePath, filePath: AbsolutePath) { - let cartonDir = fileSystem.homeDirectory.appending(component: ".carton") + ) throws -> (cartonDir: AbsolutePath, staticDir: AbsolutePath, filePath: AbsolutePath) { + let cartonDir = try fileSystem.homeDirectory.appending(component: ".carton") let staticDir = cartonDir.appending(component: "static") return (cartonDir, staticDir, staticDir.appending(component: fileName)) } public func check(on fileSystem: FileSystem, _ terminal: InteractiveWriter) throws { - let (cartonDir, staticDir, filePath) = paths(on: fileSystem) + let (cartonDir, staticDir, filePath) = try paths(on: fileSystem) // If hash check fails, download the `static.zip` archive and unpack it if try !fileSystem.exists(filePath) || SHA256().hash( diff --git a/Sources/SwiftToolchain/Builder.swift b/Sources/SwiftToolchain/Builder.swift index d1dc7def..4403c62c 100644 --- a/Sources/SwiftToolchain/Builder.swift +++ b/Sources/SwiftToolchain/Builder.swift @@ -109,7 +109,7 @@ public final class Builder { return try await buildWithoutSanitizing(builderArguments: arguments) case .stackOverflow: let sanitizerFile = - fileSystem.homeDirectory.appending(components: ".carton", "static", "so_sanitizer.wasm") + try fileSystem.homeDirectory.appending(components: ".carton", "static", "so_sanitizer.wasm") var modifiedArguments = arguments modifiedArguments.append(contentsOf: [ diff --git a/Sources/SwiftToolchain/Toolchain.swift b/Sources/SwiftToolchain/Toolchain.swift index e7f00f06..afe71c0b 100644 --- a/Sources/SwiftToolchain/Toolchain.swift +++ b/Sources/SwiftToolchain/Toolchain.swift @@ -119,7 +119,7 @@ public final class Toolchain { _ fileSystem: FileSystem, _ terminal: InteractiveWriter ) async throws { - let toolchainSystem = ToolchainSystem(fileSystem: fileSystem) + let toolchainSystem = try ToolchainSystem(fileSystem: fileSystem) let (swiftPath, version) = try await toolchainSystem.inferSwiftPath(from: versionSpec, terminal) self.swiftPath = swiftPath self.version = version diff --git a/Sources/SwiftToolchain/ToolchainManagement.swift b/Sources/SwiftToolchain/ToolchainManagement.swift index 331725ff..d338a894 100644 --- a/Sources/SwiftToolchain/ToolchainManagement.swift +++ b/Sources/SwiftToolchain/ToolchainManagement.swift @@ -46,7 +46,7 @@ public class ToolchainSystem { let cartonToolchainResolver: CartonToolchainResolver let resolvers: [ToolchainResolver] - public init(fileSystem: FileSystem) { + public init(fileSystem: FileSystem) throws { self.fileSystem = fileSystem let userLibraryPath = NSSearchPathForDirectoriesInDomains( @@ -69,8 +69,8 @@ public class ToolchainSystem { userXCToolchainResolver, rootXCToolchainResolver, ].compactMap { $0 } - cartonToolchainResolver = CartonToolchainResolver(fileSystem: fileSystem) - resolvers = [ + cartonToolchainResolver = try CartonToolchainResolver(fileSystem: fileSystem) + resolvers = try [ cartonToolchainResolver, SwiftEnvToolchainResolver(fileSystem: fileSystem), ] + xctoolchainResolvers diff --git a/Sources/SwiftToolchain/ToolchainResolver.swift b/Sources/SwiftToolchain/ToolchainResolver.swift index 5eadc334..b099db63 100644 --- a/Sources/SwiftToolchain/ToolchainResolver.swift +++ b/Sources/SwiftToolchain/ToolchainResolver.swift @@ -47,8 +47,8 @@ final class SwiftEnvToolchainResolver: ToolchainResolver { let versionsPath: AbsolutePath let fileSystem: FileSystem - init(fileSystem: FileSystem) { - versionsPath = fileSystem.homeDirectory.appending(components: ".swiftenv", "versions") + init(fileSystem: FileSystem) throws { + versionsPath = try fileSystem.homeDirectory.appending(components: ".swiftenv", "versions") self.fileSystem = fileSystem } @@ -68,8 +68,8 @@ final class CartonToolchainResolver: ToolchainResolver { let cartonSDKPath: AbsolutePath let fileSystem: FileSystem - init(fileSystem: FileSystem) { - cartonSDKPath = fileSystem.homeDirectory.appending(components: ".carton", "sdk") + init(fileSystem: FileSystem) throws { + cartonSDKPath = try fileSystem.homeDirectory.appending(components: ".carton", "sdk") self.fileSystem = fileSystem } diff --git a/Sources/carton-release/HashArchive.swift b/Sources/carton-release/HashArchive.swift index e62ed4eb..b5f7ea20 100644 --- a/Sources/carton-release/HashArchive.swift +++ b/Sources/carton-release/HashArchive.swift @@ -39,7 +39,7 @@ struct HashArchive: AsyncParsableCommand { let terminal = InteractiveWriter.stdout let cwd = localFileSystem.currentWorkingDirectory! let staticPath = AbsolutePath(cwd, "static") - let dotFilesStaticPath = localFileSystem.homeDirectory.appending( + let dotFilesStaticPath = try localFileSystem.homeDirectory.appending( components: ".carton", "static" ) From 3b5b102280a4be0153bdf8ad5d8ffd159a22bf27 Mon Sep 17 00:00:00 2001 From: Yuta Saito Date: Thu, 4 May 2023 02:08:56 +0900 Subject: [PATCH 2/8] Make swift-format 5.8 happy :) --- Sources/CartonCLI/Commands/Bundle.swift | 19 ++-- Sources/CartonCLI/Commands/Dev.swift | 4 +- Sources/CartonCLI/Commands/Init.swift | 18 ++-- Sources/CartonCLI/Commands/Options.swift | 7 +- Sources/CartonCLI/Commands/Package.swift | 7 +- Sources/CartonCLI/Commands/SDK/Local.swift | 11 ++- Sources/CartonCLI/Commands/Test.swift | 5 +- .../TestRunners/BrowserTestRunner.swift | 25 ++--- .../Commands/TestRunners/NodeTestRunner.swift | 6 +- Sources/CartonHelpers/Async.swift | 12 +-- Sources/CartonHelpers/AsyncFileDownload.swift | 5 +- Sources/CartonHelpers/FileSystem.swift | 12 +-- Sources/CartonHelpers/HTTPClient.swift | 9 +- .../Parsers/ChromeStackTrace.swift | 11 +-- .../Parsers/DiagnosticsParser.swift | 49 +++++----- .../Parsers/FirefoxStackTrace.swift | 11 +-- .../Parsers/SafariStackTrace.swift | 9 +- .../CartonHelpers/Parsers/String+Regex.swift | 8 +- .../CartonHelpers/Parsers/TestsParser.swift | 96 +++++++++++-------- Sources/CartonHelpers/Process.swift | 10 +- Sources/CartonHelpers/StackTrace.swift | 7 +- .../CartonHelpers/TerminalController.swift | 19 ++-- Sources/CartonKit/Helpers/ByteString.swift | 4 +- Sources/CartonKit/Helpers/Expectation.swift | 5 +- Sources/CartonKit/Model/Entrypoint.swift | 10 +- Sources/CartonKit/Model/Template.swift | 63 ++++++------ Sources/CartonKit/Server/Application.swift | 16 ++-- Sources/CartonKit/Server/HTML.swift | 45 +++++---- Sources/CartonKit/Server/Server.swift | 16 ++-- Sources/CartonKit/Server/StaticArchive.swift | 11 ++- Sources/SwiftToolchain/Builder.swift | 9 +- .../DestinationEnvironment.swift | 6 +- Sources/SwiftToolchain/Manifest.swift | 9 +- Sources/SwiftToolchain/Toolchain.swift | 45 +++++---- .../ToolchainInstallation.swift | 4 +- .../SwiftToolchain/ToolchainManagement.swift | 72 +++++++------- Sources/WebDriverClient/WebDriverClient.swift | 45 +++++---- Sources/carton-release/Formula.swift | 42 ++++---- Sources/carton-release/HashArchive.swift | 30 +++--- 39 files changed, 426 insertions(+), 366 deletions(-) diff --git a/Sources/CartonCLI/Commands/Bundle.swift b/Sources/CartonCLI/Commands/Bundle.swift index 28abf80a..148c6b7a 100644 --- a/Sources/CartonCLI/Commands/Bundle.swift +++ b/Sources/CartonCLI/Commands/Bundle.swift @@ -49,11 +49,11 @@ struct Bundle: AsyncParsableCommand { @Option( name: .long, help: """ - Which optimizations to apply to the .wasm binary output. - Available values: \( + Which optimizations to apply to the .wasm binary output. + Available values: \( WasmOptimizations.allCases.map(\.rawValue).joined(separator: ", ") ) - """ + """ ) var wasmOptimizations: WasmOptimizations = .size @@ -122,7 +122,9 @@ struct Bundle: AsyncParsableCommand { terminal.write("Bundle generation finished successfully\n", inColor: .green, bold: true) } - func optimize(_ inputPath: AbsolutePath, outputPath: AbsolutePath, terminal: InteractiveWriter) async throws { + func optimize(_ inputPath: AbsolutePath, outputPath: AbsolutePath, terminal: InteractiveWriter) + async throws + { var wasmOptArgs = ["wasm-opt", "-Os", inputPath.pathString, "-o", outputPath.pathString] if debugInfo { wasmOptArgs.append("--debuginfo") @@ -173,10 +175,11 @@ struct Bundle: AsyncParsableCommand { try localFileSystem.writeFileContents( AbsolutePath(bundleDirectory, "index.html"), - bytes: ByteString(encodingAsUTF8: HTML.indexPage( - customContent: HTML.readCustomIndexPage(at: customIndexPage, on: localFileSystem), - entrypointName: entrypointName - )) + bytes: ByteString( + encodingAsUTF8: HTML.indexPage( + customContent: HTML.readCustomIndexPage(at: customIndexPage, on: localFileSystem), + entrypointName: entrypointName + )) ) let manifest = try toolchain.manifest.get() diff --git a/Sources/CartonCLI/Commands/Dev.swift b/Sources/CartonCLI/Commands/Dev.swift index bb331d26..dedba73c 100644 --- a/Sources/CartonCLI/Commands/Dev.swift +++ b/Sources/CartonCLI/Commands/Dev.swift @@ -126,7 +126,9 @@ struct Dev: AsyncParsableCommand { verbose: verbose, port: port, host: host, - customIndexPath: customIndexPage.map { AbsolutePath($0, relativeTo: localFileSystem.currentWorkingDirectory!) }, + customIndexPath: customIndexPage.map { + AbsolutePath($0, relativeTo: localFileSystem.currentWorkingDirectory!) + }, // swiftlint:disable:next force_try manifest: try! toolchain.manifest.get(), product: build.product, diff --git a/Sources/CartonCLI/Commands/Init.swift b/Sources/CartonCLI/Commands/Init.swift index cdfcda40..906c9ff8 100644 --- a/Sources/CartonCLI/Commands/Init.swift +++ b/Sources/CartonCLI/Commands/Init.swift @@ -25,13 +25,15 @@ struct Init: AsyncParsableCommand { subcommands: [ListTemplates.self] ) - @Option(name: .long, - help: "The template to base the project on.", - transform: { Templates(rawValue: $0.lowercased()) }) + @Option( + name: .long, + help: "The template to base the project on.", + transform: { Templates(rawValue: $0.lowercased()) }) var template: Templates? - @Option(name: .long, - help: "The name of the project") var name: String? + @Option( + name: .long, + help: "The name of the project") var name: String? func run() async throws { let terminal = InteractiveWriter.stdout @@ -50,9 +52,9 @@ struct Init: AsyncParsableCommand { terminal.write(" in ") terminal.write("\(name)\n", inColor: .cyan) - guard let packagePath = self.name == nil ? - localFileSystem.currentWorkingDirectory : - AbsolutePath(name, relativeTo: currentDir) + guard + let packagePath = self.name == nil + ? localFileSystem.currentWorkingDirectory : AbsolutePath(name, relativeTo: currentDir) else { terminal.write("Path to project could be created.\n", inColor: .red) return diff --git a/Sources/CartonCLI/Commands/Options.swift b/Sources/CartonCLI/Commands/Options.swift index 159dbf6f..55a28256 100644 --- a/Sources/CartonCLI/Commands/Options.swift +++ b/Sources/CartonCLI/Commands/Options.swift @@ -15,9 +15,10 @@ import ArgumentParser struct BuildOptions: ParsableArguments { - @Option(name: .customLong("Xswiftc", withSingleDash: true), - parsing: .unconditionalSingleValue, - help: "Pass flag through to all Swift compiler invocations") + @Option( + name: .customLong("Xswiftc", withSingleDash: true), + parsing: .unconditionalSingleValue, + help: "Pass flag through to all Swift compiler invocations") var swiftCompilerFlags: [String] = [] init() {} diff --git a/Sources/CartonCLI/Commands/Package.swift b/Sources/CartonCLI/Commands/Package.swift index 7f9f06f2..6b1d07b1 100644 --- a/Sources/CartonCLI/Commands/Package.swift +++ b/Sources/CartonCLI/Commands/Package.swift @@ -20,9 +20,10 @@ import TSCBasic /// Proxy swift-package command to locally pinned toolchain version. struct Package: AsyncParsableCommand { - static let configuration = CommandConfiguration(abstract: """ - Perform operations on Swift packages. - """) + static let configuration = CommandConfiguration( + abstract: """ + Perform operations on Swift packages. + """) @Argument(wrappedValue: [], parsing: .remaining) var arguments: [String] diff --git a/Sources/CartonCLI/Commands/SDK/Local.swift b/Sources/CartonCLI/Commands/SDK/Local.swift index bca2abd4..7014cff6 100644 --- a/Sources/CartonCLI/Commands/SDK/Local.swift +++ b/Sources/CartonCLI/Commands/SDK/Local.swift @@ -18,17 +18,18 @@ import SwiftToolchain import TSCBasic struct Local: ParsableCommand { - static let configuration = CommandConfiguration(abstract: """ - Prints SDK version used for the current project or saves it \ - in the `.swift-version` file if a version is passed as an argument. - """) + static let configuration = CommandConfiguration( + abstract: """ + Prints SDK version used for the current project or saves it \ + in the `.swift-version` file if a version is passed as an argument. + """) @Argument() var version: String? func run() throws { let terminal = InteractiveWriter.stdout let toolchainSystem = try ToolchainSystem(fileSystem: localFileSystem) - + if let version = version { let versions = try toolchainSystem.fetchAllSwiftVersions() if versions.contains(version) { diff --git a/Sources/CartonCLI/Commands/Test.swift b/Sources/CartonCLI/Commands/Test.swift index 002cd6ab..32937743 100644 --- a/Sources/CartonCLI/Commands/Test.swift +++ b/Sources/CartonCLI/Commands/Test.swift @@ -46,7 +46,7 @@ struct Test: AsyncParsableCommand { private var environment = Environment.wasmer /// It is implemented as a separate flag instead of a `--environment` variant because `--environment` - /// is designed to accept specific browser names in the future like `--environment firefox`. + /// is designed to accept specific browser names in the future like `--environment firefox`. /// Then `--headless` should be able to be used with `defaultBrowser` and other browser values. @Flag(help: "When running browser tests, run the browser in headless mode") var headless: Bool = false @@ -83,7 +83,8 @@ struct Test: AsyncParsableCommand { func validate() throws { if headless && environment != .defaultBrowser { - throw TestError(description: "The `--headless` flag can be applied only for browser environments") + throw TestError( + description: "The `--headless` flag can be applied only for browser environments") } } diff --git a/Sources/CartonCLI/Commands/TestRunners/BrowserTestRunner.swift b/Sources/CartonCLI/Commands/TestRunners/BrowserTestRunner.swift index f73e1655..3597e989 100644 --- a/Sources/CartonCLI/Commands/TestRunners/BrowserTestRunner.swift +++ b/Sources/CartonCLI/Commands/TestRunners/BrowserTestRunner.swift @@ -35,12 +35,12 @@ enum BrowserTestRunnerError: Error, CustomStringConvertible { case let .invalidRemoteURL(url): return "Invalid remote URL: \(url)" case .failedToFindWebDriver: return """ - Failed to find WebDriver executable or remote URL to a running driver process. - Please make sure that you are satisfied with one of the followings (in order of priority) - 1. Set `WEBDRIVER_REMOTE_URL` with the address of remote WebDriver like `WEBDRIVER_REMOTE_URL=http://localhost:9515`. - 2. Set `WEBDRIVER_PATH` with the path to your WebDriver executable. - 3. `chromedriver`, `geckodriver`, `safaridriver`, or `msedgedriver` has been installed in `PATH` - """ + Failed to find WebDriver executable or remote URL to a running driver process. + Please make sure that you are satisfied with one of the followings (in order of priority) + 1. Set `WEBDRIVER_REMOTE_URL` with the address of remote WebDriver like `WEBDRIVER_REMOTE_URL=http://localhost:9515`. + 2. Set `WEBDRIVER_PATH` with the path to your WebDriver executable. + 3. `chromedriver`, `geckodriver`, `safaridriver`, or `msedgedriver` has been installed in `PATH` + """ } } } @@ -72,7 +72,7 @@ struct BrowserTestRunner: TestRunner { httpClient = HTTPClient(eventLoopGroupProvider: .shared(eventLoopGroup)) } - typealias Disposer = () -> () + typealias Disposer = () -> Void func findAvailablePort() async throws -> SocketAddress { let bootstrap = ServerBootstrap(group: eventLoopGroup) @@ -118,8 +118,10 @@ struct BrowserTestRunner: TestRunner { let driverCandidates = [ "chromedriver", "geckodriver", "safaridriver", "msedgedriver", ] - terminal.logLookup("- checking WebDriver executable in PATH: ", driverCandidates.joined(separator: ", ")) - guard let found = driverCandidates.lazy.compactMap({ Process.findExecutable($0) }).first else { + terminal.logLookup( + "- checking WebDriver executable in PATH: ", driverCandidates.joined(separator: ", ")) + guard let found = driverCandidates.lazy.compactMap({ Process.findExecutable($0) }).first + else { return nil } return try await launchDriver(executablePath: found.pathString) @@ -153,11 +155,12 @@ struct BrowserTestRunner: TestRunner { .shared(eventLoopGroup) ) let localURL = try await server.start() - var disposer: () async throws -> () = {} + var disposer: () async throws -> Void = {} do { if headless { let (endpoint, clientDisposer) = try await selectWebDriver() - let client = try await WebDriverClient.newSession(endpoint: endpoint, httpClient: httpClient) + let client = try await WebDriverClient.newSession( + endpoint: endpoint, httpClient: httpClient) disposer = { try await client.closeSession() clientDisposer() diff --git a/Sources/CartonCLI/Commands/TestRunners/NodeTestRunner.swift b/Sources/CartonCLI/Commands/TestRunners/NodeTestRunner.swift index e699686f..c827fe68 100644 --- a/Sources/CartonCLI/Commands/TestRunners/NodeTestRunner.swift +++ b/Sources/CartonCLI/Commands/TestRunners/NodeTestRunner.swift @@ -39,11 +39,13 @@ struct NodeTestRunner: TestRunner { let staticDirectory = entrypointPath.parentDirectory // Clean up existing symlinks before creating new ones. - for existingSymlink in try localFileSystem.resourcesDirectoryNames(relativeTo: staticDirectory) { + for existingSymlink in try localFileSystem.resourcesDirectoryNames(relativeTo: staticDirectory) + { try localFileSystem.removeFileTree(staticDirectory.appending(component: existingSymlink)) } - let resourceDirectories = try localFileSystem.resourcesDirectoryNames(relativeTo: buildDirectory) + let resourceDirectories = try localFileSystem.resourcesDirectoryNames( + relativeTo: buildDirectory) // Create new symlink for each resource directory. for resourcesDirectoryName in resourceDirectories { diff --git a/Sources/CartonHelpers/Async.swift b/Sources/CartonHelpers/Async.swift index 6f463828..c037a835 100644 --- a/Sources/CartonHelpers/Async.swift +++ b/Sources/CartonHelpers/Async.swift @@ -14,8 +14,8 @@ import ArgumentParser -public extension Sequence { - func asyncMap( +extension Sequence { + public func asyncMap( _ transform: (Element) async throws -> T ) async rethrows -> [T] { var values = [T]() @@ -33,8 +33,8 @@ public protocol AsyncParsableCommand: ParsableCommand { mutating func run() async throws } -public extension AsyncParsableCommand { - mutating func run() throws { +extension AsyncParsableCommand { + public mutating func run() throws { throw CleanExit.helpRequest(self) } } @@ -43,8 +43,8 @@ public protocol AsyncMain { associatedtype Command: ParsableCommand } -public extension AsyncMain { - static func main() async { +extension AsyncMain { + public static func main() async { do { var command = try Command.parseAsRoot() if var command = command as? AsyncParsableCommand { diff --git a/Sources/CartonHelpers/AsyncFileDownload.swift b/Sources/CartonHelpers/AsyncFileDownload.swift index 4696e35a..828c249e 100644 --- a/Sources/CartonHelpers/AsyncFileDownload.swift +++ b/Sources/CartonHelpers/AsyncFileDownload.swift @@ -28,7 +28,8 @@ public struct InvalidResponseCode: Error { public final class AsyncFileDownload { public let progressStream: AsyncThrowingStream - public init(path: String, _ url: URL, _ client: HTTPClient, onTotalBytes: @escaping (Int) -> ()) { + public init(path: String, _ url: URL, _ client: HTTPClient, onTotalBytes: @escaping (Int) -> Void) + { progressStream = .init { continuation in do { let request = try HTTPClient.Request.get(url: url) @@ -37,7 +38,7 @@ public final class AsyncFileDownload { path: path, reportHead: { guard $0.status == .ok, - let totalBytes = $0.headers.first(name: "Content-Length").flatMap(Int.init) + let totalBytes = $0.headers.first(name: "Content-Length").flatMap(Int.init) else { continuation .finish(throwing: InvalidResponseCode(code: $0.status.code)) diff --git a/Sources/CartonHelpers/FileSystem.swift b/Sources/CartonHelpers/FileSystem.swift index 0d6101d5..dab187f8 100644 --- a/Sources/CartonHelpers/FileSystem.swift +++ b/Sources/CartonHelpers/FileSystem.swift @@ -15,12 +15,12 @@ import Foundation import TSCBasic -public extension String { - var isAbsolutePath: Bool { first == "/" } +extension String { + public var isAbsolutePath: Bool { first == "/" } } -public extension FileSystem { - func traverseRecursively(_ traversalRoot: AbsolutePath) throws -> [AbsolutePath] { +extension FileSystem { + public func traverseRecursively(_ traversalRoot: AbsolutePath) throws -> [AbsolutePath] { guard exists(traversalRoot, followSymlink: true) else { return [] } @@ -43,14 +43,14 @@ public extension FileSystem { return result } - func humanReadableFileSize(_ path: AbsolutePath) throws -> String { + public func humanReadableFileSize(_ path: AbsolutePath) throws -> String { precondition(isFile(path)) // FIXME: should use `UnitInformationStorage`, but it's unavailable in open-source Foundation return try String(format: "%.2f MB", Double(getFileInfo(path).size) / 1024 / 1024) } - func resourcesDirectoryNames(relativeTo buildDirectory: AbsolutePath) throws -> [String] { + public func resourcesDirectoryNames(relativeTo buildDirectory: AbsolutePath) throws -> [String] { try getDirectoryContents(buildDirectory).filter { $0.hasSuffix(".resources") } diff --git a/Sources/CartonHelpers/HTTPClient.swift b/Sources/CartonHelpers/HTTPClient.swift index 21c8e08a..961245d8 100644 --- a/Sources/CartonHelpers/HTTPClient.swift +++ b/Sources/CartonHelpers/HTTPClient.swift @@ -15,16 +15,15 @@ import AsyncHTTPClient import Foundation -public extension HTTPClient.Request { - static func get(url: URL) throws -> Self { +extension HTTPClient.Request { + public static func get(url: URL) throws -> Self { try get(url: url.absoluteString) } - static func get(url: String) throws -> Self { + public static func get(url: String) throws -> Self { var request = try HTTPClient.Request(url: url) request.headers.add(name: "User-Agent", value: "carton \(cartonVersion)") - if - url.starts(with: "https://api.github.com/"), + if url.starts(with: "https://api.github.com/"), let token = ProcessInfo.processInfo.environment["GITHUB_TOKEN"] { request.headers.add(name: "Authorization", value: "Bearer \(token)") diff --git a/Sources/CartonHelpers/Parsers/ChromeStackTrace.swift b/Sources/CartonHelpers/Parsers/ChromeStackTrace.swift index b4667f94..2fbd965c 100644 --- a/Sources/CartonHelpers/Parsers/ChromeStackTrace.swift +++ b/Sources/CartonHelpers/Parsers/ChromeStackTrace.swift @@ -22,16 +22,15 @@ private let webpackRegex = try! RegEx(pattern: "at (.+) \\(webpack:///(.+?)\\)") private let wasmRegex = try! RegEx(pattern: "at (.+) \\(:(.+?)\\)") // swiftlint:enable force_try -public extension StringProtocol { - var chromeStackTrace: [StackTraceItem] { +extension StringProtocol { + public var chromeStackTrace: [StackTraceItem] { split(separator: "\n").dropFirst().compactMap { if let webpackMatch = webpackRegex.matchGroups(in: String($0)).first, - let symbol = webpackMatch.first, - let location = webpackMatch.last + let symbol = webpackMatch.first, + let location = webpackMatch.last { return StackTraceItem(symbol: symbol, location: location, kind: .javaScript) - } else if - let wasmMatch = wasmRegex.matchGroups(in: String($0)).first, + } else if let wasmMatch = wasmRegex.matchGroups(in: String($0)).first, let symbol = wasmMatch.first, let location = wasmMatch.last { diff --git a/Sources/CartonHelpers/Parsers/DiagnosticsParser.swift b/Sources/CartonHelpers/Parsers/DiagnosticsParser.swift index 2f637ce2..97d1a608 100644 --- a/Sources/CartonHelpers/Parsers/DiagnosticsParser.swift +++ b/Sources/CartonHelpers/Parsers/DiagnosticsParser.swift @@ -16,16 +16,16 @@ import Foundation import Splash import TSCBasic -private extension TokenType { - var color: String { +extension TokenType { + fileprivate var color: String { // Reference on escape codes: https://en.wikipedia.org/wiki/ANSI_escape_code#Colors switch self { - case .keyword: return "[35;1m" // magenta;bold - case .comment: return "[90m" // bright black - case .call, .dotAccess, .property, .type: return "[94m" // bright blue - case .number, .preprocessing: return "[33m" // yellow - case .string: return "[91;1m" // bright red;bold - default: return "[0m" // reset + case .keyword: return "[35;1m" // magenta;bold + case .comment: return "[90m" // bright black + case .call, .dotAccess, .property, .type: return "[94m" // bright blue + case .number, .preprocessing: return "[33m" // yellow + case .string: return "[91;1m" // bright red;bold + default: return "[0m" // reset } } } @@ -85,9 +85,9 @@ public struct DiagnosticsParser: ProcessOutputParser { case error, warning, note var color: String { switch self { - case .error: return "[41;1m" // bright red background - case .warning: return "[43;1m" // bright yellow background - case .note: return "[7m" // reversed + case .error: return "[41;1m" // bright red background + case .warning: return "[43;1m" // bright yellow background + case .note: return "[7m" // reversed } } } @@ -120,15 +120,18 @@ public struct DiagnosticsParser: ProcessOutputParser { if components.count > 3 { lineIdx += 1 let file = line.replacingOccurrences(of: message, with: "") - guard file.split(separator: "/").last? - .replacingOccurrences(of: ":", with: "") == String(currFile) + guard + file.split(separator: "/").last? + .replacingOccurrences(of: ":", with: "") == String(currFile) else { continue } fileMessages.append( .init( - kind: CustomDiagnostic - .Kind(rawValue: String(components[2] - .trimmingCharacters(in: .whitespaces))) ?? - .note, + kind: + CustomDiagnostic + .Kind( + rawValue: String( + components[2] + .trimmingCharacters(in: .whitespaces))) ?? .note, file: file, line: components[0], char: components[1], @@ -156,15 +159,15 @@ public struct DiagnosticsParser: ProcessOutputParser { ) { for (file, messages) in diagnostics.sorted(by: { $0.key < $1.key }) { guard messages.count > 0 else { continue } - terminal.write("\(" \(file) ", color: "[1m", "[7m")") // bold, reversed + terminal.write("\(" \(file) ", color: "[1m", "[7m")") // bold, reversed terminal.write(" \(messages.first!.file)\(messages.first!.line)\n\n", inColor: .gray) // Group messages that occur on sequential lines to provie a more readable output var groupedMessages = [[CustomDiagnostic]]() for message in messages { if let lastLineStr = groupedMessages.last?.last?.line, - let lastLine = Int(lastLineStr), - let line = Int(message.line), - lastLine == line - 1 || lastLine == line + let lastLine = Int(lastLineStr), + let line = Int(message.line), + lastLine == line - 1 || lastLine == line { groupedMessages[groupedMessages.count - 1].append(message) } else { @@ -178,7 +181,7 @@ public struct DiagnosticsParser: ProcessOutputParser { terminal .write( " \(" \(kind) ", color: message.kind.color, "[37;1m") \(message.message)\n" - ) // 37;1: bright white + ) // 37;1: bright white } let maxLine = messages.map(\.line.count).max() ?? 0 for (offset, message) in messages.enumerated() { @@ -211,7 +214,7 @@ public struct DiagnosticsParser: ProcessOutputParser { terminal .write( " \("\(paddedLine) | ", color: "[36m")\(highlightedCode)\n" - ) // 36: cyan + ) // 36: cyan terminal.write( " " + "".padding(toLength: maxLine, withPad: " ", startingAt: 0) + " | ", inColor: .cyan diff --git a/Sources/CartonHelpers/Parsers/FirefoxStackTrace.swift b/Sources/CartonHelpers/Parsers/FirefoxStackTrace.swift index b569c272..73232bd7 100644 --- a/Sources/CartonHelpers/Parsers/FirefoxStackTrace.swift +++ b/Sources/CartonHelpers/Parsers/FirefoxStackTrace.swift @@ -22,16 +22,15 @@ private let webpackRegex = try! RegEx(pattern: "(.+)@webpack:///(.+)") private let wasmRegex = try! RegEx(pattern: "(.+)@http://127.0.0.1.+WebAssembly.instantiate:(.+)") // swiftlint:enable force_try -public extension StringProtocol { - var firefoxStackTrace: [StackTraceItem] { +extension StringProtocol { + public var firefoxStackTrace: [StackTraceItem] { split(separator: "\n").compactMap { if let webpackMatch = webpackRegex.matchGroups(in: String($0)).first, - let symbol = webpackMatch.first, - let location = webpackMatch.last + let symbol = webpackMatch.first, + let location = webpackMatch.last { return StackTraceItem(symbol: symbol, location: location, kind: .javaScript) - } else if - let wasmMatch = wasmRegex.matchGroups(in: String($0)).first, + } else if let wasmMatch = wasmRegex.matchGroups(in: String($0)).first, let symbol = wasmMatch.first, let location = wasmMatch.last { diff --git a/Sources/CartonHelpers/Parsers/SafariStackTrace.swift b/Sources/CartonHelpers/Parsers/SafariStackTrace.swift index 6654370f..278572c1 100644 --- a/Sources/CartonHelpers/Parsers/SafariStackTrace.swift +++ b/Sources/CartonHelpers/Parsers/SafariStackTrace.swift @@ -22,19 +22,18 @@ private let jsRegex = try! RegEx(pattern: "(.+?)(?:@(?:\\[(?:native|wasm) code\\ private let wasmRegex = try! RegEx(pattern: "<\\?>\\.wasm-function\\[(.+)\\]@\\[wasm code\\]") // swiftlint:enable force_try -public extension StringProtocol { - var safariStackTrace: [StackTraceItem] { +extension StringProtocol { + public var safariStackTrace: [StackTraceItem] { split(separator: "\n").compactMap { if let wasmMatch = wasmRegex.matchGroups(in: String($0)).first, - let symbol = wasmMatch.first + let symbol = wasmMatch.first { return StackTraceItem( symbol: demangle(symbol), location: nil, kind: .webAssembly ) - } else if - let jsMatch = jsRegex.matchGroups(in: String($0)).first, + } else if let jsMatch = jsRegex.matchGroups(in: String($0)).first, let symbol = jsMatch.first { let loc: String? diff --git a/Sources/CartonHelpers/Parsers/String+Regex.swift b/Sources/CartonHelpers/Parsers/String+Regex.swift index 7540c789..52f2de0f 100644 --- a/Sources/CartonHelpers/Parsers/String+Regex.swift +++ b/Sources/CartonHelpers/Parsers/String+Regex.swift @@ -19,7 +19,7 @@ extension StringProtocol { func matches(regex: NSRegularExpression) -> String.SubSequence? { let str = String(self) guard let range = str.range(of: regex), - range.upperBound < str.endIndex + range.upperBound < str.endIndex else { return nil } return str[range.upperBound.. String.SubSequence? { let str = String(self) guard let range = str.range(of: regex, named: name), - range.upperBound < str.endIndex && range.lowerBound >= str.startIndex + range.upperBound < str.endIndex && range.lowerBound >= str.startIndex else { return nil } return str[range] } diff --git a/Sources/CartonHelpers/Parsers/TestsParser.swift b/Sources/CartonHelpers/Parsers/TestsParser.swift index f40739fe..a2344c7e 100644 --- a/Sources/CartonHelpers/Parsers/TestsParser.swift +++ b/Sources/CartonHelpers/Parsers/TestsParser.swift @@ -16,32 +16,34 @@ import Foundation import Splash import TSCBasic -private extension String.StringInterpolation { - mutating func appendInterpolation(_ regexLabel: TestsParser.Regex.Label) { +extension String.StringInterpolation { + fileprivate mutating func appendInterpolation(_ regexLabel: TestsParser.Regex.Label) { appendInterpolation("<\(regexLabel.rawValue)>") } } -private extension StringProtocol { - func range(of regex: NSRegularExpression, - labelled label: TestsParser.Regex.Label) -> Range? - { +extension StringProtocol { + fileprivate func range( + of regex: NSRegularExpression, + labelled label: TestsParser.Regex.Label + ) -> Range? { range(of: regex, named: label.rawValue) } - func match(of regex: NSRegularExpression, labelled label: TestsParser.Regex.Label) -> String + fileprivate func match(of regex: NSRegularExpression, labelled label: TestsParser.Regex.Label) + -> String .SubSequence? { match(of: regex, named: label.rawValue) } - func match( + fileprivate func match( of regex: NSRegularExpression, labelled labelA: TestsParser.Regex.Label, _ labelB: TestsParser.Regex.Label ) -> (String.SubSequence, String.SubSequence)? { guard let a = match(of: regex, named: labelA.rawValue), - let b = match(of: regex, named: labelB.rawValue) + let b = match(of: regex, named: labelB.rawValue) else { return nil } @@ -76,27 +78,32 @@ public struct TestsParser: ProcessOutputParser { } static let suiteStarted = try! NSRegularExpression( - pattern: #"Test Suite '(?\#(.suite)[^']*)' started at (?\#(.timestamp)\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3})"# + pattern: + #"Test Suite '(?\#(.suite)[^']*)' started at (?\#(.timestamp)\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3})"# ) static let suiteFinished = try! NSRegularExpression( - pattern: #"Test Suite '(?\#(.suite)[^']*)' (?\#(.status)(failed|passed)) at (?\#(.timestamp)\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3})"# + pattern: + #"Test Suite '(?\#(.suite)[^']*)' (?\#(.status)(failed|passed)) at (?\#(.timestamp)\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3})"# ) static let suiteSummary = try! NSRegularExpression( - pattern: #"Executed (?\#(.testCount)\d+) (test|tests), with (?\#(.failCount)\d+) (failure|failures) \((?\#(.unexpectedCount)\d+) unexpected\) in (?\#(.duration)\d+\.\d+) \(\d+\.\d+\) seconds"# + pattern: + #"Executed (?\#(.testCount)\d+) (test|tests), with (?\#(.failCount)\d+) (failure|failures) \((?\#(.unexpectedCount)\d+) unexpected\) in (?\#(.duration)\d+\.\d+) \(\d+\.\d+\) seconds"# ) static let caseFinished = try! NSRegularExpression( - pattern: #"Test Case '(?\#(.suite)[^']+)\.(?\#(.testCase)[^']+)' (?\#(.status)(failed|passed)) \((?\#(.duration)(\d+)\.(\d+)) seconds\)"# + pattern: + #"Test Case '(?\#(.suite)[^']+)\.(?\#(.testCase)[^']+)' (?\#(.status)(failed|passed)) \((?\#(.duration)(\d+)\.(\d+)) seconds\)"# ) static let problem = try! NSRegularExpression( - pattern: #"(?\#(.path)(.+)(\/|)([^/]+)):(?\#(.line)\d+): (?\#(.status)\w+): (?\#(.suite)\w+)\.(?\#(.testCase)\w+) : "# + pattern: + #"(?\#(.path)(.+)(\/|)([^/]+)):(?\#(.line)\d+): (?\#(.status)\w+): (?\#(.suite)\w+)\.(?\#(.testCase)\w+) : "# ) enum Assertion: String, CaseIterable { case equal = "Equal", - greaterThan = "GreaterThan", - lessThan = "LessThan", - greaterThanOrEqual = "GreaterThanOrEqual", - lessThanOrEqual = "LessThanOrEqual" + greaterThan = "GreaterThan", + lessThan = "LessThan", + greaterThanOrEqual = "GreaterThanOrEqual", + lessThanOrEqual = "LessThanOrEqual" var funcName: String { "XCTAssert\(rawValue)" @@ -127,15 +134,18 @@ public struct TestsParser: ProcessOutputParser { pattern: #"XCTAssertEqual failed: (?\#(.received).*) is not equal to (?\#(.expected).*) - "# ) static let xctAssertGreaterThan = try! NSRegularExpression( - pattern: #"XCTAssertGreaterThan failed: (?\#(.received).*) is not greater than (?\#(.expected).*) - "# + pattern: + #"XCTAssertGreaterThan failed: (?\#(.received).*) is not greater than (?\#(.expected).*) - "# ) static let xctAssertLessThan = try! NSRegularExpression( - pattern: #"XCTAssertLessThan failed: (?\#(.received).*) is not less than (?\#(.expected).*) - "# + pattern: + #"XCTAssertLessThan failed: (?\#(.received).*) is not less than (?\#(.expected).*) - "# ) static func xctAssert(_ assertion: Assertion) -> NSRegularExpression { try! NSRegularExpression( - pattern: #"\#(assertion.funcName) failed: \("(?\#(.received).*)"\) \#(assertion.innerMessage) \("(?\#(.expected).*)"\) - "# + pattern: + #"\#(assertion.funcName) failed: \("(?\#(.received).*)"\) \#(assertion.innerMessage) \("(?\#(.expected).*)"\) - "# ) } } @@ -168,30 +178,32 @@ public struct TestsParser: ProcessOutputParser { let lines = output.split(separator: "\n") var suites = [Suite]() - var unmappedProblems = [( - suite: String.SubSequence, - testCase: String.SubSequence, - problem: DiagnosticsParser.CustomDiagnostic - )]() + var unmappedProblems = [ + ( + suite: String.SubSequence, + testCase: String.SubSequence, + problem: DiagnosticsParser.CustomDiagnostic + ) + ]() for line in lines { if let suite = line.match(of: Regex.suiteStarted, labelled: .suite) { suites.append(.init(name: suite, cases: [])) } else if let testCase = line.match(of: Regex.caseFinished, labelled: .testCase), - let suite = line.match(of: Regex.caseFinished, labelled: .suite), - let suiteIdx = suites.firstIndex(where: { $0.name == suite }), - let status = line.match(of: Regex.caseFinished, labelled: .status), - let duration = line.match(of: Regex.caseFinished, labelled: .duration) + let suite = line.match(of: Regex.caseFinished, labelled: .suite), + let suiteIdx = suites.firstIndex(where: { $0.name == suite }), + let status = line.match(of: Regex.caseFinished, labelled: .status), + let duration = line.match(of: Regex.caseFinished, labelled: .duration) { suites[suiteIdx].cases.append( .init(name: testCase, passed: status == "passed", duration: duration, problems: []) ) } else if let problem = line.matches(regex: Regex.problem), - let path = line.match(of: Regex.problem, labelled: .path), - let lineNum = line.match(of: Regex.problem, labelled: .line), - let status = line.match(of: Regex.problem, labelled: .status), - let suite = line.match(of: Regex.problem, labelled: .suite), - let testCase = line.match(of: Regex.problem, labelled: .testCase) + let path = line.match(of: Regex.problem, labelled: .path), + let lineNum = line.match(of: Regex.problem, labelled: .line), + let status = line.match(of: Regex.problem, labelled: .status), + let suite = line.match(of: Regex.problem, labelled: .suite), + let testCase = line.match(of: Regex.problem, labelled: .testCase) { let diag = DiagnosticsParser.CustomDiagnostic( kind: DiagnosticsParser.CustomDiagnostic.Kind(rawValue: String(status)) ?? .note, @@ -202,7 +214,7 @@ public struct TestsParser: ProcessOutputParser { message: String(problem) ) if let suiteIdx = suites.firstIndex(where: { $0.name == suite }), - let caseIdx = suites[suiteIdx].cases.firstIndex(where: { $0.name == testCase }) + let caseIdx = suites[suiteIdx].cases.firstIndex(where: { $0.name == testCase }) { suites[suiteIdx].cases[caseIdx].problems.append(diag) } else { @@ -212,7 +224,7 @@ public struct TestsParser: ProcessOutputParser { } for problem in unmappedProblems { if let suiteIdx = suites.firstIndex(where: { $0.name == problem.suite }), - let caseIdx = suites[suiteIdx].cases.firstIndex(where: { $0.name == problem.testCase }) + let caseIdx = suites[suiteIdx].cases.firstIndex(where: { $0.name == problem.testCase }) { suites[suiteIdx].cases[caseIdx].problems.append(problem.problem) } @@ -246,14 +258,14 @@ public struct TestsParser: ProcessOutputParser { terminal.write(" \(suite.name)\n") for testCase in suite.cases { if testCase.passed { - terminal.write(" \("✓", color: "[92m") ") // green + terminal.write(" \("✓", color: "[92m") ") // green } else { - terminal.write(" \("✕", color: "[91m") ") // red + terminal.write(" \("✕", color: "[91m") ") // red } terminal .write( "\(testCase.name) \("(\(Int(Double(testCase.duration)! * 1000))ms)", color: "[90m")\n" - ) // gray + ) // gray for problem in testCase.problems { terminal.write("\n \(problem.file, color: "[90m"):\(problem.line)\n") terminal.write(" \(problem.message)\n\n") @@ -269,7 +281,7 @@ public struct TestsParser: ProcessOutputParser { } // Get the line of code from the file and output it for context. if let lineNum = Int(problem.line), - lineNum > 0 + lineNum > 0 { var fileContents: String? if let fileBuf = fileBufs.first(where: { $0.path == problem.file })?.contents { @@ -322,7 +334,7 @@ public struct TestsParser: ProcessOutputParser { terminal.write("\(String(format: "%.2f", totalDuration))s\n") if suites.contains(where: { $0.name == "All tests" }) { - terminal.write("\("Ran all test suites.", color: "[90m")\n") // gray + terminal.write("\("Ran all test suites.", color: "[90m")\n") // gray } } } diff --git a/Sources/CartonHelpers/Process.swift b/Sources/CartonHelpers/Process.swift index 93a16c5b..093c8c61 100644 --- a/Sources/CartonHelpers/Process.swift +++ b/Sources/CartonHelpers/Process.swift @@ -61,9 +61,9 @@ extension ProcessError: CustomStringConvertible { } } -public extension TSCBasic.Process { +extension TSCBasic.Process { // swiftlint:disable:next function_body_length - static func run( + public static func run( _ arguments: [String], environment: [String: String] = [:], loadingMessage: String = "Running...", @@ -77,11 +77,11 @@ public extension TSCBasic.Process { terminal.write(environment.map { "\($0)=\($1)" }.joined(separator: " ") + " ") } - let processName = arguments[0].first == "/" ? - AbsolutePath(arguments[0]).basename : arguments[0] + let processName = arguments[0].first == "/" ? AbsolutePath(arguments[0]).basename : arguments[0] do { - try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<(), Swift.Error>) in + try await withCheckedThrowingContinuation { + (continuation: CheckedContinuation<(), Swift.Error>) in DispatchQueue.global().async { var stdoutBuffer = "" diff --git a/Sources/CartonHelpers/StackTrace.swift b/Sources/CartonHelpers/StackTrace.swift index f9bba4aa..92b741ad 100644 --- a/Sources/CartonHelpers/StackTrace.swift +++ b/Sources/CartonHelpers/StackTrace.swift @@ -13,9 +13,9 @@ // limitations under the License. #if canImport(Darwin) -import Darwin + import Darwin #elseif canImport(Glibc) -import Glibc + import Glibc #endif @_silgen_name("swift_demangle") @@ -40,7 +40,8 @@ func demangle(_ mangledName: String) -> String { if let demangledNamePtr = demangledNamePtr { let demangledName = String(cString: demangledNamePtr) free(demangledNamePtr) - return demangledName + return + demangledName .replacingOccurrences(of: " Swift.", with: " ") .replacingOccurrences(of: "(Swift.", with: "(") .replacingOccurrences(of: "(_ description: String, _ target: T, newline: Bool = false) - where T: CustomStringConvertible - { +extension InteractiveWriter { + public func logLookup(_ description: String, _ target: T, newline: Bool = false) + where T: CustomStringConvertible { write(description) write("\(target)\n", inColor: .cyan, bold: true) if newline { @@ -31,11 +30,11 @@ public extension InteractiveWriter { } } - func clearWindow() { + public func clearWindow() { write(.clearScreen) } - func homeAndClear() { + public func homeAndClear() { write(.home) write(.clear) } diff --git a/Sources/CartonKit/Helpers/ByteString.swift b/Sources/CartonKit/Helpers/ByteString.swift index 939f8441..df39dec5 100644 --- a/Sources/CartonKit/Helpers/ByteString.swift +++ b/Sources/CartonKit/Helpers/ByteString.swift @@ -15,8 +15,8 @@ import Crypto import TSCBasic -public extension ByteString { - var hexSHA256: String { +extension ByteString { + public var hexSHA256: String { ByteString(SHA256.hash(data: contents)).hexadecimalRepresentation } } diff --git a/Sources/CartonKit/Helpers/Expectation.swift b/Sources/CartonKit/Helpers/Expectation.swift index 8905ef90..2419f001 100644 --- a/Sources/CartonKit/Helpers/Expectation.swift +++ b/Sources/CartonKit/Helpers/Expectation.swift @@ -18,9 +18,8 @@ public struct ExpectationError: Error, CustomStringConvertible { public let description: String } -/** Implements throwing equality assertions, as compared to standard assertions that trap - in debug mode. - */ +/// Implements throwing equality assertions, as compared to standard assertions that trap +/// in debug mode. struct Equality { let description: (_ x: T, _ y: T, _ context: C) -> String diff --git a/Sources/CartonKit/Model/Entrypoint.swift b/Sources/CartonKit/Model/Entrypoint.swift index b7d5c01c..6421e9e3 100644 --- a/Sources/CartonKit/Model/Entrypoint.swift +++ b/Sources/CartonKit/Model/Entrypoint.swift @@ -32,7 +32,7 @@ public struct Entrypoint { public func paths( on fileSystem: FileSystem - // swiftlint:disable:next large_tuple + // swiftlint:disable:next large_tuple ) throws -> (cartonDir: AbsolutePath, staticDir: AbsolutePath, filePath: AbsolutePath) { let cartonDir = try fileSystem.homeDirectory.appending(component: ".carton") let staticDir = cartonDir.appending(component: "static") @@ -43,9 +43,11 @@ public struct Entrypoint { let (cartonDir, staticDir, filePath) = try paths(on: fileSystem) // If hash check fails, download the `static.zip` archive and unpack it - if try !fileSystem.exists(filePath) || SHA256().hash( - fileSystem.readFileContents(filePath) - ) != sha256 { + if try !fileSystem.exists(filePath) + || SHA256().hash( + fileSystem.readFileContents(filePath) + ) != sha256 + { terminal.logLookup("Directory doesn't exist or contains outdated polyfills: ", staticDir) let archiveFile = cartonDir.appending(component: "static.zip") try fileSystem.removeFileTree(staticDir) diff --git a/Sources/CartonKit/Model/Template.swift b/Sources/CartonKit/Model/Template.swift index 7aa05a16..0b099bf9 100644 --- a/Sources/CartonKit/Model/Template.swift +++ b/Sources/CartonKit/Model/Template.swift @@ -92,33 +92,33 @@ extension Template { ) throws { try fileSystem.writeFileContents(project.path.appending(component: "Package.swift")) { var content = """ - // swift-tools-version:5.6 - import PackageDescription - let package = Package( - name: "\(project.name)",\n - """ + // swift-tools-version:5.6 + import PackageDescription + let package = Package( + name: "\(project.name)",\n + """ if !platforms.isEmpty { content += " platforms: [\(platforms.joined(separator: ", "))],\n" } content += """ - products: [ - .executable(name: "\(project.name)", targets: ["\(project.name)"]) - ], - dependencies: [ - \(dependencies.map(\.description).joined(separator: ",\n")) - ], - targets: [ - .executableTarget( - name: "\(project.name)", - dependencies: [ - \(targetDepencencies.map(\.description).joined(separator: ",\n")) - ]), - .testTarget( - name: "\(project.name)Tests", - dependencies: ["\(project.name)"]), - ] - ) - """ + products: [ + .executable(name: "\(project.name)", targets: ["\(project.name)"]) + ], + dependencies: [ + \(dependencies.map(\.description).joined(separator: ",\n")) + ], + targets: [ + .executableTarget( + name: "\(project.name)", + dependencies: [ + \(targetDepencencies.map(\.description).joined(separator: ",\n")) + ]), + .testTarget( + name: "\(project.name)Tests", + dependencies: ["\(project.name)"]), + ] + ) + """ content.write(to: $0) } } @@ -144,10 +144,10 @@ extension Templates { .init( url: "https://github.com/swiftwasm/JavaScriptKit", version: .from(compatibleJSKitVersion.description) - ), + ) ], targetDepencencies: [ - .init(name: "JavaScriptKit", package: "JavaScriptKit"), + .init(name: "JavaScriptKit", package: "JavaScriptKit") ], terminal ) @@ -165,10 +165,11 @@ extension Templates { _ terminal: InteractiveWriter ) async throws { try fileSystem.changeCurrentWorkingDirectory(to: project.path) - try await createPackage(type: .executable, - fileSystem: fileSystem, - project: project, - terminal) + try await createPackage( + type: .executable, + fileSystem: fileSystem, + project: project, + terminal) try createManifest( fileSystem: fileSystem, project: project, @@ -177,10 +178,10 @@ extension Templates { .init( url: "https://github.com/TokamakUI/Tokamak", version: .from("0.11.0") - ), + ) ], targetDepencencies: [ - .init(name: "TokamakShim", package: "Tokamak"), + .init(name: "TokamakShim", package: "Tokamak") ], terminal ) diff --git a/Sources/CartonKit/Server/Application.swift b/Sources/CartonKit/Server/Application.swift index 5a7f9fdc..05ea78af 100644 --- a/Sources/CartonKit/Server/Application.swift +++ b/Sources/CartonKit/Server/Application.swift @@ -28,8 +28,8 @@ extension Application { let manifest: Manifest let product: ProductDescription? let entrypoint: Entrypoint - let onWebSocketOpen: (WebSocket, DestinationEnvironment) async -> () - let onWebSocketClose: (WebSocket) async -> () + let onWebSocketOpen: (WebSocket, DestinationEnvironment) async -> Void + let onWebSocketClose: (WebSocket) async -> Void } func configure(_ configuration: Configuration) throws { @@ -52,16 +52,18 @@ extension Application { } return customIndexContent.map { - HTML(value: HTML.indexPage( - customContent: $0, - entrypointName: configuration.entrypoint.fileName - )) + HTML( + value: HTML.indexPage( + customContent: $0, + entrypointName: configuration.entrypoint.fileName + )) } } // Don't limit the size of frame to accept large test outputs webSocket("watcher", maxFrameSize: .init(integerLiteral: Int(UInt32.max))) { request, ws in - let environment = request.headers["User-Agent"].compactMap(DestinationEnvironment.init).first + let environment = + request.headers["User-Agent"].compactMap(DestinationEnvironment.init).first ?? .other Task { await configuration.onWebSocketOpen(ws, environment) } diff --git a/Sources/CartonKit/Server/HTML.swift b/Sources/CartonKit/Server/HTML.swift index 2b7cc97a..dacca719 100644 --- a/Sources/CartonKit/Server/HTML.swift +++ b/Sources/CartonKit/Server/HTML.swift @@ -17,8 +17,8 @@ import Vapor enum HTMLError: String, Error { case customIndexPageWithoutHead = """ - The custom `index.html` page does not have a `` element to allow entrypoint injection - """ + The custom `index.html` page does not have a `` element to allow entrypoint injection + """ } public struct HTML { @@ -29,16 +29,21 @@ extension HTML: ResponseEncodable { public func encodeResponse(for request: Request) -> EventLoopFuture { var headers = HTTPHeaders() headers.add(name: .contentType, value: "text/html") - return request.eventLoop.makeSucceededFuture(.init( - status: .ok, headers: headers, body: .init(string: value) - )) + return request.eventLoop.makeSucceededFuture( + .init( + status: .ok, headers: headers, body: .init(string: value) + )) } - public static func readCustomIndexPage(at path: String?, on fileSystem: FileSystem) throws -> String? { + public static func readCustomIndexPage(at path: String?, on fileSystem: FileSystem) throws + -> String? + { if let customIndexPage = path { - let content = try localFileSystem.readFileContents(customIndexPage.isAbsolutePath ? - AbsolutePath(customIndexPage) : - AbsolutePath(localFileSystem.currentWorkingDirectory!, customIndexPage)).description + let content = try localFileSystem.readFileContents( + customIndexPage.isAbsolutePath + ? AbsolutePath(customIndexPage) + : AbsolutePath(localFileSystem.currentWorkingDirectory!, customIndexPage) + ).description guard content.contains("") else { throw HTMLError.customIndexPageWithoutHead @@ -60,16 +65,16 @@ extension HTML: ResponseEncodable { } return #""" - - - - - - \#(scriptTag) - - - - - """# + + + + + + \#(scriptTag) + + + + + """# } } diff --git a/Sources/CartonKit/Server/Server.swift b/Sources/CartonKit/Server/Server.swift index 6e21e198..34387e85 100644 --- a/Sources/CartonKit/Server/Server.swift +++ b/Sources/CartonKit/Server/Server.swift @@ -284,7 +284,7 @@ extension Server { _ configuration: Configuration, in environment: DestinationEnvironment, terminal: InteractiveWriter - ) -> (WebSocket, String) -> () { + ) -> (WebSocket, String) -> Void { { [weak self] _, text in guard let self = self else { return } guard @@ -304,9 +304,11 @@ extension Server { } } else { terminal.write("\nAn error occurred, here's the raw stack trace for it:\n", inColor: .red) - terminal.write(" Please create an issue or PR to the Carton repository\n" + - " with your browser name and this raw stack trace so\n" + - " we can add support for it: https://github.com/swiftwasm/carton\n", inColor: .gray) + terminal.write( + " Please create an issue or PR to the Carton repository\n" + + " with your browser name and this raw stack trace so\n" + + " we can add support for it: https://github.com/swiftwasm/carton\n", inColor: .gray + ) terminal.write(rawStackTrace + "\n") } @@ -331,11 +333,11 @@ extension Server { @discardableResult public func openInSystemBrowser(url: String) -> Bool { #if os(macOS) - let openCommand = "open" + let openCommand = "open" #elseif os(Linux) - let openCommand = "xdg-open" + let openCommand = "xdg-open" #else - return false + return false #endif let process = Process( arguments: [openCommand, url], diff --git a/Sources/CartonKit/Server/StaticArchive.swift b/Sources/CartonKit/Server/StaticArchive.swift index 1f946731..2a8b2e82 100644 --- a/Sources/CartonKit/Server/StaticArchive.swift +++ b/Sources/CartonKit/Server/StaticArchive.swift @@ -2,22 +2,23 @@ import TSCBasic public let devEntrypointSHA256 = ByteString([ 0x98, 0x1F, 0xB8, 0x76, 0x80, 0xBB, 0x48, 0xE2, 0xEC, 0xEE, 0x42, 0x0A, 0x4F, 0x48, 0x59, 0xE4, - 0x31, 0x4A, 0xA1, 0xDE, 0xD8, 0x65, 0xBA, 0x13, 0x1A, 0xAC, 0xA7, 0x58, 0xDF, 0xEA, 0x15, 0x28 + 0x31, 0x4A, 0xA1, 0xDE, 0xD8, 0x65, 0xBA, 0x13, 0x1A, 0xAC, 0xA7, 0x58, 0xDF, 0xEA, 0x15, 0x28, ]) public let bundleEntrypointSHA256 = ByteString([ 0x73, 0xA5, 0xD7, 0x9B, 0xDD, 0xF6, 0x2E, 0x3C, 0x83, 0x9D, 0xE0, 0xB7, 0xE8, 0x68, 0x9D, 0x5E, - 0x96, 0x31, 0x68, 0x9B, 0x60, 0x0B, 0xCA, 0xD2, 0xA5, 0xF5, 0x87, 0xE8, 0x4D, 0xDD, 0x3D, 0xBC + 0x96, 0x31, 0x68, 0x9B, 0x60, 0x0B, 0xCA, 0xD2, 0xA5, 0xF5, 0x87, 0xE8, 0x4D, 0xDD, 0x3D, 0xBC, ]) public let testEntrypointSHA256 = ByteString([ 0xF3, 0x2B, 0xF0, 0x81, 0xA1, 0xB5, 0xA2, 0x75, 0x08, 0x39, 0x88, 0x85, 0x54, 0x03, 0x61, 0xF4, - 0xC8, 0x73, 0x7E, 0x9A, 0x8A, 0x9E, 0x54, 0xCE, 0x8B, 0x70, 0xC8, 0xA1, 0x75, 0x6A, 0x73, 0x27 + 0xC8, 0x73, 0x7E, 0x9A, 0x8A, 0x9E, 0x54, 0xCE, 0x8B, 0x70, 0xC8, 0xA1, 0x75, 0x6A, 0x73, 0x27, ]) public let testNodeEntrypointSHA256 = ByteString([ 0x7E, 0xA9, 0x9E, 0xAD, 0x61, 0x20, 0xEA, 0x71, 0xF4, 0x79, 0xAF, 0xF0, 0xE1, 0xA4, 0x39, 0xEE, - 0x8A, 0x41, 0x71, 0x6A, 0x8E, 0x2D, 0x78, 0xFA, 0xBE, 0xCF, 0x72, 0xA6, 0xE9, 0x9A, 0x5E, 0x4F + 0x8A, 0x41, 0x71, 0x6A, 0x8E, 0x2D, 0x78, 0xFA, 0xBE, 0xCF, 0x72, 0xA6, 0xE9, 0x9A, 0x5E, 0x4F, ]) -public let staticArchiveContents = "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" \ No newline at end of file +public let staticArchiveContents = + "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" diff --git a/Sources/SwiftToolchain/Builder.swift b/Sources/SwiftToolchain/Builder.swift index 4403c62c..b52d9cc2 100644 --- a/Sources/SwiftToolchain/Builder.swift +++ b/Sources/SwiftToolchain/Builder.swift @@ -55,7 +55,7 @@ public final class Builder { String(format: "%.2f seconds", abs(buildStarted.timeIntervalSinceNow)) ) - var transformers: [(inout InputByteStream, inout InMemoryOutputWriter) throws -> ()] = [] + var transformers: [(inout InputByteStream, inout InMemoryOutputWriter) throws -> Void] = [] if flavor.environment == .node || flavor.environment == .defaultBrowser { // If building for JS-host environments, // - i64 params in imports are not supported without bigint-i64 feature @@ -71,9 +71,10 @@ public final class Builder { transformers.append(transformer.transform) } // Strip unnecessary autolink sections, which is only used at link-time - transformers.append(CustomSectionStripper(stripIf: { - $0 == ".swift1_autolink_entries" - }).transform) + transformers.append( + CustomSectionStripper(stripIf: { + $0 == ".swift1_autolink_entries" + }).transform) switch flavor.sanitize { case .stackOverflow: diff --git a/Sources/SwiftToolchain/DestinationEnvironment.swift b/Sources/SwiftToolchain/DestinationEnvironment.swift index 36c1adc6..df6f5044 100644 --- a/Sources/SwiftToolchain/DestinationEnvironment.swift +++ b/Sources/SwiftToolchain/DestinationEnvironment.swift @@ -22,13 +22,13 @@ public enum DestinationEnvironment { case edge } -public extension String { - func parsedStackTrace(in environment: DestinationEnvironment) -> [StackTraceItem]? { +extension String { + public func parsedStackTrace(in environment: DestinationEnvironment) -> [StackTraceItem]? { switch environment { case .safari: return safariStackTrace case .firefox: return firefoxStackTrace case .chrome: return chromeStackTrace - case .edge: return chromeStackTrace // TODO: return nil if on old Edge + case .edge: return chromeStackTrace // TODO: return nil if on old Edge default: return nil } } diff --git a/Sources/SwiftToolchain/Manifest.swift b/Sources/SwiftToolchain/Manifest.swift index 966b1e68..5eea3ba9 100644 --- a/Sources/SwiftToolchain/Manifest.swift +++ b/Sources/SwiftToolchain/Manifest.swift @@ -14,13 +14,15 @@ import Basics import CartonHelpers -import PackageModel import PackageLoading +import PackageModel import TSCBasic import Workspace extension Manifest { - static func from(path: AbsolutePath, swiftc: AbsolutePath, fileSystem: FileSystem, terminal: InteractiveWriter) async throws -> Manifest { + static func from( + path: AbsolutePath, swiftc: AbsolutePath, fileSystem: FileSystem, terminal: InteractiveWriter + ) async throws -> Manifest { terminal.write("\nParsing package manifest: ", inColor: .yellow) let destination = try Destination.hostDestination(swiftc.parentDirectory) let toolchain = try UserToolchain(destination: destination) @@ -28,7 +30,8 @@ extension Manifest { let observability = ObservabilitySystem { _, diagnostic in terminal.write("\n\(diagnostic)") } - let workspace = try Workspace(fileSystem: fileSystem, forRootPackage: path, customManifestLoader: loader) + let workspace = try Workspace( + fileSystem: fileSystem, forRootPackage: path, customManifestLoader: loader) let manifest = try await workspace.loadRootManifest( at: path, observabilityScope: observability.topScope diff --git a/Sources/SwiftToolchain/Toolchain.swift b/Sources/SwiftToolchain/Toolchain.swift index afe71c0b..7da61502 100644 --- a/Sources/SwiftToolchain/Toolchain.swift +++ b/Sources/SwiftToolchain/Toolchain.swift @@ -48,9 +48,9 @@ enum ToolchainError: Error, CustomStringConvertible { return "Failed to build the test bundle" case .missingPackageManifest: return """ - The `Package.swift` manifest file could not be found. Please navigate to a directory that \ - contains `Package.swift` and restart. - """ + The `Package.swift` manifest file could not be found. Please navigate to a directory that \ + contains `Package.swift` and restart. + """ case let .invalidVersion(version): return "Invalid version \(version)" case let .invalidResponse(url: url, status: status): @@ -59,8 +59,8 @@ enum ToolchainError: Error, CustomStringConvertible { return "This version of the operating system is not supported" case let .noInstallationDirectory(path): return """ - Failed to infer toolchain installation directory. Please make sure that \(path) exists. - """ + Failed to infer toolchain installation directory. Please make sure that \(path) exists. + """ case .noWorkingDirectory: return "Working directory cannot be inferred from file system" } @@ -128,7 +128,8 @@ public final class Toolchain { if let workingDirectory = fileSystem.currentWorkingDirectory { let swiftc = swiftPath.parentDirectory.appending(component: "swiftc") manifest = await Result { - try await Manifest.from(path: workingDirectory, swiftc: swiftc, fileSystem: fileSystem, terminal: terminal) + try await Manifest.from( + path: workingDirectory, swiftc: swiftc, fileSystem: fileSystem, terminal: terminal) } } else { manifest = .failure(ToolchainError.noWorkingDirectory) @@ -157,10 +158,11 @@ public final class Toolchain { candidateProducts = candidateProducts.filter { $0.name == productName } guard candidateProducts.count == 1 else { - terminal.write(""" - Failed to disambiguate the executable product, \ - make sure `\(productName)` product is present in Package.swift - """, inColor: .red) + terminal.write( + """ + Failed to disambiguate the executable product, \ + make sure `\(productName)` product is present in Package.swift + """, inColor: .red) return nil } @@ -226,9 +228,11 @@ public final class Toolchain { private func emitJSKitWarningIfNeeded() throws { let manifest = try manifest.get() - guard let jsKit = manifest.dependencies.first(where: { - $0.nameForTargetDependencyResolutionOnly == "JavaScriptKit" - }) else { + guard + let jsKit = manifest.dependencies.first(where: { + $0.nameForTargetDependencyResolutionOnly == "JavaScriptKit" + }) + else { return } @@ -302,7 +306,9 @@ public final class Toolchain { return .init(arguments: builderArguments, mainWasmPath: mainWasmPath, product: product) } - public func getTestProduct(flavor: BuildFlavor) throws -> (name: String, artifactPath: AbsolutePath) { + public func getTestProduct(flavor: BuildFlavor) throws -> ( + name: String, artifactPath: AbsolutePath + ) { let manifest = try manifest.get() let binPath = try inferBinPath(isRelease: flavor.isRelease) let testProductName = "\(manifest.displayName)PackageTests" @@ -352,7 +358,7 @@ public final class Toolchain { var builderArguments = ["--triple", "wasm32-unknown-wasi"] if let wasmVersion = try? Version(swiftWasmVersion: version) { - + // Versions later than 5.3.x have test discovery enabled by default and the explicit flag // deprecated. if wasmVersion.major == 5, wasmVersion.minor == 3 { @@ -375,9 +381,10 @@ public final class Toolchain { } } - builderArguments.append(contentsOf: flavor.swiftCompilerFlags.flatMap { - ["-Xswiftc", $0] - }) + builderArguments.append( + contentsOf: flavor.swiftCompilerFlags.flatMap { + ["-Xswiftc", $0] + }) return builderArguments } @@ -422,7 +429,7 @@ extension Version { } var swiftWasmVersion = swiftWasmVersion swiftWasmVersion.removeFirst(prefix.count) - + let version = try Version(versionString: swiftWasmVersion, usesLenientParsing: true) // Strip prereleaseIdentifiers self.init(version.major, version.minor, version.patch) diff --git a/Sources/SwiftToolchain/ToolchainInstallation.swift b/Sources/SwiftToolchain/ToolchainInstallation.swift index bd3ab600..d3f7571d 100644 --- a/Sources/SwiftToolchain/ToolchainInstallation.swift +++ b/Sources/SwiftToolchain/ToolchainInstallation.swift @@ -20,8 +20,8 @@ import TSCUtility private let expectedArchiveSize = 891_856_371 -private extension FileDownloadDelegate.Progress { - var totalOrEstimatedBytes: Int { +extension FileDownloadDelegate.Progress { + fileprivate var totalOrEstimatedBytes: Int { totalBytes ?? expectedArchiveSize } } diff --git a/Sources/SwiftToolchain/ToolchainManagement.swift b/Sources/SwiftToolchain/ToolchainManagement.swift index d338a894..491cf4c8 100644 --- a/Sources/SwiftToolchain/ToolchainManagement.swift +++ b/Sources/SwiftToolchain/ToolchainManagement.swift @@ -70,10 +70,11 @@ public class ToolchainSystem { ].compactMap { $0 } cartonToolchainResolver = try CartonToolchainResolver(fileSystem: fileSystem) - resolvers = try [ - cartonToolchainResolver, - SwiftEnvToolchainResolver(fileSystem: fileSystem), - ] + xctoolchainResolvers + resolvers = + try [ + cartonToolchainResolver, + SwiftEnvToolchainResolver(fileSystem: fileSystem), + ] + xctoolchainResolvers } private var libraryPaths: [AbsolutePath] { @@ -105,8 +106,8 @@ public class ToolchainSystem { ) throws -> String { if let versionSpec = versionSpec { if let url = URL(string: versionSpec), - let filename = url.pathComponents.last, - let match = versionRegEx.matchGroups(in: filename).first?.first + let filename = url.pathComponents.last, + let match = versionRegEx.matchGroups(in: filename).first?.first { terminal.logLookup("Inferred swift version: ", match) return match @@ -146,9 +147,9 @@ public class ToolchainSystem { _ terminal: InteractiveWriter ) throws -> Foundation.URL? { let releaseURL = """ - https://api.github.com/repos/swiftwasm/swift/releases/tags/\ - swift-\(version) - """ + https://api.github.com/repos/swiftwasm/swift/releases/tags/\ + swift-\(version) + """ terminal.logLookup("Fetching release assets from ", releaseURL) let decoder = JSONDecoder() @@ -156,10 +157,11 @@ public class ToolchainSystem { let release = try tsc_await { client.execute(request: request).flatMapResult { response -> Result in guard (200..<300).contains(response.status.code), let body = response.body else { - return .failure(ToolchainError.invalidResponse( - url: releaseURL, - status: response.status.code - )) + return .failure( + ToolchainError.invalidResponse( + url: releaseURL, + status: response.status.code + )) } terminal.write("Response contained body, parsing it now...\n", inColor: .green) @@ -168,34 +170,34 @@ public class ToolchainSystem { } #if arch(x86_64) - let archSuffix = "x86_64" + let archSuffix = "x86_64" #elseif arch(arm64) #if os(macOS) - let archSuffix = "arm64" + let archSuffix = "arm64" #elseif os(Linux) - let archSuffix = "aarch64" + let archSuffix = "aarch64" #endif #endif #if os(macOS) - let platformSuffixes = ["osx", "catalina", "macos"] + let platformSuffixes = ["osx", "catalina", "macos"] #elseif os(Linux) - let releaseFile = AbsolutePath("/etc").appending(component: "lsb-release") - guard fileSystem.isFile(releaseFile) else { - throw ToolchainError.unsupportedOperatingSystem - } + let releaseFile = AbsolutePath("/etc").appending(component: "lsb-release") + guard fileSystem.isFile(releaseFile) else { + throw ToolchainError.unsupportedOperatingSystem + } - let releaseData = try fileSystem.readFileContents(releaseFile).description - let ubuntuSuffix: String - if releaseData.contains("DISTRIB_RELEASE=18.04") { - ubuntuSuffix = "ubuntu18.04" - } else if releaseData.contains("DISTRIB_RELEASE=20.04") { - ubuntuSuffix = "ubuntu20.04" - } else { - throw ToolchainError.unsupportedOperatingSystem - } + let releaseData = try fileSystem.readFileContents(releaseFile).description + let ubuntuSuffix: String + if releaseData.contains("DISTRIB_RELEASE=18.04") { + ubuntuSuffix = "ubuntu18.04" + } else if releaseData.contains("DISTRIB_RELEASE=20.04") { + ubuntuSuffix = "ubuntu20.04" + } else { + throw ToolchainError.unsupportedOperatingSystem + } - let platformSuffixes = ["linux", ubuntuSuffix] + let platformSuffixes = ["linux", ubuntuSuffix] #endif terminal.logLookup( @@ -279,10 +281,10 @@ public class ToolchainSystem { public func fetchLocalSwiftVersion() throws -> String? { guard fileSystem.isFile(swiftVersionPath), - let version = try fileSystem.readFileContents(swiftVersionPath) - .validDescription? - // get the first line of the file - .components(separatedBy: CharacterSet.newlines).first + let version = try fileSystem.readFileContents(swiftVersionPath) + .validDescription? + // get the first line of the file + .components(separatedBy: CharacterSet.newlines).first else { return nil } return version diff --git a/Sources/WebDriverClient/WebDriverClient.swift b/Sources/WebDriverClient/WebDriverClient.swift index 520305d0..d75c50fa 100644 --- a/Sources/WebDriverClient/WebDriverClient.swift +++ b/Sources/WebDriverClient/WebDriverClient.swift @@ -34,27 +34,28 @@ public struct WebDriverClient { } public static let defaultSessionRequestBody = #""" - { - "capabilities": { - "alwaysMatch": { - "goog:chromeOptions": { - "w3c": true, - "args": ["--headless", "--no-sandbox"] - }, - "moz:firefoxOptions": { - "args": ["-headless"] - }, - "ms:edgeOptions": { - "args": ["--headless", "--no-sandbox"] + { + "capabilities": { + "alwaysMatch": { + "goog:chromeOptions": { + "w3c": true, + "args": ["--headless", "--no-sandbox"] + }, + "moz:firefoxOptions": { + "args": ["-headless"] + }, + "ms:edgeOptions": { + "args": ["--headless", "--no-sandbox"] + } } } } - } - """# + """# - public static func newSession(endpoint: URL, body: String = defaultSessionRequestBody, - httpClient: HTTPClient) async throws -> WebDriverClient - { + public static func newSession( + endpoint: URL, body: String = defaultSessionRequestBody, + httpClient: HTTPClient + ) async throws -> WebDriverClient { struct Response: Decodable { let sessionId: String } @@ -71,13 +72,15 @@ public struct WebDriverClient { } let decoder = JSONDecoder() let response = try decoder.decode(ValueResponse.self, from: responseBody) - return WebDriverClient(client: httpClient, - driverEndpoint: endpoint, - sessionId: response.sessionId) + return WebDriverClient( + client: httpClient, + driverEndpoint: endpoint, + sessionId: response.sessionId) } private func makeSessionURL(_ components: String...) -> String { - var url = driverEndpoint + var url = + driverEndpoint .appendingPathComponent("session") .appendingPathComponent(sessionId) for component in components { diff --git a/Sources/carton-release/Formula.swift b/Sources/carton-release/Formula.swift index df953edb..634d5488 100644 --- a/Sources/carton-release/Formula.swift +++ b/Sources/carton-release/Formula.swift @@ -38,32 +38,32 @@ struct Formula: ParsableCommand { let sha256 = SHA256().hash(downloadedArchive).hexadecimalRepresentation let formula = #""" - class Carton < Formula - desc "📦 Watcher, bundler, and test runner for your SwiftWasm apps" - homepage "https://carton.dev" - head "https://github.com/swiftwasm/carton.git" + class Carton < Formula + desc "📦 Watcher, bundler, and test runner for your SwiftWasm apps" + homepage "https://carton.dev" + head "https://github.com/swiftwasm/carton.git" - depends_on :xcode => "11.4" - depends_on "wasmer" - depends_on "binaryen" + depends_on :xcode => "11.4" + depends_on "wasmer" + depends_on "binaryen" - stable do - version "\#(version)" - url "https://github.com/swiftwasm/carton/archive/#{version}.tar.gz" - sha256 "\#(sha256)" - end + stable do + version "\#(version)" + url "https://github.com/swiftwasm/carton/archive/#{version}.tar.gz" + sha256 "\#(sha256)" + end - def install - system "swift", "build", "--disable-sandbox", "-c", "release" - system "mv", ".build/release/carton", "carton" - bin.install "carton" - end + def install + system "swift", "build", "--disable-sandbox", "-c", "release" + system "mv", ".build/release/carton", "carton" + bin.install "carton" + end - test do - system "carton -h" + test do + system "carton -h" + end end - end - """# + """# print(formula) } diff --git a/Sources/carton-release/HashArchive.swift b/Sources/carton-release/HashArchive.swift index b5f7ea20..bee45477 100644 --- a/Sources/carton-release/HashArchive.swift +++ b/Sources/carton-release/HashArchive.swift @@ -30,9 +30,9 @@ struct HashArchive: AsyncParsableCommand { precondition(commaSeparated.count == 190) return """ - \(commaSeparated.prefix(95)) - \(commaSeparated.suffix(94)) - """ + \(commaSeparated.prefix(95)) + \(commaSeparated.suffix(94)) + """ } func run() async throws { @@ -70,8 +70,11 @@ struct HashArchive: AsyncParsableCommand { try localFileSystem.removeFileTree(dotFilesEntrypointPath) try localFileSystem.copy(from: entrypointPath, to: dotFilesEntrypointPath) - return (entrypoint, try SHA256().hash(localFileSystem.readFileContents(entrypointPath)) - .hexadecimalRepresentation.uppercased()) + return ( + entrypoint, + try SHA256().hash(localFileSystem.readFileContents(entrypointPath)) + .hexadecimalRepresentation.uppercased() + ) } try localFileSystem.writeFileContents( @@ -87,16 +90,17 @@ struct HashArchive: AsyncParsableCommand { try await Process.run(["zip", "-j", "static.zip"] + archiveSources, terminal) - let staticArchiveContents = try localFileSystem.readFileContents(AbsolutePath( - localFileSystem.currentWorkingDirectory!, - RelativePath("static.zip") - )) + let staticArchiveContents = try localFileSystem.readFileContents( + AbsolutePath( + localFileSystem.currentWorkingDirectory!, + RelativePath("static.zip") + )) // Base64 is not an efficient way, but too long byte array literal breaks type-checker let hashesFileContent = """ - import TSCBasic + import TSCBasic - \(hashes.map { + \(hashes.map { """ public let \($0)EntrypointSHA256 = ByteString([ \(arrayString(from: $1)) @@ -104,8 +108,8 @@ struct HashArchive: AsyncParsableCommand { """ }.joined(separator: "\n\n")) - public let staticArchiveContents = "\(staticArchiveContents.withData { $0.base64EncodedString() })" - """ + public let staticArchiveContents = "\(staticArchiveContents.withData { $0.base64EncodedString() })" + """ try localFileSystem.writeFileContents( AbsolutePath( From 468240c90191baa1edbcccff2bcd56f469590810 Mon Sep 17 00:00:00 2001 From: Yuta Saito Date: Thu, 4 May 2023 02:13:34 +0900 Subject: [PATCH 3/8] Make swift-format 5.8 happy for Tests --- .../BundleCommandTests.swift | 9 +- .../CommandTestHelper.swift | 44 +- .../CartonCommandTests/DevCommandTests.swift | 64 +-- .../CartonCommandTests/InitCommandTests.swift | 9 +- .../CartonCommandTests/IntegrationTests.swift | 3 +- .../CartonCommandTests/SDKCommandTests.swift | 3 +- Tests/CartonCommandTests/StringHelpers.swift | 4 +- .../CartonCommandTests/TestCommandTests.swift | 41 +- Tests/CartonCommandTests/Testable.swift | 12 +- Tests/CartonTests/CartonTests.swift | 66 +-- Tests/CartonTests/StackTraceTests.swift | 425 +++++++++++------- Tests/Fixtures/CrashTest/Tests/Tests.swift | 8 +- Tests/Fixtures/FailTest/Tests/Tests.swift | 6 +- Tests/Fixtures/NodeJSKitTest/Package.swift | 2 +- Tests/Fixtures/TestApp/Package.swift | 4 +- .../TestApp/Sources/TestApp/main.swift | 22 +- 16 files changed, 420 insertions(+), 302 deletions(-) diff --git a/Tests/CartonCommandTests/BundleCommandTests.swift b/Tests/CartonCommandTests/BundleCommandTests.swift index 54d49035..2563d7d5 100644 --- a/Tests/CartonCommandTests/BundleCommandTests.swift +++ b/Tests/CartonCommandTests/BundleCommandTests.swift @@ -15,10 +15,11 @@ // Created by Cavelle Benjamin on Dec/25/20. // -@testable import CartonCLI import TSCBasic import XCTest +@testable import CartonCLI + final class BundleCommandTests: XCTestCase { func testWithNoArguments() throws { try withFixture("EchoExecutable") { packageDirectory in @@ -63,7 +64,7 @@ final class BundleCommandTests: XCTestCase { return } let headers = try Process.checkNonZeroExit(arguments: [ - "wasm-objdump", "--headers", bundleDirectory.appending(component: wasmBinary).pathString + "wasm-objdump", "--headers", bundleDirectory.appending(component: wasmBinary).pathString, ]) XCTAssert(headers.contains("\"name\""), "name section not found: \(headers)") } @@ -77,7 +78,9 @@ final class BundleCommandTests: XCTestCase { func getFileSizeOfWasmBinary(wasmOptimizations: WasmOptimizations) throws -> UInt64 { let bundleDirectory = tmpDirPath.appending(component: "Bundle") - try Process.checkNonZeroExit(arguments: [cartonPath, "bundle", "--wasm-optimizations", wasmOptimizations.rawValue]) + try Process.checkNonZeroExit(arguments: [ + cartonPath, "bundle", "--wasm-optimizations", wasmOptimizations.rawValue, + ]) guard let wasmFile = (bundleDirectory.ls().filter { $0.contains("wasm") }).first else { XCTFail("No wasm binary found") diff --git a/Tests/CartonCommandTests/CommandTestHelper.swift b/Tests/CartonCommandTests/CommandTestHelper.swift index 6ab098b2..e1d6065a 100644 --- a/Tests/CartonCommandTests/CommandTestHelper.swift +++ b/Tests/CartonCommandTests/CommandTestHelper.swift @@ -12,8 +12,8 @@ import ArgumentParser import XCTest -public extension ExitCode { - static var quit = ExitCode(SIGQUIT) +extension ExitCode { + public static var quit = ExitCode(SIGQUIT) } public func stop(process id: Int32, exitCode: ExitCode = .success) { @@ -26,8 +26,8 @@ public protocol TestableParsableArguments: ParsableArguments { var didValidateExpectation: XCTestExpectation { get } } -public extension TestableParsableArguments { - mutating func validate() throws { +extension TestableParsableArguments { + public mutating func validate() throws { didValidateExpectation.fulfill() } } @@ -37,14 +37,14 @@ public protocol TestableParsableCommand: ParsableCommand, TestableParsableArgume var didRunExpectation: XCTestExpectation { get } } -public extension TestableParsableCommand { - mutating func run() throws { +extension TestableParsableCommand { + public mutating func run() throws { didRunExpectation.fulfill() } } -public extension XCTestExpectation { - convenience init(singleExpectation description: String) { +extension XCTestExpectation { + public convenience init(singleExpectation description: String) { self.init(description: description) expectedFulfillmentCount = 1 assertForOverFulfill = true @@ -103,7 +103,7 @@ public func AssertParse( _ arguments: [String], file: StaticString = #file, line: UInt = #line, - closure: (A) throws -> () + closure: (A) throws -> Void ) where A: ParsableArguments { do { let parsed = try type.parse(arguments) @@ -120,7 +120,7 @@ public func AssertParseCommand( _ arguments: [String], file: StaticString = #file, line: UInt = #line, - closure: (A) throws -> () + closure: (A) throws -> Void ) { do { let command = try rootCommand.parseAsRoot(arguments) @@ -186,15 +186,15 @@ public func AssertHelp( ) } -public extension XCTest { - var debugURL: URL { +extension XCTest { + public var debugURL: URL { let bundleURL = Bundle(for: type(of: self)).bundleURL return bundleURL.lastPathComponent.hasSuffix("xctest") ? bundleURL.deletingLastPathComponent() : bundleURL } - var cartonPath: String { + public var cartonPath: String { debugURL.appendingPathComponent("carton").path } @@ -205,10 +205,10 @@ public extension XCTest { /// - parameter cwd: The current working directory for executing the command. /// - parameter file: The file the assertion is coming from. /// - parameter line: The line the assertion is coming from. - func executeCommand( + public func executeCommand( command: String, shouldPrintOutput: Bool = false, - cwd: URL? = nil, // To allow for testing of file-based output + cwd: URL? = nil, // To allow for testing of file-based output file: StaticString = #file, line: UInt = #line ) -> Process? { let splitCommand = command.split(separator: " ") @@ -217,8 +217,9 @@ public extension XCTest { let commandName = String(splitCommand.first!) let commandURL = debugURL.appendingPathComponent(commandName) guard (try? commandURL.checkResourceIsReachable()) ?? false else { - XCTFail("No executable at '\(commandURL.standardizedFileURL.path)'.", - file: file, line: line) + XCTFail( + "No executable at '\(commandURL.standardizedFileURL.path)'.", + file: file, line: line) return nil } @@ -261,9 +262,9 @@ public extension XCTest { /// - parameter debug: Debug the assertion by printing out the command string. /// - parameter file: The file the assertion is coming from. /// - parameter line: The line the assertion is coming from. - func AssertExecuteCommand( + public func AssertExecuteCommand( command: String, - cwd: URL? = nil, // To allow for testing of file based output + cwd: URL? = nil, // To allow for testing of file based output expected: String? = nil, expectedContains: Bool = false, exitCode: ExitCode = .success, @@ -276,8 +277,9 @@ public extension XCTest { let commandName = String(splitCommand.first!) let commandURL = debugURL.appendingPathComponent(commandName) guard (try? commandURL.checkResourceIsReachable()) ?? false else { - XCTFail("No executable at '\(commandURL.standardizedFileURL.path)'.", - file: file, line: line) + XCTFail( + "No executable at '\(commandURL.standardizedFileURL.path)'.", + file: file, line: line) return } diff --git a/Tests/CartonCommandTests/DevCommandTests.swift b/Tests/CartonCommandTests/DevCommandTests.swift index 182fcb9d..d8af4277 100644 --- a/Tests/CartonCommandTests/DevCommandTests.swift +++ b/Tests/CartonCommandTests/DevCommandTests.swift @@ -16,9 +16,10 @@ // import AsyncHTTPClient -@testable import CartonCLI import XCTest +@testable import CartonCLI + final class DevCommandTests: XCTestCase { private var client: HTTPClient? @@ -28,37 +29,41 @@ final class DevCommandTests: XCTestCase { } #if os(macOS) - func testWithNoArguments() throws { - // FIXME: Don't assume a specific port is available since it can be used by others or tests - try withFixture("EchoExecutable") { packageDirectory in - guard let process = executeCommand( - command: "carton dev --verbose", - shouldPrintOutput: true, - cwd: packageDirectory.url - ) else { - XCTFail("Could not create process") - return + func testWithNoArguments() throws { + // FIXME: Don't assume a specific port is available since it can be used by others or tests + try withFixture("EchoExecutable") { packageDirectory in + guard + let process = executeCommand( + command: "carton dev --verbose", + shouldPrintOutput: true, + cwd: packageDirectory.url + ) + else { + XCTFail("Could not create process") + return + } + + checkForExpectedContent(process: process, at: "http://127.0.0.1:8080") } - - checkForExpectedContent(process: process, at: "http://127.0.0.1:8080") } - } - func testWithArguments() throws { - // FIXME: Don't assume a specific port is available since it can be used by others or tests - try withFixture("EchoExecutable") { packageDirectory in - guard let process = executeCommand( - command: "carton dev --verbose --port 8081", - shouldPrintOutput: true, - cwd: packageDirectory.url - ) else { - XCTFail("Could not create process") - return + func testWithArguments() throws { + // FIXME: Don't assume a specific port is available since it can be used by others or tests + try withFixture("EchoExecutable") { packageDirectory in + guard + let process = executeCommand( + command: "carton dev --verbose --port 8081", + shouldPrintOutput: true, + cwd: packageDirectory.url + ) + else { + XCTFail("Could not create process") + return + } + + checkForExpectedContent(process: process, at: "http://127.0.0.1:8081") } - - checkForExpectedContent(process: process, at: "http://127.0.0.1:8081") } - } #endif func checkForExpectedContent(process: Process, at url: String) { @@ -90,8 +95,9 @@ final class DevCommandTests: XCTestCase { read: .seconds(timeOut) ) - client = HTTPClient(eventLoopGroupProvider: .createNew, - configuration: HTTPClient.Configuration(timeout: timeout)) + client = HTTPClient( + eventLoopGroupProvider: .createNew, + configuration: HTTPClient.Configuration(timeout: timeout)) var response: HTTPClient.Response? var count = 0 diff --git a/Tests/CartonCommandTests/InitCommandTests.swift b/Tests/CartonCommandTests/InitCommandTests.swift index d0a29409..9a0546fc 100644 --- a/Tests/CartonCommandTests/InitCommandTests.swift +++ b/Tests/CartonCommandTests/InitCommandTests.swift @@ -15,10 +15,11 @@ // Created by Cavelle Benjamin on Dec/20/20. // -@testable import CartonCLI import TSCBasic import XCTest +@testable import CartonCLI + final class InitCommandTests: XCTestCase { func testWithNoArguments() throws { try withTemporaryDirectory { tmpDirPath in @@ -87,8 +88,10 @@ final class InitCommandTests: XCTestCase { "Tests/\(package)Tests/\(package)Tests.swift does not exist" ) - let actualTemplateSource = try String(contentsOfFile: packageDirectory - .appending(components: "Sources", package, "App.swift").pathString) + let actualTemplateSource = try String( + contentsOfFile: + packageDirectory + .appending(components: "Sources", package, "App.swift").pathString) XCTAssertEqual(expectedTemplateSource, actualTemplateSource, "Template Sources do not match") } diff --git a/Tests/CartonCommandTests/IntegrationTests.swift b/Tests/CartonCommandTests/IntegrationTests.swift index bfccd1ec..ca4c60ef 100644 --- a/Tests/CartonCommandTests/IntegrationTests.swift +++ b/Tests/CartonCommandTests/IntegrationTests.swift @@ -12,10 +12,11 @@ // See the License for the specific language governing permissions and // limitations under the License. -@testable import CartonCLI import TSCBasic import XCTest +@testable import CartonCLI + final class IntegrationTests: XCTestCase { func testTokamakBundle() throws { try withTemporaryDirectory { tmpDirPath in diff --git a/Tests/CartonCommandTests/SDKCommandTests.swift b/Tests/CartonCommandTests/SDKCommandTests.swift index 05167e9d..154ebe60 100644 --- a/Tests/CartonCommandTests/SDKCommandTests.swift +++ b/Tests/CartonCommandTests/SDKCommandTests.swift @@ -15,10 +15,11 @@ // Created by Cavelle Benjamin on Dec/25/20. // -@testable import CartonCLI import TSCBasic import XCTest +@testable import CartonCLI + final class SDKCommandTests: XCTestCase { func testInstall() throws { AssertExecuteCommand( diff --git a/Tests/CartonCommandTests/StringHelpers.swift b/Tests/CartonCommandTests/StringHelpers.swift index e7c42510..c48dddeb 100644 --- a/Tests/CartonCommandTests/StringHelpers.swift +++ b/Tests/CartonCommandTests/StringHelpers.swift @@ -18,8 +18,8 @@ extension Substring { } } -public extension String { - func trimmingLines() -> String { +extension String { + public func trimmingLines() -> String { split(separator: "\n", omittingEmptySubsequences: false) .map { $0.trimmed() } .joined(separator: "\n") diff --git a/Tests/CartonCommandTests/TestCommandTests.swift b/Tests/CartonCommandTests/TestCommandTests.swift index 279540ff..b99f25ab 100644 --- a/Tests/CartonCommandTests/TestCommandTests.swift +++ b/Tests/CartonCommandTests/TestCommandTests.swift @@ -66,7 +66,8 @@ final class TestCommandTests: XCTestCase { cwd: packageDirectory.url ) AssertExecuteCommand( - command: "carton test --environment node --prebuilt-test-bundle-path ./.build/wasm32-unknown-wasi/debug/NodeJSKitTestPackageTests.wasm", + command: + "carton test --environment node --prebuilt-test-bundle-path ./.build/wasm32-unknown-wasi/debug/NodeJSKitTestPackageTests.wasm", cwd: packageDirectory.url ) } @@ -98,7 +99,9 @@ final class TestCommandTests: XCTestCase { } try withFixture(fixture) { packageDirectory in try ProcessEnv.chdir(packageDirectory) - let process = Process(arguments: [cartonPath, "test", "--environment", "defaultBrowser", "--headless"]) + let process = Process(arguments: [ + cartonPath, "test", "--environment", "defaultBrowser", "--headless", + ]) try process.launch() let result = try process.waitUntilExit() XCTAssertNotEqual(result.exitStatus, .terminated(code: 0)) @@ -107,28 +110,28 @@ final class TestCommandTests: XCTestCase { // This test is prone to hanging on Linux. #if os(macOS) - func testEnvironmentDefaultBrowser() throws { - try withFixture(Constants.testAppPackageName) { packageDirectory in - let expectedTestSuiteCount = 1 - let expectedTestsCount = 1 + func testEnvironmentDefaultBrowser() throws { + try withFixture(Constants.testAppPackageName) { packageDirectory in + let expectedTestSuiteCount = 1 + let expectedTestsCount = 1 - let expectedContent = - """ - Test Suites: \(ControlCode.CSI)32m\(expectedTestSuiteCount) passed\(ControlCode + let expectedContent = + """ + Test Suites: \(ControlCode.CSI)32m\(expectedTestSuiteCount) passed\(ControlCode .CSI)0m, \(expectedTestSuiteCount) total - Tests: \(ControlCode.CSI)32m\(expectedTestsCount) passed\(ControlCode + Tests: \(ControlCode.CSI)32m\(expectedTestsCount) passed\(ControlCode .CSI)0m, \(expectedTestsCount) total - """ + """ - // FIXME: Don't assume a specific port is available since it can be used by others or tests - AssertExecuteCommand( - command: "carton test --environment defaultBrowser --port 8082", - cwd: packageDirectory.url, - expected: expectedContent, - expectedContains: true - ) + // FIXME: Don't assume a specific port is available since it can be used by others or tests + AssertExecuteCommand( + command: "carton test --environment defaultBrowser --port 8082", + cwd: packageDirectory.url, + expected: expectedContent, + expectedContains: true + ) + } } - } #endif } diff --git a/Tests/CartonCommandTests/Testable.swift b/Tests/CartonCommandTests/Testable.swift index e8b9a7d8..2a487646 100644 --- a/Tests/CartonCommandTests/Testable.swift +++ b/Tests/CartonCommandTests/Testable.swift @@ -22,12 +22,12 @@ import TSCTestSupport /// Returns path to the built products directory. public var productsDirectory: AbsolutePath { #if os(macOS) - for bundle in Bundle.allBundles where bundle.bundlePath.hasSuffix(".xctest") { - return AbsolutePath(bundle.bundleURL.deletingLastPathComponent().path) - } - fatalError("couldn't find the products directory") + for bundle in Bundle.allBundles where bundle.bundlePath.hasSuffix(".xctest") { + return AbsolutePath(bundle.bundleURL.deletingLastPathComponent().path) + } + fatalError("couldn't find the products directory") #else - return AbsolutePath(Bundle.main.bundleURL.path) + return AbsolutePath(Bundle.main.bundleURL.path) #endif } @@ -42,7 +42,7 @@ public var packageDirectory: AbsolutePath { .parentDirectory } -func withFixture(_ name: String, _ body: (AbsolutePath) throws -> ()) throws { +func withFixture(_ name: String, _ body: (AbsolutePath) throws -> Void) throws { let fixtureDir = testFixturesDirectory.appending(component: name) try withTemporaryDirectory(prefix: name) { tmpDirPath in let dstDir = tmpDirPath.appending(component: name) diff --git a/Tests/CartonTests/CartonTests.swift b/Tests/CartonTests/CartonTests.swift index ad6b7d37..d31f6a1c 100644 --- a/Tests/CartonTests/CartonTests.swift +++ b/Tests/CartonTests/CartonTests.swift @@ -13,23 +13,25 @@ // limitations under the License. import CartonHelpers -@testable import CartonKit -import class Foundation.Bundle -@testable import SwiftToolchain import TSCBasic import TSCUtility import XCTest +import class Foundation.Bundle + +@testable import CartonKit +@testable import SwiftToolchain + final class CartonTests: XCTestCase { /// Returns path to the built products directory. var productsDirectory: Foundation.URL { #if os(macOS) - for bundle in Bundle.allBundles where bundle.bundlePath.hasSuffix(".xctest") { - return bundle.bundleURL.deletingLastPathComponent() - } - fatalError("couldn't find the products directory") + for bundle in Bundle.allBundles where bundle.bundlePath.hasSuffix(".xctest") { + return bundle.bundleURL.deletingLastPathComponent() + } + fatalError("couldn't find the products directory") #else - return Bundle.main.bundleURL + return Bundle.main.bundleURL #endif } @@ -85,28 +87,28 @@ final class CartonTests: XCTestCase { func testDiagnosticsParser() { // swiftlint:disable line_length let testDiagnostics = """ - [1/1] Compiling TokamakCore Font.swift - /Users/username/Project/Sources/TokamakCore/Tokens/Font.swift:58:15: error: invalid redeclaration of 'resolve(in:)' - public func resolve(in environment: EnvironmentValues) -> _Font { - ^ - /Users/username/Project/Sources/TokamakCore/Tokens/Font.swift:55:15: note: 'resolve(in:)' previously declared here - public func resolve(in environment: EnvironmentValues) -> _Font { - ^ - """ + [1/1] Compiling TokamakCore Font.swift + /Users/username/Project/Sources/TokamakCore/Tokens/Font.swift:58:15: error: invalid redeclaration of 'resolve(in:)' + public func resolve(in environment: EnvironmentValues) -> _Font { + ^ + /Users/username/Project/Sources/TokamakCore/Tokens/Font.swift:55:15: note: 'resolve(in:)' previously declared here + public func resolve(in environment: EnvironmentValues) -> _Font { + ^ + """ let expectedOutput = """ - \u{001B}[1m\u{001B}[7m Font.swift \u{001B}[0m /Users/username/Project/Sources/TokamakCore/Tokens/Font.swift:58 + \u{001B}[1m\u{001B}[7m Font.swift \u{001B}[0m /Users/username/Project/Sources/TokamakCore/Tokens/Font.swift:58 - \u{001B}[41;1m\u{001B}[37;1m ERROR \u{001B}[0m invalid redeclaration of 'resolve(in:)' - \u{001B}[36m58 | \u{001B}[0m \u{001B}[35;1mpublic\u{001B}[0m \u{001B}[35;1mfunc\u{001B}[0m resolve(in environment: \u{001B}[94mEnvironmentValues\u{001B}[0m) -> \u{001B}[94m_Font\u{001B}[0m { - | ^ + \u{001B}[41;1m\u{001B}[37;1m ERROR \u{001B}[0m invalid redeclaration of 'resolve(in:)' + \u{001B}[36m58 | \u{001B}[0m \u{001B}[35;1mpublic\u{001B}[0m \u{001B}[35;1mfunc\u{001B}[0m resolve(in environment: \u{001B}[94mEnvironmentValues\u{001B}[0m) -> \u{001B}[94m_Font\u{001B}[0m { + | ^ - \u{001B}[7m\u{001B}[37;1m NOTE \u{001B}[0m 'resolve(in:)' previously declared here - \u{001B}[36m55 | \u{001B}[0m \u{001B}[35;1mpublic\u{001B}[0m \u{001B}[35;1mfunc\u{001B}[0m resolve(in environment: \u{001B}[94mEnvironmentValues\u{001B}[0m) -> \u{001B}[94m_Font\u{001B}[0m { - | ^ + \u{001B}[7m\u{001B}[37;1m NOTE \u{001B}[0m 'resolve(in:)' previously declared here + \u{001B}[36m55 | \u{001B}[0m \u{001B}[35;1mpublic\u{001B}[0m \u{001B}[35;1mfunc\u{001B}[0m resolve(in environment: \u{001B}[94mEnvironmentValues\u{001B}[0m) -> \u{001B}[94m_Font\u{001B}[0m { + | ^ - """ + """ // swiftlint:enable line_length let stream = TestOutputStream() let writer = InteractiveWriter(stream: stream) @@ -117,25 +119,29 @@ final class CartonTests: XCTestCase { func testDestinationEnvironment() { XCTAssertEqual( DestinationEnvironment( - userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:93.0) Gecko/20100101 Firefox/93.0" + userAgent: + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:93.0) Gecko/20100101 Firefox/93.0" ), .firefox ) XCTAssertEqual( DestinationEnvironment( - userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.71 Safari/537.36 Edg/94.0.992.38" + userAgent: + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.71 Safari/537.36 Edg/94.0.992.38" ), .edge ) XCTAssertEqual( DestinationEnvironment( - userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.71 Safari/537.36" + userAgent: + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.71 Safari/537.36" ), .chrome ) XCTAssertEqual( DestinationEnvironment( - userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.0 Safari/605.1.15" + userAgent: + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.0 Safari/605.1.15" ), .safari ) @@ -144,7 +150,7 @@ final class CartonTests: XCTestCase { nil ) } - + func testSwiftWasmVersionParsing() throws { let v5_6 = try Version(swiftWasmVersion: "wasm-5.6.0-RELEASE") XCTAssertEqual(v5_6.major, 5) @@ -152,7 +158,7 @@ final class CartonTests: XCTestCase { XCTAssertEqual(v5_6.patch, 0) XCTAssert(v5_6.prereleaseIdentifiers.isEmpty) XCTAssert(v5_6 >= Version(5, 6, 0)) - + let v5_7_snapshot = try Version(swiftWasmVersion: "wasm-5.7-SNAPSHOT-2022-07-14-a") XCTAssertEqual(v5_7_snapshot.major, 5) XCTAssertEqual(v5_7_snapshot.minor, 7) diff --git a/Tests/CartonTests/StackTraceTests.swift b/Tests/CartonTests/StackTraceTests.swift index 32edc095..cf37c05e 100644 --- a/Tests/CartonTests/StackTraceTests.swift +++ b/Tests/CartonTests/StackTraceTests.swift @@ -15,39 +15,40 @@ // Created by Max Desiatov on 08/11/2020. // -@testable import CartonHelpers import XCTest +@testable import CartonHelpers + final class StackTraceTests: XCTestCase {} extension StackTraceTests { func testFirefoxStackTrace() { // swiftlint:disable line_length let stackTrace = """ - wasmFs.fs.writeSync@webpack:///./entrypoint/dev.js?:35:21 - a/this.wasiImport.fd_write eval line 58 > WebAssembly.instantiate:wasm-function[62062]:0x12af331 - swift_reportError@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[21654]:0x37c242 - _swift_stdlib_reportFatalErrorInFile@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[22950]:0x3e2996 - $ss17_assertionFailure__4file4line5flagss5NeverOs12StaticStringV_A2HSus6UInt32VtFySRys5UInt8VGXEfU_yAMXEfU_@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[3635]:0xd717d - $ss17_assertionFailure__4file4line5flagss5NeverOs12StaticStringV_A2HSus6UInt32VtFySRys5UInt8VGXEfU_Tm@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[3636]:0xd7374 - $ss17_assertionFailure__4file4line5flagss5NeverOs12StaticStringV_A2HSus6UInt32VtF@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[2752]:0xa7917 - $sSayxSicig@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[2982]:0xb34da - $s7TestApp5crashyyF@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[1372]:0x8012c - $s7TestAppySay13JavaScriptKit7JSValueOGcfU_@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[1367]:0x7f4e7 - $s13JavaScriptKit9JSClosureCyACySayAA7JSValueOGccfcAeFcfU_@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[787]:0x5003b - $s13JavaScriptKit9JSClosureCyACySayAA7JSValueOGccfcAeFcfU_TA@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[786]:0x4ff96 - $sSay13JavaScriptKit7JSValueOGACIeggo_AdCIegnr_TR@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[783]:0x4fe00 - $sSay13JavaScriptKit7JSValueOGACIeggo_AdCIegnr_TRTA@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[782]:0x4fdc8 - $sSay13JavaScriptKit7JSValueOGACIegnr_AdCIeggo_TR@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[812]:0x52ddd - $sSay13JavaScriptKit7JSValueOGACIegnr_AdCIeggo_TRTA@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[802]:0x529bc - $s13JavaScriptKit24_call_host_function_implyys6UInt32V_SPySo10RawJSValueaGs5Int32VADtF@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[801]:0x525e8 - _call_host_function_impl@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[800]:0x52158 - _call_host_function@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[1388]:0x814d3 - callHostFunction@webpack:///./node_modules/javascript-kit-swift/Runtime/lib/index.js?:110:21 - swjs_create_function/func_ref<@webpack:///./node_modules/javascript-kit-swift/Runtime/lib/index.js?:280:28 - """.firefoxStackTrace + wasmFs.fs.writeSync@webpack:///./entrypoint/dev.js?:35:21 + a/this.wasiImport.fd_write eval line 58 > WebAssembly.instantiate:wasm-function[62062]:0x12af331 + swift_reportError@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[21654]:0x37c242 + _swift_stdlib_reportFatalErrorInFile@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[22950]:0x3e2996 + $ss17_assertionFailure__4file4line5flagss5NeverOs12StaticStringV_A2HSus6UInt32VtFySRys5UInt8VGXEfU_yAMXEfU_@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[3635]:0xd717d + $ss17_assertionFailure__4file4line5flagss5NeverOs12StaticStringV_A2HSus6UInt32VtFySRys5UInt8VGXEfU_Tm@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[3636]:0xd7374 + $ss17_assertionFailure__4file4line5flagss5NeverOs12StaticStringV_A2HSus6UInt32VtF@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[2752]:0xa7917 + $sSayxSicig@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[2982]:0xb34da + $s7TestApp5crashyyF@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[1372]:0x8012c + $s7TestAppySay13JavaScriptKit7JSValueOGcfU_@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[1367]:0x7f4e7 + $s13JavaScriptKit9JSClosureCyACySayAA7JSValueOGccfcAeFcfU_@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[787]:0x5003b + $s13JavaScriptKit9JSClosureCyACySayAA7JSValueOGccfcAeFcfU_TA@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[786]:0x4ff96 + $sSay13JavaScriptKit7JSValueOGACIeggo_AdCIegnr_TR@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[783]:0x4fe00 + $sSay13JavaScriptKit7JSValueOGACIeggo_AdCIegnr_TRTA@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[782]:0x4fdc8 + $sSay13JavaScriptKit7JSValueOGACIegnr_AdCIeggo_TR@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[812]:0x52ddd + $sSay13JavaScriptKit7JSValueOGACIegnr_AdCIeggo_TRTA@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[802]:0x529bc + $s13JavaScriptKit24_call_host_function_implyys6UInt32V_SPySo10RawJSValueaGs5Int32VADtF@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[801]:0x525e8 + _call_host_function_impl@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[800]:0x52158 + _call_host_function@http://127.0.0.1:8080/dev.js line 97 > eval line 58 > WebAssembly.instantiate:wasm-function[1388]:0x814d3 + callHostFunction@webpack:///./node_modules/javascript-kit-swift/Runtime/lib/index.js?:110:21 + swjs_create_function/func_ref<@webpack:///./node_modules/javascript-kit-swift/Runtime/lib/index.js?:280:28 + """.firefoxStackTrace let expected: [StackTraceItem] = [ .init( @@ -74,79 +75,108 @@ extension StackTraceTests { symbol: "write", location: "wasm-function[62062]:0x12af331", kind: .webAssembly - ), .init( + ), + .init( symbol: "swift_reportError", location: "wasm-function[21654]:0x37c242", kind: .webAssembly - ), .init( + ), + .init( symbol: "_swift_stdlib_reportFatalErrorInFile", location: "wasm-function[22950]:0x3e2996", kind: .webAssembly - ), .init( - symbol: "closure #1 (UnsafeBufferPointer) -> () in closure #1 (UnsafeBufferPointer) -> () in _assertionFailure(_: StaticString, _: StaticString, file: StaticString, line: UInt, flags: UInt32) -> Never", + ), + .init( + symbol: + "closure #1 (UnsafeBufferPointer) -> () in closure #1 (UnsafeBufferPointer) -> () in _assertionFailure(_: StaticString, _: StaticString, file: StaticString, line: UInt, flags: UInt32) -> Never", location: "wasm-function[3635]:0xd717d", kind: .webAssembly - ), .init( - symbol: "merged closure #1 (UnsafeBufferPointer) -> () in _assertionFailure(_: StaticString, _: StaticString, file: StaticString, line: UInt, flags: UInt32) -> Never", + ), + .init( + symbol: + "merged closure #1 (UnsafeBufferPointer) -> () in _assertionFailure(_: StaticString, _: StaticString, file: StaticString, line: UInt, flags: UInt32) -> Never", location: "wasm-function[3636]:0xd7374", kind: .webAssembly - ), .init( - symbol: "Swift._assertionFailure(_: StaticString, _: StaticString, file: StaticString, line: UInt, flags: UInt32) -> Never", + ), + .init( + symbol: + "Swift._assertionFailure(_: StaticString, _: StaticString, file: StaticString, line: UInt, flags: UInt32) -> Never", location: "wasm-function[2752]:0xa7917", kind: .webAssembly - ), .init( + ), + .init( symbol: "Swift.Array.subscript.getter : (Int) -> A", location: "wasm-function[2982]:0xb34da", kind: .webAssembly - ), .init( + ), + .init( symbol: "TestApp.crash() -> ()", location: "wasm-function[1372]:0x8012c", kind: .webAssembly - ), .init( + ), + .init( symbol: "closure #1 (Array) -> () in TestApp", location: "wasm-function[1367]:0x7f4e7", kind: .webAssembly - ), .init( - symbol: "closure #1 (Array) -> JavaScriptKit.JSValue in JavaScriptKit.JSClosure.init((Array) -> ()) -> JavaScriptKit.JSClosure", + ), + .init( + symbol: + "closure #1 (Array) -> JavaScriptKit.JSValue in JavaScriptKit.JSClosure.init((Array) -> ()) -> JavaScriptKit.JSClosure", location: "wasm-function[787]:0x5003b", kind: .webAssembly - ), .init( - symbol: "partial apply forwarder for closure #1 (Array) -> JavaScriptKit.JSValue in JavaScriptKit.JSClosure.init((Array) -> ()) -> JavaScriptKit.JSClosure", + ), + .init( + symbol: + "partial apply forwarder for closure #1 (Array) -> JavaScriptKit.JSValue in JavaScriptKit.JSClosure.init((Array) -> ()) -> JavaScriptKit.JSClosure", location: "wasm-function[786]:0x4ff96", kind: .webAssembly - ), .init( - symbol: "reabstraction thunk helper from @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue)", + ), + .init( + symbol: + "reabstraction thunk helper from @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue)", location: "wasm-function[783]:0x4fe00", kind: .webAssembly - ), .init( - symbol: "partial apply forwarder for reabstraction thunk helper from @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue)", + ), + .init( + symbol: + "partial apply forwarder for reabstraction thunk helper from @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue)", location: "wasm-function[782]:0x4fdc8", kind: .webAssembly - ), .init( - symbol: "reabstraction thunk helper from @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue)", + ), + .init( + symbol: + "reabstraction thunk helper from @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue)", location: "wasm-function[812]:0x52ddd", kind: .webAssembly - ), .init( - symbol: "partial apply forwarder for reabstraction thunk helper from @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue)", + ), + .init( + symbol: + "partial apply forwarder for reabstraction thunk helper from @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue)", location: "wasm-function[802]:0x529bc", kind: .webAssembly - ), .init( - symbol: "JavaScriptKit._call_host_function_impl(UInt32, UnsafePointer<__C.RawJSValue>, Int32, UInt32) -> ()", + ), + .init( + symbol: + "JavaScriptKit._call_host_function_impl(UInt32, UnsafePointer<__C.RawJSValue>, Int32, UInt32) -> ()", location: "wasm-function[801]:0x525e8", kind: .webAssembly - ), .init( + ), + .init( symbol: "_call_host_function_impl", location: "wasm-function[800]:0x52158", kind: .webAssembly - ), .init( + ), + .init( symbol: "_call_host_function", location: "wasm-function[1388]:0x814d3", kind: .webAssembly - ), .init( + ), + .init( symbol: "callHostFunction", location: "./node_modules/javascript-kit-swift/Runtime/lib/index.js?:110:21", kind: .javaScript - ), .init( + ), + .init( symbol: "swjs_create_function/func_ref<", location: "./node_modules/javascript-kit-swift/Runtime/lib/index.js?:280:28", kind: .javaScript @@ -160,32 +190,32 @@ extension StackTraceTests { func testSafariStackTrace() { // swiftlint:disable line_length let stackTrace = """ - forEach@[native code] + forEach@[native code] - wasm-stub@[wasm code] - .wasm-function[write]@[wasm code] - .wasm-function[swift_reportError]@[wasm code] - .wasm-function[_swift_stdlib_reportFatalErrorInFile]@[wasm code] - .wasm-function[$ss17_assertionFailure__4file4line5flagss5NeverOs12StaticStringV_A2HSus6UInt32VtFySRys5UInt8VGXEfU_yAMXEfU_]@[wasm code] - .wasm-function[$ss17_assertionFailure__4file4line5flagss5NeverOs12StaticStringV_A2HSus6UInt32VtFySRys5UInt8VGXEfU_Tm]@[wasm code] - .wasm-function[$ss17_assertionFailure__4file4line5flagss5NeverOs12StaticStringV_A2HSus6UInt32VtF]@[wasm code] - .wasm-function[$sSayxSicig]@[wasm code] - .wasm-function[$s7TestApp5crashyyF]@[wasm code] - .wasm-function[$s7TestAppySay13JavaScriptKit7JSValueOGcfU_]@[wasm code] - .wasm-function[$s13JavaScriptKit9JSClosureCyACySayAA7JSValueOGccfcAeFcfU_]@[wasm code] - .wasm-function[$s13JavaScriptKit9JSClosureCyACySayAA7JSValueOGccfcAeFcfU_TA]@[wasm code] - .wasm-function[$sSay13JavaScriptKit7JSValueOGACIeggo_AdCIegnr_TR]@[wasm code] - .wasm-function[$sSay13JavaScriptKit7JSValueOGACIeggo_AdCIegnr_TRTA]@[wasm code] - .wasm-function[$sSay13JavaScriptKit7JSValueOGACIegnr_AdCIeggo_TR]@[wasm code] - .wasm-function[$sSay13JavaScriptKit7JSValueOGACIegnr_AdCIeggo_TRTA]@[wasm code] - .wasm-function[$s13JavaScriptKit24_call_host_function_implyys6UInt32V_SPySo10RawJSValueaGs5Int32VADtF]@[wasm code] - .wasm-function[_call_host_function_impl]@[wasm code] - .wasm-function[_call_host_function]@[wasm code] - wasm-stub@[wasm code] - swjs_call_host_function@[native code] - callHostFunction - """.safariStackTrace + wasm-stub@[wasm code] + .wasm-function[write]@[wasm code] + .wasm-function[swift_reportError]@[wasm code] + .wasm-function[_swift_stdlib_reportFatalErrorInFile]@[wasm code] + .wasm-function[$ss17_assertionFailure__4file4line5flagss5NeverOs12StaticStringV_A2HSus6UInt32VtFySRys5UInt8VGXEfU_yAMXEfU_]@[wasm code] + .wasm-function[$ss17_assertionFailure__4file4line5flagss5NeverOs12StaticStringV_A2HSus6UInt32VtFySRys5UInt8VGXEfU_Tm]@[wasm code] + .wasm-function[$ss17_assertionFailure__4file4line5flagss5NeverOs12StaticStringV_A2HSus6UInt32VtF]@[wasm code] + .wasm-function[$sSayxSicig]@[wasm code] + .wasm-function[$s7TestApp5crashyyF]@[wasm code] + .wasm-function[$s7TestAppySay13JavaScriptKit7JSValueOGcfU_]@[wasm code] + .wasm-function[$s13JavaScriptKit9JSClosureCyACySayAA7JSValueOGccfcAeFcfU_]@[wasm code] + .wasm-function[$s13JavaScriptKit9JSClosureCyACySayAA7JSValueOGccfcAeFcfU_TA]@[wasm code] + .wasm-function[$sSay13JavaScriptKit7JSValueOGACIeggo_AdCIegnr_TR]@[wasm code] + .wasm-function[$sSay13JavaScriptKit7JSValueOGACIeggo_AdCIegnr_TRTA]@[wasm code] + .wasm-function[$sSay13JavaScriptKit7JSValueOGACIegnr_AdCIeggo_TR]@[wasm code] + .wasm-function[$sSay13JavaScriptKit7JSValueOGACIegnr_AdCIeggo_TRTA]@[wasm code] + .wasm-function[$s13JavaScriptKit24_call_host_function_implyys6UInt32V_SPySo10RawJSValueaGs5Int32VADtF]@[wasm code] + .wasm-function[_call_host_function_impl]@[wasm code] + .wasm-function[_call_host_function]@[wasm code] + wasm-stub@[wasm code] + swjs_call_host_function@[native code] + callHostFunction + """.safariStackTrace let expected: [StackTraceItem] = [ @@ -193,91 +223,123 @@ extension StackTraceTests { symbol: "forEach", location: nil, kind: .javaScript - ), .init( + ), + .init( symbol: "wasm-stub", location: nil, kind: .javaScript - ), .init( + ), + .init( symbol: "write", location: nil, kind: .webAssembly - ), .init( + ), + .init( symbol: "swift_reportError", location: nil, kind: .webAssembly - ), .init( + ), + .init( symbol: "_swift_stdlib_reportFatalErrorInFile", location: nil, kind: .webAssembly - ), .init( - symbol: "closure #1 (UnsafeBufferPointer) -> () in closure #1 (UnsafeBufferPointer) -> () in _assertionFailure(_: StaticString, _: StaticString, file: StaticString, line: UInt, flags: UInt32) -> Never", + ), + .init( + symbol: + "closure #1 (UnsafeBufferPointer) -> () in closure #1 (UnsafeBufferPointer) -> () in _assertionFailure(_: StaticString, _: StaticString, file: StaticString, line: UInt, flags: UInt32) -> Never", location: nil, kind: .webAssembly - ), .init( - symbol: "merged closure #1 (UnsafeBufferPointer) -> () in _assertionFailure(_: StaticString, _: StaticString, file: StaticString, line: UInt, flags: UInt32) -> Never", + ), + .init( + symbol: + "merged closure #1 (UnsafeBufferPointer) -> () in _assertionFailure(_: StaticString, _: StaticString, file: StaticString, line: UInt, flags: UInt32) -> Never", location: nil, kind: .webAssembly - ), .init( - symbol: "Swift._assertionFailure(_: StaticString, _: StaticString, file: StaticString, line: UInt, flags: UInt32) -> Never", + ), + .init( + symbol: + "Swift._assertionFailure(_: StaticString, _: StaticString, file: StaticString, line: UInt, flags: UInt32) -> Never", location: nil, kind: .webAssembly - ), .init( + ), + .init( symbol: "Swift.Array.subscript.getter : (Int) -> A", location: nil, kind: .webAssembly - ), .init( + ), + .init( symbol: "TestApp.crash() -> ()", location: nil, kind: .webAssembly - ), .init( + ), + .init( symbol: "closure #1 (Array) -> () in TestApp", location: nil, kind: .webAssembly - ), .init( - symbol: "closure #1 (Array) -> JavaScriptKit.JSValue in JavaScriptKit.JSClosure.init((Array) -> ()) -> JavaScriptKit.JSClosure", + ), + .init( + symbol: + "closure #1 (Array) -> JavaScriptKit.JSValue in JavaScriptKit.JSClosure.init((Array) -> ()) -> JavaScriptKit.JSClosure", location: nil, kind: .webAssembly - ), .init( - symbol: "partial apply forwarder for closure #1 (Array) -> JavaScriptKit.JSValue in JavaScriptKit.JSClosure.init((Array) -> ()) -> JavaScriptKit.JSClosure", + ), + .init( + symbol: + "partial apply forwarder for closure #1 (Array) -> JavaScriptKit.JSValue in JavaScriptKit.JSClosure.init((Array) -> ()) -> JavaScriptKit.JSClosure", location: nil, kind: .webAssembly - ), .init( - symbol: "reabstraction thunk helper from @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue)", + ), + .init( + symbol: + "reabstraction thunk helper from @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue)", location: nil, kind: .webAssembly - ), .init( - symbol: "partial apply forwarder for reabstraction thunk helper from @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue)", + ), + .init( + symbol: + "partial apply forwarder for reabstraction thunk helper from @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue)", location: nil, kind: .webAssembly - ), .init( - symbol: "reabstraction thunk helper from @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue)", + ), + .init( + symbol: + "reabstraction thunk helper from @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue)", location: nil, kind: .webAssembly - ), .init( - symbol: "partial apply forwarder for reabstraction thunk helper from @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue)", + ), + .init( + symbol: + "partial apply forwarder for reabstraction thunk helper from @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue)", location: nil, kind: .webAssembly - ), .init( - symbol: "JavaScriptKit._call_host_function_impl(UInt32, UnsafePointer<__C.RawJSValue>, Int32, UInt32) -> ()", + ), + .init( + symbol: + "JavaScriptKit._call_host_function_impl(UInt32, UnsafePointer<__C.RawJSValue>, Int32, UInt32) -> ()", location: nil, kind: .webAssembly - ), .init( + ), + .init( symbol: "_call_host_function_impl", location: nil, kind: .webAssembly - ), .init( + ), + .init( symbol: "_call_host_function", location: nil, kind: .webAssembly - ), .init( + ), + .init( symbol: "wasm-stub", location: nil, kind: .javaScript - ), .init( + ), + .init( symbol: "swjs_call_host_function", location: nil, kind: .javaScript - ), .init( + ), + .init( symbol: "callHostFunction", location: nil, kind: .javaScript @@ -291,33 +353,33 @@ extension StackTraceTests { func testChromeStackTrace() { // swiftlint:disable line_length let stackTrace = """ - Error - at Object.wasmFs.fs.writeSync (webpack:///./entrypoint/dev.js?:54:25) - at eval (webpack:///./node_modules/@wasmer/wasi/lib/index.esm.js?:115:429) - at Array.forEach () - at eval (webpack:///./node_modules/@wasmer/wasi/lib/index.esm.js?:115:372) - at eval (webpack:///./node_modules/@wasmer/wasi/lib/index.esm.js?:102:271) - at write (:wasm-function[62105]:0x12b19bc) - at swift_reportError (:wasm-function[21697]:0x37e8aa) - at _swift_stdlib_reportFatalErrorInFile (:wasm-function[22993]:0x3e4ffe) - at $ss17_assertionFailure__4file4line5flagss5NeverOs12StaticStringV_A2HSus6UInt32VtFySRys5UInt8VGXEfU_yAMXEfU_ (:wasm-function[3676]:0xd96fc) - at $ss17_assertionFailure__4file4line5flagss5NeverOs12StaticStringV_A2HSus6UInt32VtFySRys5UInt8VGXEfU_Tm (:wasm-function[3677]:0xd98f3) - at $ss17_assertionFailure__4file4line5flagss5NeverOs12StaticStringV_A2HSus6UInt32VtF (:wasm-function[2793]:0xa9f38) - at $sSayxSicig (:wasm-function[3023]:0xb5afb) - at $s7TestApp5crashyyF (:wasm-function[1413]:0x8274d) - at $s7TestAppySay13JavaScriptKit7JSValueOGcfU_ (:wasm-function[1408]:0x81b08) - at $s13JavaScriptKit9JSClosureCyACySayAA7JSValueOGccfcAeFcfU_ (:wasm-function[816]:0x51881) - at $s13JavaScriptKit9JSClosureCyACySayAA7JSValueOGccfcAeFcfU_TA (:wasm-function[815]:0x517dc) - at $sSay13JavaScriptKit7JSValueOGACIeggo_AdCIegnr_TR (:wasm-function[812]:0x51646) - at $sSay13JavaScriptKit7JSValueOGACIeggo_AdCIegnr_TRTA (:wasm-function[811]:0x5160e) - at $sSay13JavaScriptKit7JSValueOGACIegnr_AdCIeggo_TR (:wasm-function[839]:0x54566) - at $sSay13JavaScriptKit7JSValueOGACIegnr_AdCIeggo_TRTA (:wasm-function[831]:0x54202) - at $s13JavaScriptKit24_call_host_function_implyys6UInt32V_SPySo10RawJSValueaGs5Int32VADtF (:wasm-function[830]:0x53e2e) - at _call_host_function_impl (:wasm-function[829]:0x5399e) - at _call_host_function (:wasm-function[1429]:0x83af4) - at callHostFunction (webpack:///./node_modules/javascript-kit-swift/Runtime/lib/index.js?:110:21) - at HTMLButtonElement.eval (webpack:///./node_modules/javascript-kit-swift/Runtime/lib/index.js?:295:28) - """.chromeStackTrace + Error + at Object.wasmFs.fs.writeSync (webpack:///./entrypoint/dev.js?:54:25) + at eval (webpack:///./node_modules/@wasmer/wasi/lib/index.esm.js?:115:429) + at Array.forEach () + at eval (webpack:///./node_modules/@wasmer/wasi/lib/index.esm.js?:115:372) + at eval (webpack:///./node_modules/@wasmer/wasi/lib/index.esm.js?:102:271) + at write (:wasm-function[62105]:0x12b19bc) + at swift_reportError (:wasm-function[21697]:0x37e8aa) + at _swift_stdlib_reportFatalErrorInFile (:wasm-function[22993]:0x3e4ffe) + at $ss17_assertionFailure__4file4line5flagss5NeverOs12StaticStringV_A2HSus6UInt32VtFySRys5UInt8VGXEfU_yAMXEfU_ (:wasm-function[3676]:0xd96fc) + at $ss17_assertionFailure__4file4line5flagss5NeverOs12StaticStringV_A2HSus6UInt32VtFySRys5UInt8VGXEfU_Tm (:wasm-function[3677]:0xd98f3) + at $ss17_assertionFailure__4file4line5flagss5NeverOs12StaticStringV_A2HSus6UInt32VtF (:wasm-function[2793]:0xa9f38) + at $sSayxSicig (:wasm-function[3023]:0xb5afb) + at $s7TestApp5crashyyF (:wasm-function[1413]:0x8274d) + at $s7TestAppySay13JavaScriptKit7JSValueOGcfU_ (:wasm-function[1408]:0x81b08) + at $s13JavaScriptKit9JSClosureCyACySayAA7JSValueOGccfcAeFcfU_ (:wasm-function[816]:0x51881) + at $s13JavaScriptKit9JSClosureCyACySayAA7JSValueOGccfcAeFcfU_TA (:wasm-function[815]:0x517dc) + at $sSay13JavaScriptKit7JSValueOGACIeggo_AdCIegnr_TR (:wasm-function[812]:0x51646) + at $sSay13JavaScriptKit7JSValueOGACIeggo_AdCIegnr_TRTA (:wasm-function[811]:0x5160e) + at $sSay13JavaScriptKit7JSValueOGACIegnr_AdCIeggo_TR (:wasm-function[839]:0x54566) + at $sSay13JavaScriptKit7JSValueOGACIegnr_AdCIeggo_TRTA (:wasm-function[831]:0x54202) + at $s13JavaScriptKit24_call_host_function_implyys6UInt32V_SPySo10RawJSValueaGs5Int32VADtF (:wasm-function[830]:0x53e2e) + at _call_host_function_impl (:wasm-function[829]:0x5399e) + at _call_host_function (:wasm-function[1429]:0x83af4) + at callHostFunction (webpack:///./node_modules/javascript-kit-swift/Runtime/lib/index.js?:110:21) + at HTMLButtonElement.eval (webpack:///./node_modules/javascript-kit-swift/Runtime/lib/index.js?:295:28) + """.chromeStackTrace let expected: [StackTraceItem] = [ @@ -345,79 +407,108 @@ extension StackTraceTests { symbol: "write", location: "wasm-function[62105]:0x12b19bc", kind: .webAssembly - ), .init( + ), + .init( symbol: "swift_reportError", location: "wasm-function[21697]:0x37e8aa", kind: .webAssembly - ), .init( + ), + .init( symbol: "_swift_stdlib_reportFatalErrorInFile", location: "wasm-function[22993]:0x3e4ffe", kind: .webAssembly - ), .init( - symbol: "closure #1 (UnsafeBufferPointer) -> () in closure #1 (UnsafeBufferPointer) -> () in _assertionFailure(_: StaticString, _: StaticString, file: StaticString, line: UInt, flags: UInt32) -> Never", + ), + .init( + symbol: + "closure #1 (UnsafeBufferPointer) -> () in closure #1 (UnsafeBufferPointer) -> () in _assertionFailure(_: StaticString, _: StaticString, file: StaticString, line: UInt, flags: UInt32) -> Never", location: "wasm-function[3676]:0xd96fc", kind: .webAssembly - ), .init( - symbol: "merged closure #1 (UnsafeBufferPointer) -> () in _assertionFailure(_: StaticString, _: StaticString, file: StaticString, line: UInt, flags: UInt32) -> Never", + ), + .init( + symbol: + "merged closure #1 (UnsafeBufferPointer) -> () in _assertionFailure(_: StaticString, _: StaticString, file: StaticString, line: UInt, flags: UInt32) -> Never", location: "wasm-function[3677]:0xd98f3", kind: .webAssembly - ), .init( - symbol: "Swift._assertionFailure(_: StaticString, _: StaticString, file: StaticString, line: UInt, flags: UInt32) -> Never", + ), + .init( + symbol: + "Swift._assertionFailure(_: StaticString, _: StaticString, file: StaticString, line: UInt, flags: UInt32) -> Never", location: "wasm-function[2793]:0xa9f38", kind: .webAssembly - ), .init( + ), + .init( symbol: "Swift.Array.subscript.getter : (Int) -> A", location: "wasm-function[3023]:0xb5afb", kind: .webAssembly - ), .init( + ), + .init( symbol: "TestApp.crash() -> ()", location: "wasm-function[1413]:0x8274d", kind: .webAssembly - ), .init( + ), + .init( symbol: "closure #1 (Array) -> () in TestApp", location: "wasm-function[1408]:0x81b08", kind: .webAssembly - ), .init( - symbol: "closure #1 (Array) -> JavaScriptKit.JSValue in JavaScriptKit.JSClosure.init((Array) -> ()) -> JavaScriptKit.JSClosure", + ), + .init( + symbol: + "closure #1 (Array) -> JavaScriptKit.JSValue in JavaScriptKit.JSClosure.init((Array) -> ()) -> JavaScriptKit.JSClosure", location: "wasm-function[816]:0x51881", kind: .webAssembly - ), .init( - symbol: "partial apply forwarder for closure #1 (Array) -> JavaScriptKit.JSValue in JavaScriptKit.JSClosure.init((Array) -> ()) -> JavaScriptKit.JSClosure", + ), + .init( + symbol: + "partial apply forwarder for closure #1 (Array) -> JavaScriptKit.JSValue in JavaScriptKit.JSClosure.init((Array) -> ()) -> JavaScriptKit.JSClosure", location: "wasm-function[815]:0x517dc", kind: .webAssembly - ), .init( - symbol: "reabstraction thunk helper from @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue)", + ), + .init( + symbol: + "reabstraction thunk helper from @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue)", location: "wasm-function[812]:0x51646", kind: .webAssembly - ), .init( - symbol: "partial apply forwarder for reabstraction thunk helper from @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue)", + ), + .init( + symbol: + "partial apply forwarder for reabstraction thunk helper from @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue)", location: "wasm-function[811]:0x5160e", kind: .webAssembly - ), .init( - symbol: "reabstraction thunk helper from @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue)", + ), + .init( + symbol: + "reabstraction thunk helper from @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue)", location: "wasm-function[839]:0x54566", kind: .webAssembly - ), .init( - symbol: "partial apply forwarder for reabstraction thunk helper from @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue)", + ), + .init( + symbol: + "partial apply forwarder for reabstraction thunk helper from @escaping @callee_guaranteed (@in_guaranteed Array) -> (@out JavaScriptKit.JSValue) to @escaping @callee_guaranteed (@guaranteed Array) -> (@owned JavaScriptKit.JSValue)", location: "wasm-function[831]:0x54202", kind: .webAssembly - ), .init( - symbol: "JavaScriptKit._call_host_function_impl(UInt32, UnsafePointer<__C.RawJSValue>, Int32, UInt32) -> ()", + ), + .init( + symbol: + "JavaScriptKit._call_host_function_impl(UInt32, UnsafePointer<__C.RawJSValue>, Int32, UInt32) -> ()", location: "wasm-function[830]:0x53e2e", kind: .webAssembly - ), .init( + ), + .init( symbol: "_call_host_function_impl", location: "wasm-function[829]:0x5399e", kind: .webAssembly - ), .init( + ), + .init( symbol: "_call_host_function", location: "wasm-function[1429]:0x83af4", kind: .webAssembly - ), .init( + ), + .init( symbol: "callHostFunction", location: "./node_modules/javascript-kit-swift/Runtime/lib/index.js?:110:21", kind: .javaScript - ), .init( + ), + .init( symbol: "HTMLButtonElement.eval", location: "./node_modules/javascript-kit-swift/Runtime/lib/index.js?:295:28", kind: .javaScript diff --git a/Tests/Fixtures/CrashTest/Tests/Tests.swift b/Tests/Fixtures/CrashTest/Tests/Tests.swift index 867bf4ef..605c89eb 100644 --- a/Tests/Fixtures/CrashTest/Tests/Tests.swift +++ b/Tests/Fixtures/CrashTest/Tests/Tests.swift @@ -1,8 +1,8 @@ import XCTest class Tests: XCTestCase { - func testCrash() { - // recursive call would cause stack overflow - testCrash() - } + func testCrash() { + // recursive call would cause stack overflow + testCrash() + } } diff --git a/Tests/Fixtures/FailTest/Tests/Tests.swift b/Tests/Fixtures/FailTest/Tests/Tests.swift index e116ac2f..450713b5 100644 --- a/Tests/Fixtures/FailTest/Tests/Tests.swift +++ b/Tests/Fixtures/FailTest/Tests/Tests.swift @@ -1,7 +1,7 @@ import XCTest class Tests: XCTestCase { - func testFail() { - XCTFail("Yeah") - } + func testFail() { + XCTFail("Yeah") + } } diff --git a/Tests/Fixtures/NodeJSKitTest/Package.swift b/Tests/Fixtures/NodeJSKitTest/Package.swift index 22429168..7fb2ecea 100644 --- a/Tests/Fixtures/NodeJSKitTest/Package.swift +++ b/Tests/Fixtures/NodeJSKitTest/Package.swift @@ -6,7 +6,7 @@ import PackageDescription let package = Package( name: "NodeJSKitTest", dependencies: [ - .package(url: "https://github.com/swiftwasm/JavaScriptKit", from: "0.15.0"), + .package(url: "https://github.com/swiftwasm/JavaScriptKit", from: "0.15.0") ], targets: [ // Targets are the basic building blocks of a package. A target can define a module or a test suite. diff --git a/Tests/Fixtures/TestApp/Package.swift b/Tests/Fixtures/TestApp/Package.swift index dc68dada..aa94aa66 100644 --- a/Tests/Fixtures/TestApp/Package.swift +++ b/Tests/Fixtures/TestApp/Package.swift @@ -6,10 +6,10 @@ import PackageDescription let package = Package( name: "CartonTestApp", products: [ - .executable(name: "TestApp", targets: ["TestApp"]), + .executable(name: "TestApp", targets: ["TestApp"]) ], dependencies: [ - .package(url: "https://github.com/swiftwasm/JavaScriptKit", from: "0.15.0"), + .package(url: "https://github.com/swiftwasm/JavaScriptKit", from: "0.15.0") ], targets: [ // Targets are the basic building blocks of a package. A target can define a module or a test diff --git a/Tests/Fixtures/TestApp/Sources/TestApp/main.swift b/Tests/Fixtures/TestApp/Sources/TestApp/main.swift index 0e2b9017..cf1a0fa1 100644 --- a/Tests/Fixtures/TestApp/Sources/TestApp/main.swift +++ b/Tests/Fixtures/TestApp/Sources/TestApp/main.swift @@ -44,21 +44,23 @@ let handler = JSClosure { _ in buttonNode.onclick = .object(handler) var div = document.createElement("div") -div.innerHTML = .string(#""" -Link to a static resource -
-Link to a static resource +
+ Link to a Bundle.main resource -"""#) + """#) _ = document.body.appendChild(div) var timerElement = document.createElement("p") _ = document.body.appendChild(timerElement) let timer = JSTimer(millisecondsDelay: 1000, isRepeating: true) { let date = JSDate() - timerElement.innerHTML = .string(""" -

Current date is \(date.toLocaleDateString())

-

Current time is \(date.toLocaleTimeString())

-

Current Date().timeIntervalSince1970 is \(Date().timeIntervalSince1970)

- """) + timerElement.innerHTML = .string( + """ +

Current date is \(date.toLocaleDateString())

+

Current time is \(date.toLocaleTimeString())

+

Current Date().timeIntervalSince1970 is \(Date().timeIntervalSince1970)

+ """) } From cafce4e58e30af4878a12db68690f73c73bcfc30 Mon Sep 17 00:00:00 2001 From: Yuta Saito Date: Thu, 4 May 2023 02:17:31 +0900 Subject: [PATCH 4/8] Fix wrong formatting --- Sources/CartonCLI/Commands/Bundle.swift | 2 +- Sources/CartonCLI/Commands/Init.swift | 5 +-- Sources/CartonCLI/Commands/Test.swift | 3 +- .../SwiftToolchain/ToolchainManagement.swift | 16 +++++---- Tests/CartonCommandTests/Testable.swift | 34 +++++++++++-------- 5 files changed, 35 insertions(+), 25 deletions(-) diff --git a/Sources/CartonCLI/Commands/Bundle.swift b/Sources/CartonCLI/Commands/Bundle.swift index 148c6b7a..8771d3d8 100644 --- a/Sources/CartonCLI/Commands/Bundle.swift +++ b/Sources/CartonCLI/Commands/Bundle.swift @@ -52,7 +52,7 @@ struct Bundle: AsyncParsableCommand { Which optimizations to apply to the .wasm binary output. Available values: \( WasmOptimizations.allCases.map(\.rawValue).joined(separator: ", ") - ) + ) """ ) var wasmOptimizations: WasmOptimizations = .size diff --git a/Sources/CartonCLI/Commands/Init.swift b/Sources/CartonCLI/Commands/Init.swift index 906c9ff8..4bfcf247 100644 --- a/Sources/CartonCLI/Commands/Init.swift +++ b/Sources/CartonCLI/Commands/Init.swift @@ -53,8 +53,9 @@ struct Init: AsyncParsableCommand { terminal.write("\(name)\n", inColor: .cyan) guard - let packagePath = self.name == nil - ? localFileSystem.currentWorkingDirectory : AbsolutePath(name, relativeTo: currentDir) + let packagePath = try self.name == nil + ? localFileSystem.currentWorkingDirectory + : AbsolutePath(validating: name, relativeTo: currentDir) else { terminal.write("Path to project could be created.\n", inColor: .red) return diff --git a/Sources/CartonCLI/Commands/Test.swift b/Sources/CartonCLI/Commands/Test.swift index 32937743..37a93a9a 100644 --- a/Sources/CartonCLI/Commands/Test.swift +++ b/Sources/CartonCLI/Commands/Test.swift @@ -93,7 +93,8 @@ struct Test: AsyncParsableCommand { let toolchain = try await Toolchain(localFileSystem, terminal) let bundlePath: AbsolutePath if let preBundlePath = self.prebuiltTestBundlePath { - bundlePath = AbsolutePath(preBundlePath, relativeTo: localFileSystem.currentWorkingDirectory!) + bundlePath = try AbsolutePath( + validating: preBundlePath, relativeTo: localFileSystem.currentWorkingDirectory!) guard localFileSystem.exists(bundlePath) else { terminal.write( "No prebuilt binary found at \(bundlePath)\n", diff --git a/Sources/SwiftToolchain/ToolchainManagement.swift b/Sources/SwiftToolchain/ToolchainManagement.swift index 491cf4c8..3beeb829 100644 --- a/Sources/SwiftToolchain/ToolchainManagement.swift +++ b/Sources/SwiftToolchain/ToolchainManagement.swift @@ -59,11 +59,11 @@ public class ToolchainSystem { .localDomainMask, true ).first - userXCToolchainResolver = userLibraryPath.flatMap { - XCToolchainResolver(libraryPath: AbsolutePath($0), fileSystem: fileSystem) + userXCToolchainResolver = try userLibraryPath.flatMap { + XCToolchainResolver(libraryPath: try AbsolutePath(validating: $0), fileSystem: fileSystem) } - let rootXCToolchainResolver = rootLibraryPath.flatMap { - XCToolchainResolver(libraryPath: AbsolutePath($0), fileSystem: fileSystem) + let rootXCToolchainResolver = try rootLibraryPath.flatMap { + XCToolchainResolver(libraryPath: try AbsolutePath(validating: $0), fileSystem: fileSystem) } let xctoolchainResolvers: [ToolchainResolver] = [ userXCToolchainResolver, rootXCToolchainResolver, @@ -78,9 +78,11 @@ public class ToolchainSystem { } private var libraryPaths: [AbsolutePath] { - NSSearchPathForDirectoriesInDomains( - .libraryDirectory, [.localDomainMask], true - ).map { AbsolutePath($0) } + get throws { + try NSSearchPathForDirectoriesInDomains( + .libraryDirectory, [.localDomainMask], true + ).map { try AbsolutePath(validating: $0) } + } } public var swiftVersionPath: AbsolutePath { diff --git a/Tests/CartonCommandTests/Testable.swift b/Tests/CartonCommandTests/Testable.swift index 2a487646..ee165355 100644 --- a/Tests/CartonCommandTests/Testable.swift +++ b/Tests/CartonCommandTests/Testable.swift @@ -21,29 +21,35 @@ import TSCTestSupport /// Returns path to the built products directory. public var productsDirectory: AbsolutePath { - #if os(macOS) - for bundle in Bundle.allBundles where bundle.bundlePath.hasSuffix(".xctest") { - return AbsolutePath(bundle.bundleURL.deletingLastPathComponent().path) - } - fatalError("couldn't find the products directory") - #else - return AbsolutePath(Bundle.main.bundleURL.path) - #endif + get throws { + #if os(macOS) + for bundle in Bundle.allBundles where bundle.bundlePath.hasSuffix(".xctest") { + return try AbsolutePath(validating: bundle.bundleURL.deletingLastPathComponent().path) + } + fatalError("couldn't find the products directory") + #else + return AbsolutePath(validating: Bundle.main.bundleURL.path) + #endif + } } public var testFixturesDirectory: AbsolutePath { - packageDirectory.appending(components: "Tests", "Fixtures") + get throws { + packageDirectory.appending(components: "Tests", "Fixtures") + } } public var packageDirectory: AbsolutePath { - AbsolutePath(#filePath) - .parentDirectory - .parentDirectory - .parentDirectory + get throws { + try AbsolutePath(validating: #filePath) + .parentDirectory + .parentDirectory + .parentDirectory + } } func withFixture(_ name: String, _ body: (AbsolutePath) throws -> Void) throws { - let fixtureDir = testFixturesDirectory.appending(component: name) + let fixtureDir = try testFixturesDirectory.appending(component: name) try withTemporaryDirectory(prefix: name) { tmpDirPath in let dstDir = tmpDirPath.appending(component: name) try systemQuietly("cp", "-R", "-H", fixtureDir.pathString, dstDir.pathString) From c756decb4201f6551ab2dbd2b5c9a688a6c9fe28 Mon Sep 17 00:00:00 2001 From: Yuta Saito Date: Thu, 4 May 2023 02:18:12 +0900 Subject: [PATCH 5/8] Resolve AbsolutePath(validating:) rename warnings --- Sources/CartonCLI/Commands/Dev.swift | 2 +- Sources/CartonHelpers/Process.swift | 3 ++- Sources/CartonKit/Server/HTML.swift | 2 +- Sources/SwiftToolchain/Toolchain.swift | 2 +- Tests/CartonCommandTests/SDKCommandTests.swift | 4 ++-- Tests/CartonCommandTests/Testable.swift | 6 +----- 6 files changed, 8 insertions(+), 11 deletions(-) diff --git a/Sources/CartonCLI/Commands/Dev.swift b/Sources/CartonCLI/Commands/Dev.swift index dedba73c..b16d972d 100644 --- a/Sources/CartonCLI/Commands/Dev.swift +++ b/Sources/CartonCLI/Commands/Dev.swift @@ -127,7 +127,7 @@ struct Dev: AsyncParsableCommand { port: port, host: host, customIndexPath: customIndexPage.map { - AbsolutePath($0, relativeTo: localFileSystem.currentWorkingDirectory!) + try AbsolutePath(validating: $0, relativeTo: localFileSystem.currentWorkingDirectory!) }, // swiftlint:disable:next force_try manifest: try! toolchain.manifest.get(), diff --git a/Sources/CartonHelpers/Process.swift b/Sources/CartonHelpers/Process.swift index 093c8c61..dfcf0e58 100644 --- a/Sources/CartonHelpers/Process.swift +++ b/Sources/CartonHelpers/Process.swift @@ -77,7 +77,8 @@ extension TSCBasic.Process { terminal.write(environment.map { "\($0)=\($1)" }.joined(separator: " ") + " ") } - let processName = arguments[0].first == "/" ? AbsolutePath(arguments[0]).basename : arguments[0] + let processName = + arguments[0].first == "/" ? try AbsolutePath(validating: arguments[0]).basename : arguments[0] do { try await withCheckedThrowingContinuation { diff --git a/Sources/CartonKit/Server/HTML.swift b/Sources/CartonKit/Server/HTML.swift index dacca719..d3f37c84 100644 --- a/Sources/CartonKit/Server/HTML.swift +++ b/Sources/CartonKit/Server/HTML.swift @@ -41,7 +41,7 @@ extension HTML: ResponseEncodable { if let customIndexPage = path { let content = try localFileSystem.readFileContents( customIndexPage.isAbsolutePath - ? AbsolutePath(customIndexPage) + ? AbsolutePath(validating: customIndexPage) : AbsolutePath(localFileSystem.currentWorkingDirectory!, customIndexPage) ).description diff --git a/Sources/SwiftToolchain/Toolchain.swift b/Sources/SwiftToolchain/Toolchain.swift index 7da61502..f83918ed 100644 --- a/Sources/SwiftToolchain/Toolchain.swift +++ b/Sources/SwiftToolchain/Toolchain.swift @@ -145,7 +145,7 @@ public final class Toolchain { let binPath = output.first else { fatalError("failed to decode UTF8 output of the `swift build` invocation") } - return AbsolutePath(binPath) + return try AbsolutePath(validating: binPath) } private func inferDevProduct(hint: String?) throws -> ProductDescription? { diff --git a/Tests/CartonCommandTests/SDKCommandTests.swift b/Tests/CartonCommandTests/SDKCommandTests.swift index 154ebe60..a242a844 100644 --- a/Tests/CartonCommandTests/SDKCommandTests.swift +++ b/Tests/CartonCommandTests/SDKCommandTests.swift @@ -22,7 +22,7 @@ import XCTest final class SDKCommandTests: XCTestCase { func testInstall() throws { - AssertExecuteCommand( + try AssertExecuteCommand( command: "carton sdk install", cwd: packageDirectory.url, expected: "SDK successfully installed!", @@ -31,7 +31,7 @@ final class SDKCommandTests: XCTestCase { } func testVersions() throws { - AssertExecuteCommand( + try AssertExecuteCommand( command: "carton sdk versions", cwd: packageDirectory.url, expected: "wasm-", diff --git a/Tests/CartonCommandTests/Testable.swift b/Tests/CartonCommandTests/Testable.swift index ee165355..b96ba9d3 100644 --- a/Tests/CartonCommandTests/Testable.swift +++ b/Tests/CartonCommandTests/Testable.swift @@ -35,7 +35,7 @@ public var productsDirectory: AbsolutePath { public var testFixturesDirectory: AbsolutePath { get throws { - packageDirectory.appending(components: "Tests", "Fixtures") + try packageDirectory.appending(components: "Tests", "Fixtures") } } @@ -82,8 +82,4 @@ extension AbsolutePath { else { return [] } return paths } - - static var home: AbsolutePath { - AbsolutePath(FileManager.default.homeDirectoryForCurrentUser.path) - } } From 0a96db0d939d792673d48787f643ba455722a61e Mon Sep 17 00:00:00 2001 From: Yuta Saito Date: Thu, 4 May 2023 02:22:42 +0900 Subject: [PATCH 6/8] Fix wrong formatting --- Sources/carton-release/HashArchive.swift | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Sources/carton-release/HashArchive.swift b/Sources/carton-release/HashArchive.swift index bee45477..1b21a5c8 100644 --- a/Sources/carton-release/HashArchive.swift +++ b/Sources/carton-release/HashArchive.swift @@ -106,7 +106,7 @@ struct HashArchive: AsyncParsableCommand { \(arrayString(from: $1)) ]) """ - }.joined(separator: "\n\n")) + }.joined(separator: "\n\n")) public let staticArchiveContents = "\(staticArchiveContents.withData { $0.base64EncodedString() })" """ From a08a69a330fe9e7e9aa7a8297df78433e722b4d8 Mon Sep 17 00:00:00 2001 From: Yuta Saito Date: Thu, 4 May 2023 02:24:21 +0900 Subject: [PATCH 7/8] Resolve remaining deprecation warnings --- Sources/CartonHelpers/Process.swift | 6 ++++-- Sources/CartonKit/Model/Entrypoint.swift | 5 +++-- Sources/CartonKit/Server/Server.swift | 1 - 3 files changed, 7 insertions(+), 5 deletions(-) diff --git a/Sources/CartonHelpers/Process.swift b/Sources/CartonHelpers/Process.swift index dfcf0e58..f9751059 100644 --- a/Sources/CartonHelpers/Process.swift +++ b/Sources/CartonHelpers/Process.swift @@ -106,8 +106,10 @@ extension TSCBasic.Process { arguments: arguments, environment: ProcessEnv.vars.merging(environment) { _, new in new }, outputRedirection: .stream(stdout: stdout, stderr: stderr), - verbose: true, - startNewProcessGroup: true + startNewProcessGroup: true, + loggingHandler: { + terminal.write($0) + } ) let result = Result { diff --git a/Sources/CartonKit/Model/Entrypoint.swift b/Sources/CartonKit/Model/Entrypoint.swift index 6421e9e3..2b916aff 100644 --- a/Sources/CartonKit/Model/Entrypoint.swift +++ b/Sources/CartonKit/Model/Entrypoint.swift @@ -13,10 +13,10 @@ // limitations under the License. import AsyncHTTPClient +import Basics import CartonHelpers import Foundation import TSCBasic -import TSCUtility public enum EntrypointError: Error { } @@ -60,7 +60,8 @@ public struct Entrypoint { try fileSystem.createDirectory(staticDir) try tsc_await { - ZipArchiver().extract(from: archiveFile, to: staticDir, completion: $0) + ZipArchiver(fileSystem: fileSystem).extract( + from: archiveFile, to: staticDir, completion: $0) } } } diff --git a/Sources/CartonKit/Server/Server.swift b/Sources/CartonKit/Server/Server.swift index 34387e85..c51bcafc 100644 --- a/Sources/CartonKit/Server/Server.swift +++ b/Sources/CartonKit/Server/Server.swift @@ -342,7 +342,6 @@ public func openInSystemBrowser(url: String) -> Bool { let process = Process( arguments: [openCommand, url], outputRedirection: .none, - verbose: false, startNewProcessGroup: true ) do { From b0f6483cb2ace3a5d1261e512c9afa79d37580da Mon Sep 17 00:00:00 2001 From: Yuta Saito Date: Thu, 4 May 2023 16:19:30 +0900 Subject: [PATCH 8/8] Fix Linux build failure --- Tests/CartonCommandTests/Testable.swift | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Tests/CartonCommandTests/Testable.swift b/Tests/CartonCommandTests/Testable.swift index b96ba9d3..22052c20 100644 --- a/Tests/CartonCommandTests/Testable.swift +++ b/Tests/CartonCommandTests/Testable.swift @@ -28,7 +28,7 @@ public var productsDirectory: AbsolutePath { } fatalError("couldn't find the products directory") #else - return AbsolutePath(validating: Bundle.main.bundleURL.path) + return try AbsolutePath(validating: Bundle.main.bundleURL.path) #endif } }