Format repository

Author: bkhouri

.swift-format

@@ -1,10 +1,13 @@
 {
-	"version": 1,
-	"lineLength": 10000,
-	"indentation": {
-		"spaces": 4
-	},
-	"rules": {
-	},
-	"tabWidth": 4
+    "version": 1,
+    "lineLength": 10000,
+    "indentation": {
+        "spaces": 4
+    },
+    "lineBreakBeforeEachArgument": true,
+    "maximumBlankLines" : 1,
+    "multiElementCollectionTrailingCommas" : true,
+    "rules": {
+    },
+    "tabWidth": 4
 }

Package.swift

@@ -66,7 +66,7 @@ struct CMakeSmokeTest: CommandPlugin {
         }
 
         var sharedSwiftFlags = [
-            "-module-cache-path", moduleCachePath
+            "-module-cache-path", moduleCachePath,
         ]
 
         if let sysrootPath {
@@ -79,15 +79,16 @@ struct CMakeSmokeTest: CommandPlugin {
             "-DTSC_DIR=\(swiftToolsSupportCoreBuildURL.appending(components: "cmake", "modules").filePath)",
             "-DSwiftDriver_DIR=\(swiftDriverBuildURL.appending(components: "cmake", "modules").filePath)",
             "-DSwiftSystem_DIR=\(swiftSystemBuildURL.appending(components: "cmake", "modules").filePath)",
-            "-DSwiftToolsProtocols_DIR=\(swiftToolsProtocolsBuildURL.appending(components: "cmake", "modules").filePath)"
+            "-DSwiftToolsProtocols_DIR=\(swiftToolsProtocolsBuildURL.appending(components: "cmake", "modules").filePath)",
         ]
 
-        let sharedCMakeArgs = [
-            "-G", "Ninja",
-            "-DCMAKE_MAKE_PROGRAM=\(ninjaPath)",
-            "-DCMAKE_BUILD_TYPE:=Debug",
-            "-DCMAKE_Swift_FLAGS='\(sharedSwiftFlags.joined(separator: " "))'"
-        ] + cMakeProjectArgs + extraCMakeArgs
+        let sharedCMakeArgs =
+            [
+                "-G", "Ninja",
+                "-DCMAKE_MAKE_PROGRAM=\(ninjaPath)",
+                "-DCMAKE_BUILD_TYPE:=Debug",
+                "-DCMAKE_Swift_FLAGS='\(sharedSwiftFlags.joined(separator: " "))'",
+            ] + cMakeProjectArgs + extraCMakeArgs
 
         Diagnostics.progress("Building swift-tools-support-core")
         try await Process.checkNonZeroExit(url: cmakeURL, arguments: sharedCMakeArgs + [swiftToolsSupportCoreURL.filePath], workingDirectory: swiftToolsSupportCoreBuildURL)
@@ -168,13 +169,13 @@ enum OS {
 
     static func host() throws -> Self {
         #if os(macOS)
-        return .macOS
+            return .macOS
         #elseif os(Linux)
-        return .linux
+            return .linux
         #elseif os(Windows)
-        return .windows
+            return .windows
         #else
-        throw Errors.unimplementedForHostOS
+            throw Errors.unimplementedForHostOS
         #endif
     }
 }
@@ -211,100 +212,104 @@ extension Process {
     static func checkNonZeroExit(url: URL, arguments: [String], workingDirectory: URL, environment: [String: String]? = nil) async throws {
         try Diagnostics.progress("\(url.filePath) \(arguments.joined(separator: " "))")
         #if USE_PROCESS_SPAWNING_WORKAROUND && !os(Windows)
-        Diagnostics.progress("Using process spawning workaround")
-        // Linux workaround for https://github.com/swiftlang/swift-corelibs-foundation/issues/4772
-        // Foundation.Process on Linux seems to inherit the Process.run()-calling thread's signal mask, creating processes that even have SIGTERM blocked
-        // This manifests as CMake getting stuck when invoking 'uname' with incorrectly configured signal handlers.
-        var fileActions = posix_spawn_file_actions_t()
-        defer { posix_spawn_file_actions_destroy(&fileActions) }
-        var attrs: posix_spawnattr_t = posix_spawnattr_t()
-        defer { posix_spawnattr_destroy(&attrs) }
-        posix_spawn_file_actions_init(&fileActions)
-        try posix_spawn_file_actions_addchdir_np(&fileActions, workingDirectory.filePath)
-
-        posix_spawnattr_init(&attrs)
-        posix_spawnattr_setpgroup(&attrs, 0)
-        var noSignals = sigset_t()
-        sigemptyset(&noSignals)
-        posix_spawnattr_setsigmask(&attrs, &noSignals)
-
-        var mostSignals = sigset_t()
-        sigemptyset(&mostSignals)
-        for i in 1 ..< SIGSYS {
-            if i == SIGKILL || i == SIGSTOP {
-                continue
-            }
-            sigaddset(&mostSignals, i)
-        }
-        posix_spawnattr_setsigdefault(&attrs, &mostSignals)
-        posix_spawnattr_setflags(&attrs, numericCast(POSIX_SPAWN_SETPGROUP | POSIX_SPAWN_SETSIGDEF | POSIX_SPAWN_SETSIGMASK))
-        var pid: pid_t = -1
-        try withArrayOfCStrings([url.filePath] + arguments) { arguments in
-            try withArrayOfCStrings((environment ?? [:]).map { key, value in "\(key)=\(value)" }) { environment in
-                let spawnResult = try posix_spawn(&pid, url.filePath, /*file_actions=*/&fileActions, /*attrp=*/&attrs, arguments, nil);
-                var exitCode: Int32 = -1
-                var result = wait4(pid, &exitCode, 0, nil);
-                while (result == -1 && errno == EINTR) {
-                    result = wait4(pid, &exitCode, 0, nil)
-                }
-                guard result != -1 else {
-                    throw Errors.miscError("wait failed")
+            Diagnostics.progress("Using process spawning workaround")
+            // Linux workaround for https://github.com/swiftlang/swift-corelibs-foundation/issues/4772
+            // Foundation.Process on Linux seems to inherit the Process.run()-calling thread's signal mask, creating processes that even have SIGTERM blocked
+            // This manifests as CMake getting stuck when invoking 'uname' with incorrectly configured signal handlers.
+            var fileActions = posix_spawn_file_actions_t()
+            defer { posix_spawn_file_actions_destroy(&fileActions) }
+            var attrs: posix_spawnattr_t = posix_spawnattr_t()
+            defer { posix_spawnattr_destroy(&attrs) }
+            posix_spawn_file_actions_init(&fileActions)
+            try posix_spawn_file_actions_addchdir_np(&fileActions, workingDirectory.filePath)
+
+            posix_spawnattr_init(&attrs)
+            posix_spawnattr_setpgroup(&attrs, 0)
+            var noSignals = sigset_t()
+            sigemptyset(&noSignals)
+            posix_spawnattr_setsigmask(&attrs, &noSignals)
+
+            var mostSignals = sigset_t()
+            sigemptyset(&mostSignals)
+            for i in 1..<SIGSYS {
+                if i == SIGKILL || i == SIGSTOP {
+                    continue
                 }
-                guard exitCode == 0 else {
-                    throw Errors.miscError("exit code nonzero")
+                sigaddset(&mostSignals, i)
+            }
+            posix_spawnattr_setsigdefault(&attrs, &mostSignals)
+            posix_spawnattr_setflags(&attrs, numericCast(POSIX_SPAWN_SETPGROUP | POSIX_SPAWN_SETSIGDEF | POSIX_SPAWN_SETSIGMASK))
+            var pid: pid_t = -1
+            try withArrayOfCStrings([url.filePath] + arguments) { arguments in
+                try withArrayOfCStrings((environment ?? [:]).map { key, value in "\(key)=\(value)" }) { environment in
+                    let spawnResult = try posix_spawn(&pid, url.filePath, /*file_actions=*/ &fileActions, /*attrp=*/ &attrs, arguments, nil);
+                    var exitCode: Int32 = -1
+                    var result = wait4(pid, &exitCode, 0, nil);
+                    while (result == -1 && errno == EINTR) {
+                        result = wait4(pid, &exitCode, 0, nil)
+                    }
+                    guard result != -1 else {
+                        throw Errors.miscError("wait failed")
+                    }
+                    guard exitCode == 0 else {
+                        throw Errors.miscError("exit code nonzero")
+                    }
                 }
             }
-        }
         #else
-        let process = Process()
-        process.executableURL = url
-        process.arguments = arguments
-        process.currentDirectoryURL = workingDirectory
-        process.environment = environment
-        try await process.run()
-        if process.terminationStatus != 0 {
-            throw Errors.processError(terminationReason: process.terminationReason, terminationStatus: process.terminationStatus)
-        }
+            let process = Process()
+            process.executableURL = url
+            process.arguments = arguments
+            process.currentDirectoryURL = workingDirectory
+            process.environment = environment
+            try await process.run()
+            if process.terminationStatus != 0 {
+                throw Errors.processError(terminationReason: process.terminationReason, terminationStatus: process.terminationStatus)
+            }
         #endif
     }
 }
 
 #if USE_PROCESS_SPAWNING_WORKAROUND && !os(Windows)
-func scan<S: Sequence, U>(_ seq: S, _ initial: U, _ combine: (U, S.Element) -> U) -> [U] {
-  var result: [U] = []
-  result.reserveCapacity(seq.underestimatedCount)
-  var runningResult = initial
-  for element in seq {
-    runningResult = combine(runningResult, element)
-    result.append(runningResult)
-  }
-  return result
-}
+    func scan<S: Sequence, U>(_ seq: S, _ initial: U, _ combine: (U, S.Element) -> U) -> [U] {
+        var result: [U] = []
+        result.reserveCapacity(seq.underestimatedCount)
+        var runningResult = initial
+        for element in seq {
+            runningResult = combine(runningResult, element)
+            result.append(runningResult)
+        }
+        return result
+    }
 
-func withArrayOfCStrings<T>(
-  _ args: [String],
-  _ body: (UnsafePointer<UnsafeMutablePointer<Int8>?>) throws -> T
-) throws -> T {
-  let argsCounts = Array(args.map { $0.utf8.count + 1 })
-  let argsOffsets = [0] + scan(argsCounts, 0, +)
-  let argsBufferSize = argsOffsets.last!
-  var argsBuffer: [UInt8] = []
-  argsBuffer.reserveCapacity(argsBufferSize)
-  for arg in args {
-    argsBuffer.append(contentsOf: arg.utf8)
-    argsBuffer.append(0)
-  }
-  return try argsBuffer.withUnsafeMutableBufferPointer {
-    (argsBuffer) in
-    let ptr = UnsafeRawPointer(argsBuffer.baseAddress!).bindMemory(
-      to: Int8.self, capacity: argsBuffer.count)
-    var cStrings: [UnsafePointer<Int8>?] = argsOffsets.map { ptr + $0 }
-    cStrings[cStrings.count - 1] = nil
-    return try cStrings.withUnsafeMutableBufferPointer {
-      let unsafeString = UnsafeMutableRawPointer($0.baseAddress!).bindMemory(
-        to: UnsafeMutablePointer<Int8>?.self, capacity: $0.count)
-      return try body(unsafeString)
+    func withArrayOfCStrings<T>(
+        _ args: [String],
+        _ body: (UnsafePointer<UnsafeMutablePointer<Int8>?>) throws -> T
+    ) throws -> T {
+        let argsCounts = Array(args.map { $0.utf8.count + 1 })
+        let argsOffsets = [0] + scan(argsCounts, 0, +)
+        let argsBufferSize = argsOffsets.last!
+        var argsBuffer: [UInt8] = []
+        argsBuffer.reserveCapacity(argsBufferSize)
+        for arg in args {
+            argsBuffer.append(contentsOf: arg.utf8)
+            argsBuffer.append(0)
+        }
+        return try argsBuffer.withUnsafeMutableBufferPointer {
+            (argsBuffer) in
+            let ptr = UnsafeRawPointer(argsBuffer.baseAddress!).bindMemory(
+                to: Int8.self,
+                capacity: argsBuffer.count
+            )
+            var cStrings: [UnsafePointer<Int8>?] = argsOffsets.map { ptr + $0 }
+            cStrings[cStrings.count - 1] = nil
+            return try cStrings.withUnsafeMutableBufferPointer {
+                let unsafeString = UnsafeMutableRawPointer($0.baseAddress!).bindMemory(
+                    to: UnsafeMutablePointer<Int8>?.self,
+                    capacity: $0.count
+                )
+                return try body(unsafeString)
+            }
+        }
     }
-  }
-}
 #endif

Plugins/cmake-smoke-test/cmake-smoke-test.swift

@@ -25,24 +25,24 @@ struct GenerateWindowsInstallerComponentGroups: CommandPlugin {
                 continue
             }
             librariesComponent += #"""
-                  <Component>
-                    <File Source="$(ToolchainRoot)\usr\bin\\#(sourceModule.name).dll" />
-                  </Component>
+                      <Component>
+                        <File Source="$(ToolchainRoot)\usr\bin\\#(sourceModule.name).dll" />
+                      </Component>
 
-            """#
+                """#
 
             let resources = sourceModule.sourceFiles.filter { resource in resource.type == .resource && ["xcspec", "xcbuildrules"].contains(resource.url.pathExtension) }
             if !resources.isEmpty {
                 groupRefs += #"      <ComponentGroupRef Id="\#(sourceModule.name)Resources" />\#n"#
                 directories += #"                  <Directory Id="_usr_share_pm_\#(sourceModule.name)" Name="SwiftBuild_\#(sourceModule.name).resources" />\#n"#
                 resourcesComponents += #"    <ComponentGroup Id="\#(sourceModule.name)Resources" Directory="_usr_share_pm_\#(sourceModule.name)">\#n"#
-                for resource in resources  {
+                for resource in resources {
                     resourcesComponents += #"""
-                      <Component>
-                        <File Source="$(ToolchainRoot)\usr\share\pm\SwiftBuild_\#(sourceModule.name).resources\\#(resource.url.lastPathComponent)" />
-                      </Component>
+                              <Component>
+                                <File Source="$(ToolchainRoot)\usr\share\pm\SwiftBuild_\#(sourceModule.name).resources\\#(resource.url.lastPathComponent)" />
+                              </Component>
 
-                """#
+                        """#
                 }
                 resourcesComponents += "    </ComponentGroup>\n"
             }

Plugins/generate-windows-installer-component-groups/generate-windows-installer-component-groups.swift

@@ -17,37 +17,37 @@ import Foundation
 struct LaunchXcode: CommandPlugin {
     func performCommand(context: PluginContext, arguments: [String]) async throws {
         #if !os(macOS)
-        throw LaunchXcodeError.unsupportedPlatform
+            throw LaunchXcodeError.unsupportedPlatform
         #else
-        var args = ArgumentExtractor(arguments)
-        var configuration: PackageManager.BuildConfiguration = .debug
-        // --release
-        if args.extractFlag(named: "release") > 0 {
-            configuration = .release
-        } else {
-            // --configuration release
-            let configurationOptions = args.extractOption(named: "configuration")
-            if configurationOptions.contains("release") {
+            var args = ArgumentExtractor(arguments)
+            var configuration: PackageManager.BuildConfiguration = .debug
+            // --release
+            if args.extractFlag(named: "release") > 0 {
                 configuration = .release
+            } else {
+                // --configuration release
+                let configurationOptions = args.extractOption(named: "configuration")
+                if configurationOptions.contains("release") {
+                    configuration = .release
+                }
             }
-        }
 
-        let buildResult = try packageManager.build(.all(includingTests: false), parameters: .init(configuration: configuration, echoLogs: true))
-        guard buildResult.succeeded else { return }
-        guard let buildServiceURL = buildResult.builtArtifacts.map({ $0.url }).filter({ $0.lastPathComponent == "SWBBuildServiceBundle" }).first else {
-            throw LaunchXcodeError.buildServiceURLNotFound
-        }
+            let buildResult = try packageManager.build(.all(includingTests: false), parameters: .init(configuration: configuration, echoLogs: true))
+            guard buildResult.succeeded else { return }
+            guard let buildServiceURL = buildResult.builtArtifacts.map({ $0.url }).filter({ $0.lastPathComponent == "SWBBuildServiceBundle" }).first else {
+                throw LaunchXcodeError.buildServiceURLNotFound
+            }
 
-        print("Launching Xcode...")
-        let process = Process()
-        process.executableURL = URL(fileURLWithPath: "/usr/bin/open")
-        process.arguments = ["-n", "-F", "-W", "--env", "XCBBUILDSERVICE_PATH=\(buildServiceURL.path())", "-b", "com.apple.dt.Xcode"]
-        process.standardOutput = nil
-        process.standardError = nil
-        try await process.run()
-        if process.terminationStatus != 0 {
-            throw LaunchXcodeError.launchFailed
-        }
+            print("Launching Xcode...")
+            let process = Process()
+            process.executableURL = URL(fileURLWithPath: "/usr/bin/open")
+            process.arguments = ["-n", "-F", "-W", "--env", "XCBBUILDSERVICE_PATH=\(buildServiceURL.path())", "-b", "com.apple.dt.Xcode"]
+            process.standardOutput = nil
+            process.standardError = nil
+            try await process.run()
+            if process.terminationStatus != 0 {
+                throw LaunchXcodeError.launchFailed
+            }
         #endif
     }
 }