Ran swiftformat . on main. No other changes. (#117)

Motivation:

Have main pass the soundness checks.

Modifications:

`CONTRIBUTING.md` recommends running the `./Utilities/soundness.sh` script before making changes to the project. This script runs the `swiftformat .` command which currently modifies 34 of the files on main with no other changes to the project.

Result:

Bring main up to formatting requirements specified by `CONTRIBUTING.md`.

Author: zaneenders

Sources/AsyncProcess/FileContentStream.swift

@@ -183,11 +183,11 @@ private final class ReadIntoAsyncChannelHandler: ChannelDuplexHandler {
   private var shouldRead: Bool {
     switch self.state {
     case .idle:
-      return true
+      true
     case .error:
-      return false
+      false
     case .sending:
-      return false
+      false
     }
   }
 

Sources/AsyncProcess/ProcessExecutor+Convenience.swift

@@ -37,18 +37,18 @@ public struct OutputLoggingSettings: Sendable {
   func logMessage(line: String) -> Logger.Message {
     switch self.to {
     case .logMessage:
-      return "\(line)"
+      "\(line)"
     case .metadata(logMessage: let message, key: _):
-      return message
+      message
     }
   }
 
   func metadata(stream: ProcessOutputStream, line: String) -> Logger.Metadata {
     switch self.to {
     case .logMessage:
-      return ["stream": "\(stream.description)"]
+      ["stream": "\(stream.description)"]
     case .metadata(logMessage: _, let key):
-      return [key: "\(line)"]
+      [key: "\(line)"]
     }
   }
 }

Sources/AsyncProcess/ProcessExecutor.swift

@@ -33,9 +33,9 @@ public struct ProcessOutputStream: Sendable & Hashable & CustomStringConvertible
   public var description: String {
     switch self.backing {
     case .standardOutput:
-      return "stdout"
+      "stdout"
     case .standardError:
-      return "stderr"
+      "stderr"
     }
   }
 }

Sources/GeneratorCLI/GeneratorCLI.swift

@@ -138,7 +138,7 @@ extension GeneratorCLI {
       if let host {
         return host
       }
-      let current = try SwiftSDKGenerator.getCurrentTriple(isVerbose: verbose)
+      let current = try SwiftSDKGenerator.getCurrentTriple(isVerbose: self.verbose)
       if let arch = hostArch {
         let target = Triple(arch: arch, vendor: current.vendor!, os: current.os!)
         print("deprecated: Please use `--host \(target.triple)` instead of `--host-arch \(arch)`")
@@ -198,15 +198,16 @@ extension GeneratorCLI {
     }
 
     func run() async throws {
-      if isInvokedAsDefaultSubcommand() {
-        print("deprecated: Please explicity specify the subcommand to run. For example: $ swift-sdk-generator make-linux-sdk")
+      if self.isInvokedAsDefaultSubcommand() {
+        print(
+          "deprecated: Please explicity specify the subcommand to run. For example: $ swift-sdk-generator make-linux-sdk"
+        )
       }
-      let linuxDistributionDefaultVersion: String
-      switch self.linuxDistributionName {
+      let linuxDistributionDefaultVersion = switch self.linuxDistributionName {
       case .rhel:
-        linuxDistributionDefaultVersion = "ubi9"
+        "ubi9"
       case .ubuntu:
-        linuxDistributionDefaultVersion = "22.04"
+        "22.04"
       }
       let linuxDistributionVersion = self.linuxDistributionVersion ?? linuxDistributionDefaultVersion
       let linuxDistribution = try LinuxDistribution(name: linuxDistributionName, version: linuxDistributionVersion)
@@ -218,14 +219,14 @@ extension GeneratorCLI {
         hostTriple: hostTriple,
         linuxDistribution: linuxDistribution,
         swiftVersion: generatorOptions.swiftVersion,
-        swiftBranch: generatorOptions.swiftBranch,
-        lldVersion: lldVersion,
-        withDocker: withDocker,
-        fromContainerImage: fromContainerImage,
-        hostSwiftPackagePath: generatorOptions.hostSwiftPackagePath,
-        targetSwiftPackagePath: generatorOptions.targetSwiftPackagePath
+        swiftBranch: self.generatorOptions.swiftBranch,
+        lldVersion: self.lldVersion,
+        withDocker: self.withDocker,
+        fromContainerImage: self.fromContainerImage,
+        hostSwiftPackagePath: self.generatorOptions.hostSwiftPackagePath,
+        targetSwiftPackagePath: self.generatorOptions.targetSwiftPackagePath
       )
-      try await GeneratorCLI.run(recipe: recipe, targetTriple: targetTriple, options: generatorOptions)
+      try await GeneratorCLI.run(recipe: recipe, targetTriple: targetTriple, options: self.generatorOptions)
     }
 
     func isInvokedAsDefaultSubcommand() -> Bool {
@@ -270,17 +271,17 @@ extension GeneratorCLI {
       guard let targetSwiftPackagePath = generatorOptions.targetSwiftPackagePath else {
         throw StringError("Missing expected argument '--target-swift-package-path'")
       }
-      let recipe = WebAssemblyRecipe(
-        hostSwiftPackage: try generatorOptions.hostSwiftPackagePath.map {
+      let recipe = try WebAssemblyRecipe(
+        hostSwiftPackage: generatorOptions.hostSwiftPackagePath.map {
           let hostTriple = try self.generatorOptions.deriveHostTriple()
           return WebAssemblyRecipe.HostToolchainPackage(path: FilePath($0), triple: hostTriple)
         },
         targetSwiftPackagePath: FilePath(targetSwiftPackagePath),
-        wasiSysroot: FilePath(wasiSysroot),
-        swiftVersion: generatorOptions.swiftVersion
+        wasiSysroot: FilePath(self.wasiSysroot),
+        swiftVersion: self.generatorOptions.swiftVersion
       )
       let targetTriple = self.deriveTargetTriple()
-      try await GeneratorCLI.run(recipe: recipe, targetTriple: targetTriple, options: generatorOptions)
+      try await GeneratorCLI.run(recipe: recipe, targetTriple: targetTriple, options: self.generatorOptions)
     }
   }
 }

Sources/GeneratorEngine/Cache/CacheKeyProtocol.swift

@@ -16,8 +16,7 @@ import struct SystemPackage.FilePath
 
 /// Indicates that values of a conforming type can be hashed with an arbitrary hashing function. Unlike `Hashable`,
 /// this protocol doesn't utilize random seed values and produces consistent hash values across process launches.
-public protocol CacheKey: Encodable {
-}
+public protocol CacheKey: Encodable {}
 
 /// Types that cannot be decomposed more to be hashed
 protocol LeafCacheKey: CacheKey {

Sources/GeneratorEngine/Cache/SQLite.swift

@@ -135,11 +135,11 @@ public final class SQLite {
     var pathString: String {
       switch self {
       case let .path(path):
-        return path.string
+        path.string
       case .memory:
-        return ":memory:"
+        ":memory:"
       case .temporary:
-        return ""
+        ""
       }
     }
   }

Sources/GeneratorEngine/Engine.swift

@@ -11,108 +11,107 @@
 //===----------------------------------------------------------------------===//
 
 @_exported import Crypto
+import Helpers
 import struct Logging.Logger
 @_exported import struct SystemPackage.FilePath
-import Helpers
 
 public func withEngine(
-    _ fileSystem: any FileSystem,
-    _ logger: Logger,
-    cacheLocation: SQLite.Location,
-    _ body: @Sendable (Engine) async throws -> Void
+  _ fileSystem: any FileSystem,
+  _ logger: Logger,
+  cacheLocation: SQLite.Location,
+  _ body: @Sendable (Engine) async throws -> ()
 ) async throws {
-    let engine = Engine(
-        fileSystem,
-        logger,
-        cacheLocation: cacheLocation
-    )
-
-    try await withAsyncThrowing {
-        try await body(engine)
-    } defer: {
-        try await engine.shutDown()
-    }
+  let engine = Engine(
+    fileSystem,
+    logger,
+    cacheLocation: cacheLocation
+  )
+
+  try await withAsyncThrowing {
+    try await body(engine)
+  } defer: {
+    try await engine.shutDown()
+  }
 }
 
 /// Cacheable computations engine. Currently the engine makes an assumption that computations produce same results for
 /// the same query values and write results to a single file path.
 public actor Engine {
-    private(set) var cacheHits = 0
-    private(set) var cacheMisses = 0
-
-    public let fileSystem: any FileSystem
-    public let logger: Logger
-    private let resultsCache: SQLiteBackedCache
-    private var isShutDown = false
-
-    /// Creates a new instance of the ``QueryEngine`` actor. Requires an explicit call
-    /// to ``QueryEngine//shutdown`` before the instance is deinitialized. The recommended approach to resource
-    /// management is to place `engine.shutDown()` when the engine is no longer used, but is not deinitialized yet.
-    /// - Parameter fileSystem: Implementation of a file system this engine should use.
-    /// - Parameter cacheLocation: Location of cache storage used by the engine.
-    /// - Parameter logger: Logger to use during queries execution.
-    init(
-        _ fileSystem: any FileSystem,
-        _ logger: Logger,
-        cacheLocation: SQLite.Location
-    ) {
-        self.fileSystem = fileSystem
-        self.logger = logger
-        self.resultsCache = SQLiteBackedCache(tableName: "cache_table", location: cacheLocation, logger)
-    }
+  private(set) var cacheHits = 0
+  private(set) var cacheMisses = 0
+
+  public let fileSystem: any FileSystem
+  public let logger: Logger
+  private let resultsCache: SQLiteBackedCache
+  private var isShutDown = false
+
+  /// Creates a new instance of the ``QueryEngine`` actor. Requires an explicit call
+  /// to ``QueryEngine//shutdown`` before the instance is deinitialized. The recommended approach to resource
+  /// management is to place `engine.shutDown()` when the engine is no longer used, but is not deinitialized yet.
+  /// - Parameter fileSystem: Implementation of a file system this engine should use.
+  /// - Parameter cacheLocation: Location of cache storage used by the engine.
+  /// - Parameter logger: Logger to use during queries execution.
+  init(
+    _ fileSystem: any FileSystem,
+    _ logger: Logger,
+    cacheLocation: SQLite.Location
+  ) {
+    self.fileSystem = fileSystem
+    self.logger = logger
+    self.resultsCache = SQLiteBackedCache(tableName: "cache_table", location: cacheLocation, logger)
+  }
+
+  public func shutDown() async throws {
+    precondition(!self.isShutDown, "`QueryEngine/shutDown` should be called only once")
+    try self.resultsCache.close()
+
+    self.isShutDown = true
+  }
+
+  deinit {
+    let isShutDown = self.isShutDown
+    precondition(
+      isShutDown,
+      "`QueryEngine/shutDown` should be called explicitly on instances of `Engine` before deinitialization"
+    )
+  }
+
+  /// Executes a given query if no cached result of it is available. Otherwise fetches the result from engine's cache.
+  /// - Parameter query: A query value to execute.
+  /// - Returns: A file path to query's result recorded in a file.
+  public subscript(_ query: some Query) -> FileCacheRecord {
+    get async throws {
+      let hashEncoder = HashEncoder<SHA512>()
+      try hashEncoder.encode(query.cacheKey)
+      let key = hashEncoder.finalize()
+
+      if let fileRecord = try resultsCache.get(key, as: FileCacheRecord.self) {
+        let fileHash = try await self.fileSystem.withOpenReadableFile(fileRecord.path) {
+          var hashFunction = SHA512()
+          try await $0.hash(with: &hashFunction)
+          return hashFunction.finalize().description
+        }
+
+        if fileHash == fileRecord.hash {
+          self.cacheHits += 1
+          return fileRecord
+        }
+      }
 
-    public func shutDown() async throws {
-        precondition(!self.isShutDown, "`QueryEngine/shutDown` should be called only once")
-        try self.resultsCache.close()
+      self.cacheMisses += 1
+      let resultPath = try await query.run(engine: self)
 
-        self.isShutDown = true
-    }
+      let resultHash = try await self.fileSystem.withOpenReadableFile(resultPath) {
+        var hashFunction = SHA512()
+        try await $0.hash(with: &hashFunction)
+        return hashFunction.finalize().description
+      }
+      let result = FileCacheRecord(path: resultPath, hash: resultHash)
 
-    deinit {
-        let isShutDown = self.isShutDown
-        precondition(
-            isShutDown,
-            "`QueryEngine/shutDown` should be called explicitly on instances of `Engine` before deinitialization"
-        )
-    }
+      // FIXME: update `SQLiteBackedCache` to store `resultHash` directly instead of relying on string conversions
+      try self.resultsCache.set(key, to: result)
 
-    /// Executes a given query if no cached result of it is available. Otherwise fetches the result from engine's cache.
-    /// - Parameter query: A query value to execute.
-    /// - Returns: A file path to query's result recorded in a file.
-    public subscript(_ query: some Query) -> FileCacheRecord {
-        get async throws {
-            let hashEncoder = HashEncoder<SHA512>()
-            try hashEncoder.encode(query.cacheKey)
-            let key = hashEncoder.finalize()
-
-            if let fileRecord = try resultsCache.get(key, as: FileCacheRecord.self) {
-
-                let fileHash = try await self.fileSystem.withOpenReadableFile(fileRecord.path) {
-                    var hashFunction = SHA512()
-                    try await $0.hash(with: &hashFunction)
-                    return hashFunction.finalize().description
-                }
-
-                if fileHash == fileRecord.hash {
-                    self.cacheHits += 1
-                    return fileRecord
-                }
-            }
-
-            self.cacheMisses += 1
-            let resultPath = try await query.run(engine: self)
-
-            let resultHash = try await self.fileSystem.withOpenReadableFile(resultPath) {
-                var hashFunction = SHA512()
-                try await $0.hash(with: &hashFunction)
-                return hashFunction.finalize().description
-            }
-            let result = FileCacheRecord(path: resultPath, hash: resultHash)
-
-            // FIXME: update `SQLiteBackedCache` to store `resultHash` directly instead of relying on string conversions
-            try self.resultsCache.set(key, to: result)
-
-            return result
-        }
+      return result
     }
+  }
 }

Sources/GeneratorEngine/FileSystem/FileSystem.swift

@@ -28,9 +28,9 @@ enum FileSystemError: Error {
 extension Error {
   func attach(path: FilePath) -> any Error {
     if let error = self as? Errno {
-      return FileSystemError.systemError(path, error)
+      FileSystemError.systemError(path, error)
     } else {
-      return self
+      self
     }
   }
 }

Sources/GeneratorEngine/FileSystem/OpenReadableFile.swift

@@ -25,9 +25,9 @@ public struct OpenReadableFile {
   func read() async throws -> ReadableFileStream {
     switch self.fileHandle {
     case let .local(fileDescriptor):
-      return ReadableFileStream.local(.init(fileDescriptor: fileDescriptor, readChunkSize: self.readChunkSize))
+      ReadableFileStream.local(.init(fileDescriptor: fileDescriptor, readChunkSize: self.readChunkSize))
     case let .virtual(array):
-      return ReadableFileStream.virtual(.init(bytes: array))
+      ReadableFileStream.virtual(.init(bytes: array))
     }
   }
 

Sources/GeneratorEngine/FileSystem/ReadableFileStream.swift

@@ -25,19 +25,19 @@ public enum ReadableFileStream: AsyncSequence {
     public func next() async throws -> [UInt8]? {
       switch self {
       case let .local(local):
-        return try await local.next()
+        try await local.next()
       case let .virtual(virtual):
-        return try await virtual.next()
+        try await virtual.next()
       }
     }
   }
 
   public func makeAsyncIterator() -> Iterator {
     switch self {
     case let .local(local):
-      return .local(local.makeAsyncIterator())
+      .local(local.makeAsyncIterator())
     case let .virtual(virtual):
-      return .virtual(virtual.makeAsyncIterator())
+      .virtual(virtual.makeAsyncIterator())
     }
   }
 }