Merge pull request #265 from allevato/swift-5.5-cherrypicks

Cherry-pick recent changes for Swift 5.5.

Author: allevato

Package.swift

@@ -47,7 +47,11 @@ let package = Package(
     ),
     .target(
       name: "SwiftFormatTestSupport",
-      dependencies: ["SwiftFormatCore", "SwiftFormatConfiguration"]
+      dependencies: [
+        "SwiftFormatCore",
+        "SwiftFormatRules",
+        "SwiftFormatConfiguration",
+      ]
     ),
     .target(
       name: "SwiftFormatWhitespaceLinter",

Sources/SwiftFormat/LintPipeline.swift

@@ -29,7 +29,7 @@ extension LintPipeline {
   func visitIfEnabled<Rule: SyntaxLintRule, Node: SyntaxProtocol>(
     _ visitor: (Rule) -> (Node) -> SyntaxVisitorContinueKind, for node: Node
   ) {
-    guard context.isRuleEnabled(Rule.self.ruleName, node: Syntax(node)) else { return }
+    guard context.isRuleEnabled(Rule.self, node: Syntax(node)) else { return }
     let rule = self.rule(Rule.self)
     _ = visitor(rule)(node)
   }
@@ -50,7 +50,7 @@ extension LintPipeline {
     // more importantly because the `visit` methods return protocol refinements of `Syntax` that
     // cannot currently be expressed as constraints without duplicating this function for each of
     // them individually.
-    guard context.isRuleEnabled(Rule.self.ruleName, node: Syntax(node)) else { return }
+    guard context.isRuleEnabled(Rule.self, node: Syntax(node)) else { return }
     let rule = self.rule(Rule.self)
     _ = visitor(rule)(node)
   }

Sources/SwiftFormat/Pipelines+Generated.swift

@@ -63,6 +63,7 @@ class LintPipeline: SyntaxVisitor {
   override func visit(_ node: CodeBlockItemListSyntax) -> SyntaxVisitorContinueKind {
     visitIfEnabled(DoNotUseSemicolons.visit, for: node)
     visitIfEnabled(OneVariableDeclarationPerLine.visit, for: node)
+    visitIfEnabled(UseEarlyExits.visit, for: node)
     return .visitChildren
   }
 
@@ -106,6 +107,11 @@ class LintPipeline: SyntaxVisitor {
     return .visitChildren
   }
 
+  override func visit(_ node: ForInStmtSyntax) -> SyntaxVisitorContinueKind {
+    visitIfEnabled(UseWhereClausesInForLoops.visit, for: node)
+    return .visitChildren
+  }
+
   override func visit(_ node: ForcedValueExprSyntax) -> SyntaxVisitorContinueKind {
     visitIfEnabled(NeverForceUnwrap.visit, for: node)
     return .visitChildren
@@ -314,9 +320,11 @@ extension FormatPipeline {
     node = OneVariableDeclarationPerLine(context: context).visit(node)
     node = OrderedImports(context: context).visit(node)
     node = ReturnVoidInsteadOfEmptyTuple(context: context).visit(node)
+    node = UseEarlyExits(context: context).visit(node)
     node = UseShorthandTypeNames(context: context).visit(node)
     node = UseSingleLinePropertyGetter(context: context).visit(node)
     node = UseTripleSlashForDocumentationComments(context: context).visit(node)
+    node = UseWhereClausesInForLoops(context: context).visit(node)
     return node
   }
 }

Sources/SwiftFormat/SwiftFormatter.swift

@@ -14,6 +14,7 @@ import Foundation
 import SwiftFormatConfiguration
 import SwiftFormatCore
 import SwiftFormatPrettyPrint
+import SwiftFormatRules
 import SwiftSyntax
 
 /// Formats Swift source code or syntax trees according to the Swift style guidelines.
@@ -108,7 +109,7 @@ public final class SwiftFormatter {
     let assumedURL = url ?? URL(fileURLWithPath: "source")
     let context = Context(
       configuration: configuration, diagnosticEngine: diagnosticEngine, fileURL: assumedURL,
-      sourceFileSyntax: syntax, source: source)
+      sourceFileSyntax: syntax, source: source, ruleNameCache: ruleNameCache)
     let pipeline = FormatPipeline(context: context)
     let transformedSyntax = pipeline.visit(Syntax(syntax))
 

Sources/SwiftFormat/SwiftLinter.swift

@@ -14,6 +14,7 @@ import Foundation
 import SwiftFormatConfiguration
 import SwiftFormatCore
 import SwiftFormatPrettyPrint
+import SwiftFormatRules
 import SwiftFormatWhitespaceLinter
 import SwiftSyntax
 
@@ -88,7 +89,7 @@ public final class SwiftLinter {
 
     let context = Context(
       configuration: configuration, diagnosticEngine: diagnosticEngine, fileURL: url,
-      sourceFileSyntax: syntax, source: source)
+      sourceFileSyntax: syntax, source: source, ruleNameCache: ruleNameCache)
     let pipeline = LintPipeline(context: context)
     pipeline.walk(Syntax(syntax))
 

Sources/SwiftFormatConfiguration/RuleRegistry+Generated.swift

@@ -40,11 +40,13 @@ enum RuleRegistry {
     "OnlyOneTrailingClosureArgument": true,
     "OrderedImports": true,
     "ReturnVoidInsteadOfEmptyTuple": true,
+    "UseEarlyExits": false,
     "UseLetInEveryBoundCaseVariable": true,
     "UseShorthandTypeNames": true,
     "UseSingleLinePropertyGetter": true,
     "UseSynthesizedInitializer": true,
     "UseTripleSlashForDocumentationComments": true,
+    "UseWhereClausesInForLoops": false,
     "ValidateDocumentationComments": false,
   ]
 }

Sources/SwiftFormatCore/Context.swift

@@ -52,13 +52,17 @@ public class Context {
   /// Contains the rules have been disabled by comments for certain line numbers.
   public let ruleMask: RuleMask
 
+  /// Contains all the available rules' names associated to their types' object identifiers.
+  public let ruleNameCache: [ObjectIdentifier: String]
+
   /// Creates a new Context with the provided configuration, diagnostic engine, and file URL.
   public init(
     configuration: Configuration,
     diagnosticEngine: DiagnosticEngine?,
     fileURL: URL,
     sourceFileSyntax: SourceFileSyntax,
-    source: String? = nil
+    source: String? = nil,
+    ruleNameCache: [ObjectIdentifier: String]
   ) {
     self.configuration = configuration
     self.diagnosticEngine = diagnosticEngine
@@ -71,12 +75,22 @@ public class Context {
       syntaxNode: Syntax(sourceFileSyntax),
       sourceLocationConverter: sourceLocationConverter
     )
+    self.ruleNameCache = ruleNameCache
   }
 
   /// Given a rule's name and the node it is examining, determine if the rule is disabled at this
   /// location or not.
-  public func isRuleEnabled(_ ruleName: String, node: Syntax) -> Bool {
+  public func isRuleEnabled<R: Rule>(_ rule: R.Type, node: Syntax) -> Bool {
     let loc = node.startLocation(converter: self.sourceLocationConverter)
+
+    assert(
+      ruleNameCache[ObjectIdentifier(rule)] != nil,
+      """
+      Missing cached rule name for '\(rule)'! \
+      Ensure `generate-pipelines` has been run and `ruleNameCache` was injected.
+      """)
+
+    let ruleName = ruleNameCache[ObjectIdentifier(rule)] ?? R.ruleName
     switch ruleMask.ruleState(ruleName, at: loc) {
     case .default:
       return configuration.rules[ruleName] ?? false

Sources/SwiftFormatCore/Rule.swift

@@ -17,7 +17,7 @@ public protocol Rule {
   /// The context in which the rule is executed.
   var context: Context { get }
 
-  /// The human-readable name of the rule. This defaults to the class name.
+  /// The human-readable name of the rule. This defaults to the type name.
   static var ruleName: String { get }
 
   /// Whether this rule is opt-in, meaning it is disabled by default.
@@ -27,27 +27,7 @@ public protocol Rule {
   init(context: Context)
 }
 
-fileprivate var nameCache = [ObjectIdentifier: String]()
-fileprivate var nameCacheQueue = DispatchQueue(
-      label: "com.apple.SwiftFormat.NameCache", attributes: .concurrent)
-
 extension Rule {
   /// By default, the `ruleName` is just the name of the implementing rule class.
-  public static var ruleName: String {
-    let identifier = ObjectIdentifier(self)
-    let cachedName = nameCacheQueue.sync {
-        nameCache[identifier]
-    }
-
-    if let cachedName = cachedName {
-      return cachedName
-    }
-
-    let name = String("\(self)".split(separator: ".").last!)
-    nameCacheQueue.async(flags: .barrier) {
-        nameCache[identifier] = name
-    }
-
-    return name
-  }
+  public static var ruleName: String { String("\(self)".split(separator: ".").last!) }
 }

Sources/SwiftFormatCore/SyntaxFormatRule.swift

@@ -31,7 +31,7 @@ open class SyntaxFormatRule: SyntaxRewriter, Rule {
   open override func visitAny(_ node: Syntax) -> Syntax? {
     // If the rule is not enabled, then return the node unmodified; otherwise, returning nil tells
     // SwiftSyntax to continue with the standard dispatch.
-    guard context.isRuleEnabled(Self.ruleName, node: node) else { return node }
+    guard context.isRuleEnabled(type(of: self), node: node) else { return node }
     return nil
   }
 }

Sources/SwiftFormatRules/OrderedImports.swift

@@ -324,7 +324,7 @@ fileprivate func generateLines(codeBlockItemList: CodeBlockItemListSyntax, conte
         lines.append(currentLine)
         currentLine = Line()
       }
-      let sortable = context.isRuleEnabled(OrderedImports.ruleName, node: Syntax(block))
+      let sortable = context.isRuleEnabled(OrderedImports.self, node: Syntax(block))
       currentLine.syntaxNode = .importCodeBlock(block, sortable: sortable)
     } else {
       guard let syntaxNode = currentLine.syntaxNode else {