Upgrading swift-format dependency to Swift 5.10 and reformatting code base

Author: tothambrus11

Package.swift

@@ -55,7 +55,7 @@ let package = Package(
       branch: "main"),
     .package(
       url: "https://github.com/apple/swift-format",
-      from: "508.0.1"),
+      from: "510.1.0"),
     .package(
       url: "https://github.com/SwiftPackageIndex/SPIManifest.git",
       from: "0.12.0"),

Sources/CodeGen/LLVM/ConcreteTypeLayout.swift

@@ -88,4 +88,3 @@ struct ConcreteTypeLayout {
   }
 
 }
-

Sources/CodeGen/LLVM/Transpilation.swift

@@ -4,10 +4,10 @@ import IR
 import SwiftyLLVM
 import Utils
 
-fileprivate extension SwiftyLLVM.OverflowBehavior {
+extension SwiftyLLVM.OverflowBehavior {
 
   /// An instance equivalent to `x`
-  init(_ x: FrontEnd.OverflowBehavior) {
+  fileprivate init(_ x: FrontEnd.OverflowBehavior) {
     switch x {
     case .ignore: self = .ignore
     case .nsw: self = .nsw
@@ -17,10 +17,10 @@ fileprivate extension SwiftyLLVM.OverflowBehavior {
 
 }
 
-fileprivate extension SwiftyLLVM.IntegerPredicate {
+extension SwiftyLLVM.IntegerPredicate {
 
   /// An instance equivalent to `x`
-  init(_ x: FrontEnd.IntegerPredicate) {
+  fileprivate init(_ x: FrontEnd.IntegerPredicate) {
     switch x {
     case .eq: self = .eq
     case .slt: self = .slt
@@ -37,10 +37,10 @@ fileprivate extension SwiftyLLVM.IntegerPredicate {
 
 }
 
-fileprivate extension SwiftyLLVM.FloatingPointPredicate {
+extension SwiftyLLVM.FloatingPointPredicate {
 
   /// An instance equivalent to `x`
-  init(_ x: FrontEnd.FloatingPointPredicate) {
+  fileprivate init(_ x: FrontEnd.FloatingPointPredicate) {
     switch x {
     case .alwaysFalse: self = .alwaysFalse
     case .alwaysTrue: self = .alwaysTrue
@@ -121,11 +121,12 @@ extension SwiftyLLVM.Module {
 
     // Get the declaraiton of LLVM function corresponding to `f`. It is possible that this function
     // has already been declared if it is referred to by some code that was transpiled first.
-    let transpilation = if context.source[f].isSubscript {
-      declareSubscript(transpiledFrom: f, in: &context)
-    } else {
-      declareFunction(transpiledFrom: f, in: &context)
-    }
+    let transpilation =
+      if context.source[f].isSubscript {
+        declareSubscript(transpiledFrom: f, in: &context)
+      } else {
+        declareFunction(transpiledFrom: f, in: &context)
+      }
 
     transpile(contentsOf: f, into: transpilation.function, inContext: &context)
     if f == context.source.entryFunction {
@@ -1465,94 +1466,130 @@ extension SwiftyLLVM.Module {
         insert(atomicRMW: .xor, ordering: .sequentiallyConsistent, for: i)
 
       case .atomic_cmpxchg_relaxed_relaxed:
-        insertAtomicCompareExchange(successOrdering: .monotonic, failureOrdering: .monotonic, weak: false, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .monotonic, failureOrdering: .monotonic, weak: false, for: i)
 
       case .atomic_cmpxchg_relaxed_acquire:
-        insertAtomicCompareExchange(successOrdering: .monotonic, failureOrdering: .acquire, weak: false, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .monotonic, failureOrdering: .acquire, weak: false, for: i)
 
       case .atomic_cmpxchg_relaxed_seqcst:
-        insertAtomicCompareExchange(successOrdering: .monotonic, failureOrdering: .sequentiallyConsistent, weak: false, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .monotonic, failureOrdering: .sequentiallyConsistent, weak: false, for: i
+        )
 
       case .atomic_cmpxchg_acquire_relaxed:
-        insertAtomicCompareExchange(successOrdering: .acquire, failureOrdering: .monotonic, weak: false, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .acquire, failureOrdering: .monotonic, weak: false, for: i)
 
       case .atomic_cmpxchg_acquire_acquire:
-        insertAtomicCompareExchange(successOrdering: .acquire, failureOrdering: .acquire, weak: false, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .acquire, failureOrdering: .acquire, weak: false, for: i)
 
       case .atomic_cmpxchg_acquire_seqcst:
-        insertAtomicCompareExchange(successOrdering: .acquire, failureOrdering: .sequentiallyConsistent, weak: false, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .acquire, failureOrdering: .sequentiallyConsistent, weak: false, for: i)
 
       case .atomic_cmpxchg_release_relaxed:
-        insertAtomicCompareExchange(successOrdering: .release, failureOrdering: .monotonic, weak: false, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .release, failureOrdering: .monotonic, weak: false, for: i)
 
       case .atomic_cmpxchg_release_acquire:
-        insertAtomicCompareExchange(successOrdering: .release, failureOrdering: .acquire, weak: false, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .release, failureOrdering: .acquire, weak: false, for: i)
 
       case .atomic_cmpxchg_release_seqcst:
-        insertAtomicCompareExchange(successOrdering: .release, failureOrdering: .sequentiallyConsistent, weak: false, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .release, failureOrdering: .sequentiallyConsistent, weak: false, for: i)
 
       case .atomic_cmpxchg_acqrel_relaxed:
-        insertAtomicCompareExchange(successOrdering: .acquireRelease, failureOrdering: .monotonic, weak: false, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .acquireRelease, failureOrdering: .monotonic, weak: false, for: i)
 
       case .atomic_cmpxchg_acqrel_acquire:
-        insertAtomicCompareExchange(successOrdering: .acquireRelease, failureOrdering: .acquire, weak: false, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .acquireRelease, failureOrdering: .acquire, weak: false, for: i)
 
       case .atomic_cmpxchg_acqrel_seqcst:
-        insertAtomicCompareExchange(successOrdering: .acquireRelease, failureOrdering: .sequentiallyConsistent, weak: false, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .acquireRelease, failureOrdering: .sequentiallyConsistent, weak: false,
+          for: i)
 
       case .atomic_cmpxchg_seqcst_relaxed:
-        insertAtomicCompareExchange(successOrdering: .sequentiallyConsistent, failureOrdering: .monotonic, weak: false, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .sequentiallyConsistent, failureOrdering: .monotonic, weak: false, for: i
+        )
 
       case .atomic_cmpxchg_seqcst_acquire:
-        insertAtomicCompareExchange(successOrdering: .sequentiallyConsistent, failureOrdering: .acquire, weak: false, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .sequentiallyConsistent, failureOrdering: .acquire, weak: false, for: i)
 
       case .atomic_cmpxchg_seqcst_seqcst:
-        insertAtomicCompareExchange(successOrdering: .sequentiallyConsistent, failureOrdering: .sequentiallyConsistent, weak: false, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .sequentiallyConsistent, failureOrdering: .sequentiallyConsistent,
+          weak: false, for: i)
 
       case .atomic_cmpxchgweak_relaxed_relaxed:
-        insertAtomicCompareExchange(successOrdering: .monotonic, failureOrdering: .monotonic, weak: true, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .monotonic, failureOrdering: .monotonic, weak: true, for: i)
 
       case .atomic_cmpxchgweak_relaxed_acquire:
-        insertAtomicCompareExchange(successOrdering: .monotonic, failureOrdering: .acquire, weak: true, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .monotonic, failureOrdering: .acquire, weak: true, for: i)
 
       case .atomic_cmpxchgweak_relaxed_seqcst:
-        insertAtomicCompareExchange(successOrdering: .monotonic, failureOrdering: .sequentiallyConsistent, weak: true, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .monotonic, failureOrdering: .sequentiallyConsistent, weak: true, for: i)
 
       case .atomic_cmpxchgweak_acquire_relaxed:
-        insertAtomicCompareExchange(successOrdering: .acquire, failureOrdering: .monotonic, weak: true, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .acquire, failureOrdering: .monotonic, weak: true, for: i)
 
       case .atomic_cmpxchgweak_acquire_acquire:
-        insertAtomicCompareExchange(successOrdering: .acquire, failureOrdering: .acquire, weak: true, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .acquire, failureOrdering: .acquire, weak: true, for: i)
 
       case .atomic_cmpxchgweak_acquire_seqcst:
-        insertAtomicCompareExchange(successOrdering: .acquire, failureOrdering: .sequentiallyConsistent, weak: true, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .acquire, failureOrdering: .sequentiallyConsistent, weak: true, for: i)
 
       case .atomic_cmpxchgweak_release_relaxed:
-        insertAtomicCompareExchange(successOrdering: .release, failureOrdering: .monotonic, weak: true, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .release, failureOrdering: .monotonic, weak: true, for: i)
 
       case .atomic_cmpxchgweak_release_acquire:
-        insertAtomicCompareExchange(successOrdering: .release, failureOrdering: .acquire, weak: true, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .release, failureOrdering: .acquire, weak: true, for: i)
 
       case .atomic_cmpxchgweak_release_seqcst:
-        insertAtomicCompareExchange(successOrdering: .release, failureOrdering: .sequentiallyConsistent, weak: true, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .release, failureOrdering: .sequentiallyConsistent, weak: true, for: i)
 
       case .atomic_cmpxchgweak_acqrel_relaxed:
-        insertAtomicCompareExchange(successOrdering: .acquireRelease, failureOrdering: .monotonic, weak: true, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .acquireRelease, failureOrdering: .monotonic, weak: true, for: i)
 
       case .atomic_cmpxchgweak_acqrel_acquire:
-        insertAtomicCompareExchange(successOrdering: .acquireRelease, failureOrdering: .acquire, weak: true, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .acquireRelease, failureOrdering: .acquire, weak: true, for: i)
 
       case .atomic_cmpxchgweak_acqrel_seqcst:
-        insertAtomicCompareExchange(successOrdering: .acquireRelease, failureOrdering: .sequentiallyConsistent, weak: true, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .acquireRelease, failureOrdering: .sequentiallyConsistent, weak: true,
+          for: i)
 
       case .atomic_cmpxchgweak_seqcst_relaxed:
-        insertAtomicCompareExchange(successOrdering: .sequentiallyConsistent, failureOrdering: .monotonic, weak: true, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .sequentiallyConsistent, failureOrdering: .monotonic, weak: true, for: i)
 
       case .atomic_cmpxchgweak_seqcst_acquire:
-        insertAtomicCompareExchange(successOrdering: .sequentiallyConsistent, failureOrdering: .acquire, weak: true, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .sequentiallyConsistent, failureOrdering: .acquire, weak: true, for: i)
 
       case .atomic_cmpxchgweak_seqcst_seqcst:
-        insertAtomicCompareExchange(successOrdering: .sequentiallyConsistent, failureOrdering: .sequentiallyConsistent, weak: true, for: i)
+        insertAtomicCompareExchange(
+          successOrdering: .sequentiallyConsistent, failureOrdering: .sequentiallyConsistent,
+          weak: true, for: i)
 
       case .atomic_fence_acquire:
         insertAtomicFence(.acquire, singleThread: false, for: i)
@@ -1587,12 +1624,17 @@ extension SwiftyLLVM.Module {
       let s = context.source[i] as! IR.CallBuiltinFunction
       let target = llvm(s.operands[0])
       let value = llvm(s.operands[1])
-      let o = insertAtomicRMW(target, operation: oper, value: value, ordering: ordering, singleThread: false, at: insertionPoint)
+      let o = insertAtomicRMW(
+        target, operation: oper, value: value, ordering: ordering, singleThread: false,
+        at: insertionPoint)
       register[.register(i)] = o
     }
 
     /// Inserts the transpilation of `i` at `insertionPoint`.
-    func insertAtomicCompareExchange(successOrdering: AtomicOrdering, failureOrdering: AtomicOrdering, weak: Bool, for i: IR.InstructionID) {
+    func insertAtomicCompareExchange(
+      successOrdering: AtomicOrdering, failureOrdering: AtomicOrdering, weak: Bool,
+      for i: IR.InstructionID
+    ) {
       let s = context.source[i] as! IR.CallBuiltinFunction
       let target = llvm(s.operands[0])
       let old = llvm(s.operands[1])
@@ -1610,7 +1652,8 @@ extension SwiftyLLVM.Module {
     }
 
     /// Inserts the transpilation of `i` at `insertionPoint`.
-    func insertAtomicFence(_ ordering: AtomicOrdering, singleThread: Bool, for i: IR.InstructionID) {
+    func insertAtomicFence(_ ordering: AtomicOrdering, singleThread: Bool, for i: IR.InstructionID)
+    {
       insertFence(ordering, singleThread: singleThread, at: insertionPoint)
       register[.register(i)] = ptr.null
     }

Sources/CodeGen/LLVM/TypeLowering.swift

@@ -75,7 +75,7 @@ extension IR.Program {
     case .ptr:
       return module.ptr
     case .cNumeric(let cType):
-      return SwiftyLLVM.IntegerType(cType.size*8, in: &module)
+      return SwiftyLLVM.IntegerType(cType.size * 8, in: &module)
     case .module:
       notLLVMRepresentable(t)
     }

Sources/FrontEnd/Parse/Parser.swift

@@ -3050,7 +3050,7 @@ public enum Parser {
         guard let c = parseConnective(in: &state) else { return lhs }
 
         // Backtrack if the connective we got hasn't strong enough precedence.
-        if (c.rawValue < p.rawValue) {
+        if c.rawValue < p.rawValue {
           state.restore(from: backup)
           return lhs
         }
@@ -3104,7 +3104,7 @@ public enum Parser {
       } else if h.kind == .poundElse {
         fallback = try parseConditionalCompilationBranch(in: &state)
         _ = try state.expect("'#endif'", using: { $0.take(.poundEndif) })
-      } else{
+      } else {
         fallback = [try parseCompilerConditionTail(head: h, in: &state)]
       }
 

Sources/FrontEnd/TypeChecking/Rewriting/RewritingSystem.swift

@@ -99,7 +99,7 @@ struct RewritingSystem<Term: RewritingTerm> {
   /// This method uses Knuth-Bendix completion algorithm to transform `self` into a terminating
   /// confluent system. The completion procedure is semi-decidable: it returns `true` if it
   /// succeeds or `false` if it suspects that it won't terminate.
-  mutating func complete(orderingTermsWith compareOrder: (Term, Term) -> StrictOrdering) -> Bool{
+  mutating func complete(orderingTermsWith compareOrder: (Term, Term) -> StrictOrdering) -> Bool {
     var visitedOverlaps = Set<OverlapIdentifier>()
     var pairs: [CriticalPair] = []
     var changed = true
@@ -129,7 +129,6 @@ struct RewritingSystem<Term: RewritingTerm> {
     return true
   }
 
-
   /// Calls `action` on each overlap between two rules of the system.
   private func forEachOverlap(do action: (RuleID, RuleID, Term.Index) -> Void) {
     for i in rules.indices where !rules[i].isSimplified {

Sources/FrontEnd/TypeChecking/TypeChecker+Diagnostics.swift

@@ -1,4 +1,3 @@
-
 extension Diagnostic {
 
   static func error(ambiguousDisjunctionAt site: SourceRange) -> Diagnostic {

Sources/FrontEnd/TypeChecking/TypeChecker.swift

@@ -1599,7 +1599,8 @@ struct TypeChecker {
       return (
         type: canonical(expectedType(of: m), in: scopeOfDefinition),
         name: program.name(of: m)!,
-        parameters: genericParameters(introducedBy: m))
+        parameters: genericParameters(introducedBy: m)
+      )
     }
 
     /// Returns the type of `m` viewed as a member of `model` through its conformance to `trait`.
@@ -1685,8 +1686,7 @@ struct TypeChecker {
       of requirement: AnyDeclID, withAPI expectedAPI: API
     ) -> SynthesizedFunctionDecl? {
       let scopeOfImplementation = AnyScopeID(origin.source)!
-      if
-        let k = program.ast.synthesizedKind(of: requirement),
+      if let k = program.ast.synthesizedKind(of: requirement),
         canSynthesizeConformance(model, to: trait, in: scopeOfImplementation)
       {
         let t = ArrowType(expectedAPI.type)!
@@ -4396,8 +4396,7 @@ struct TypeChecker {
     }
 
     // If the match is a trait member, specialize its receiver.
-    if
-      d.kind != AssociatedTypeDecl.self,
+    if d.kind != AssociatedTypeDecl.self,
       let t = traitDeclaring(d),
       let r = context?.type ?? resolveReceiverMetatype(in: scopeOfUse)?.instance
     {
@@ -4533,8 +4532,7 @@ struct TypeChecker {
     reportingDiagnosticsAt diagnosticSite: SourceRange
   ) -> AnyType {
     let lens = traitDeclaring(d)!
-    if
-      let c = demandConformance(of: domain, to: lens, exposedTo: scopeOfUse),
+    if let c = demandConformance(of: domain, to: lens, exposedTo: scopeOfUse),
       let i = c.implementations[d]?.decl
     {
       return uncheckedType(of: i)
@@ -6589,7 +6587,7 @@ struct TypeChecker {
     let bb = bases(of: b)
 
     if ab.unordered.count > bb.unordered.count {
-      return .descending // !!! .ascending in Slava's work
+      return .descending  // !!! .ascending in Slava's work
     } else if ab.unordered.count == bb.unordered.count {
       return .init(between: a.decl.rawValue, and: b.decl.rawValue)
     } else {

Sources/GenerateHyloFileTests/GenerateHyloFileTests.swift

@@ -34,13 +34,13 @@ struct GenerateHyloFileTests: ParsableCommand {
       let trailing = test.arguments.reduce(into: "", { (s, a) in s.write(", \(a)") })
       swiftCode += """
 
-        func test_\(test.methodName)_\(testID)() throws {
-          try \(test.methodName)(
-            \(String(reflecting: source.fileSystemPath)),
-            extending: programToExtend!\(trailing))
-        }
+          func test_\(test.methodName)_\(testID)() throws {
+            try \(test.methodName)(
+              \(String(reflecting: source.fileSystemPath)),
+              extending: programToExtend!\(trailing))
+          }
 
-      """
+        """
     }
   }
 
@@ -131,7 +131,7 @@ extension StringProtocol where Self.SubSequence == Substring {
 }
 
 /// The name of a method implementing the logic of a test runner.
-fileprivate enum TestMethod: String {
+private enum TestMethod: String {
 
   /// Compiles and runs the program.
   case compileAndRun
@@ -154,7 +154,7 @@ fileprivate enum TestMethod: String {
 }
 
 /// An argument of a test runner.
-fileprivate struct TestArgument: CustomStringConvertible {
+private struct TestArgument: CustomStringConvertible {
 
   /// The label of an argument.
   enum Label: String {