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

allevato · web-flow · commit da2f1ec9f300 · 2021-09-21T16:19:58.000-07:00
Cherry-pick recent changes for Swift 5.5.
diff --git a/Package.swift b/Package.swift
@@ -47,7 +47,11 @@ let package = Package(
     ),
     .target(
       name: "SwiftFormatTestSupport",
-      dependencies: ["SwiftFormatCore", "SwiftFormatConfiguration"]
+      dependencies: [
+        "SwiftFormatCore",
+        "SwiftFormatRules",
+        "SwiftFormatConfiguration",
+      ]
     ),
     .target(
       name: "SwiftFormatWhitespaceLinter",
diff --git a/Sources/SwiftFormat/LintPipeline.swift b/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)
   }
diff --git a/Sources/SwiftFormat/Pipelines+Generated.swift b/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
   }
 }
diff --git a/Sources/SwiftFormat/SwiftFormatter.swift b/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))
 
diff --git a/Sources/SwiftFormat/SwiftLinter.swift b/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))
 
diff --git a/Sources/SwiftFormatConfiguration/RuleRegistry+Generated.swift b/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,
   ]
 }
diff --git a/Sources/SwiftFormatCore/Context.swift b/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
diff --git a/Sources/SwiftFormatCore/Rule.swift b/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!) }
 }
diff --git a/Sources/SwiftFormatCore/SyntaxFormatRule.swift b/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
   }
 }
diff --git a/Sources/SwiftFormatRules/OrderedImports.swift b/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 {
diff --git a/Sources/SwiftFormatRules/RuleNameCache+Generated.swift b/Sources/SwiftFormatRules/RuleNameCache+Generated.swift
@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+// This file is automatically generated with generate-pipeline. Do Not Edit!
+
+/// By default, the `Rule.ruleName` should be the name of the implementing rule type.
+public let ruleNameCache: [ObjectIdentifier: String] = [
+  ObjectIdentifier(AllPublicDeclarationsHaveDocumentation.self): "AllPublicDeclarationsHaveDocumentation",
+  ObjectIdentifier(AlwaysUseLowerCamelCase.self): "AlwaysUseLowerCamelCase",
+  ObjectIdentifier(AmbiguousTrailingClosureOverload.self): "AmbiguousTrailingClosureOverload",
+  ObjectIdentifier(BeginDocumentationCommentWithOneLineSummary.self): "BeginDocumentationCommentWithOneLineSummary",
+  ObjectIdentifier(DoNotUseSemicolons.self): "DoNotUseSemicolons",
+  ObjectIdentifier(DontRepeatTypeInStaticProperties.self): "DontRepeatTypeInStaticProperties",
+  ObjectIdentifier(FileScopedDeclarationPrivacy.self): "FileScopedDeclarationPrivacy",
+  ObjectIdentifier(FullyIndirectEnum.self): "FullyIndirectEnum",
+  ObjectIdentifier(GroupNumericLiterals.self): "GroupNumericLiterals",
+  ObjectIdentifier(IdentifiersMustBeASCII.self): "IdentifiersMustBeASCII",
+  ObjectIdentifier(NeverForceUnwrap.self): "NeverForceUnwrap",
+  ObjectIdentifier(NeverUseForceTry.self): "NeverUseForceTry",
+  ObjectIdentifier(NeverUseImplicitlyUnwrappedOptionals.self): "NeverUseImplicitlyUnwrappedOptionals",
+  ObjectIdentifier(NoAccessLevelOnExtensionDeclaration.self): "NoAccessLevelOnExtensionDeclaration",
+  ObjectIdentifier(NoBlockComments.self): "NoBlockComments",
+  ObjectIdentifier(NoCasesWithOnlyFallthrough.self): "NoCasesWithOnlyFallthrough",
+  ObjectIdentifier(NoEmptyTrailingClosureParentheses.self): "NoEmptyTrailingClosureParentheses",
+  ObjectIdentifier(NoLabelsInCasePatterns.self): "NoLabelsInCasePatterns",
+  ObjectIdentifier(NoLeadingUnderscores.self): "NoLeadingUnderscores",
+  ObjectIdentifier(NoParensAroundConditions.self): "NoParensAroundConditions",
+  ObjectIdentifier(NoVoidReturnOnFunctionSignature.self): "NoVoidReturnOnFunctionSignature",
+  ObjectIdentifier(OneCasePerLine.self): "OneCasePerLine",
+  ObjectIdentifier(OneVariableDeclarationPerLine.self): "OneVariableDeclarationPerLine",
+  ObjectIdentifier(OnlyOneTrailingClosureArgument.self): "OnlyOneTrailingClosureArgument",
+  ObjectIdentifier(OrderedImports.self): "OrderedImports",
+  ObjectIdentifier(ReturnVoidInsteadOfEmptyTuple.self): "ReturnVoidInsteadOfEmptyTuple",
+  ObjectIdentifier(UseEarlyExits.self): "UseEarlyExits",
+  ObjectIdentifier(UseLetInEveryBoundCaseVariable.self): "UseLetInEveryBoundCaseVariable",
+  ObjectIdentifier(UseShorthandTypeNames.self): "UseShorthandTypeNames",
+  ObjectIdentifier(UseSingleLinePropertyGetter.self): "UseSingleLinePropertyGetter",
+  ObjectIdentifier(UseSynthesizedInitializer.self): "UseSynthesizedInitializer",
+  ObjectIdentifier(UseTripleSlashForDocumentationComments.self): "UseTripleSlashForDocumentationComments",
+  ObjectIdentifier(UseWhereClausesInForLoops.self): "UseWhereClausesInForLoops",
+  ObjectIdentifier(ValidateDocumentationComments.self): "ValidateDocumentationComments",
+]
diff --git a/Sources/SwiftFormatRules/UseEarlyExits.swift b/Sources/SwiftFormatRules/UseEarlyExits.swift
@@ -44,6 +44,10 @@ import SwiftSyntax
 ///         equivalent `guard ... else { return/throw/break/continue }` constructs.
 public final class UseEarlyExits: SyntaxFormatRule {
 
+  /// Identifies this rule as being opt-in. This rule is experimental and not yet stable enough to
+  /// be enabled by default.
+  public override class var isOptIn: Bool { return true }
+
   public override func visit(_ node: CodeBlockItemListSyntax) -> Syntax {
     // Continue recursing down the tree first, so that any nested/child nodes get transformed first.
     let nodeAfterTransformingChildren = super.visit(node)
diff --git a/Sources/SwiftFormatRules/UseWhereClausesInForLoops.swift b/Sources/SwiftFormatRules/UseWhereClausesInForLoops.swift
@@ -21,6 +21,10 @@ import SwiftSyntax
 ///         statement factored out to a `where` clause.
 public final class UseWhereClausesInForLoops: SyntaxFormatRule {
 
+  /// Identifies this rule as being opt-in. This rule is experimental and not yet stable enough to
+  /// be enabled by default.
+  public override class var isOptIn: Bool { return true }
+
   public override func visit(_ node: ForInStmtSyntax) -> StmtSyntax {
     // Extract IfStmt node if it's the only node in the function's body.
     guard !node.body.statements.isEmpty else { return StmtSyntax(node) }
diff --git a/Sources/SwiftFormatTestSupport/DiagnosingTestCase.swift b/Sources/SwiftFormatTestSupport/DiagnosingTestCase.swift
@@ -1,5 +1,6 @@
 import SwiftFormatConfiguration
 import SwiftFormatCore
+import SwiftFormatRules
 import SwiftSyntax
 import XCTest
 
@@ -39,7 +40,8 @@ open class DiagnosingTestCase: XCTestCase {
       configuration: configuration ?? Configuration(),
       diagnosticEngine: DiagnosticEngine(),
       fileURL: URL(fileURLWithPath: "/tmp/test.swift"),
-      sourceFileSyntax: sourceFileSyntax)
+      sourceFileSyntax: sourceFileSyntax,
+      ruleNameCache: ruleNameCache)
     consumer = DiagnosticTrackingConsumer()
     context.diagnosticEngine?.addConsumer(consumer)
     return context
diff --git a/Sources/generate-pipeline/RuleCollector.swift b/Sources/generate-pipeline/RuleCollector.swift
@@ -14,9 +14,6 @@ import Foundation
 import SwiftFormatCore
 import SwiftSyntax
 
-// These rules will not be added to the pipeline.
-let suppressRules = ["UseEarlyExits", "UseWhereClausesInForLoops"]
-
 /// Collects information about rules in the formatter code base.
 final class RuleCollector {
   /// Information about a detected rule.
@@ -99,8 +96,8 @@ final class RuleCollector {
       return nil
     }
 
-    // Make sure the rule isn't suppressed, and it must have an inheritance clause.
-    guard !suppressRules.contains(typeName), let inheritanceClause = maybeInheritanceClause else {
+    // Make sure it has an inheritance clause.
+    guard let inheritanceClause = maybeInheritanceClause else {
       return nil
     }
 
diff --git a/Sources/generate-pipeline/RuleNameCacheGenerator.swift b/Sources/generate-pipeline/RuleNameCacheGenerator.swift
@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import Foundation
+
+/// Generates the rule registry file used to populate the default configuration.
+final class RuleNameCacheGenerator: FileGenerator {
+
+  /// The rules collected by scanning the formatter source code.
+  let ruleCollector: RuleCollector
+
+  /// Creates a new rule registry generator.
+  init(ruleCollector: RuleCollector) {
+    self.ruleCollector = ruleCollector
+  }
+
+  func write(into handle: FileHandle) throws {
+    handle.write(
+      """
+      //===----------------------------------------------------------------------===//
+      //
+      // This source file is part of the Swift.org open source project
+      //
+      // Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+      // Licensed under Apache License v2.0 with Runtime Library Exception
+      //
+      // See https://swift.org/LICENSE.txt for license information
+      // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+      //
+      //===----------------------------------------------------------------------===//
+
+      // This file is automatically generated with generate-pipeline. Do Not Edit!
+
+      /// By default, the `Rule.ruleName` should be the name of the implementing rule type.
+      public let ruleNameCache: [ObjectIdentifier: String] = [
+
+      """
+    )
+
+    for detectedRule in ruleCollector.allLinters.sorted(by: { $0.typeName < $1.typeName }) {
+      handle.write("  ObjectIdentifier(\(detectedRule.typeName).self): \"\(detectedRule.typeName)\",\n")
+    }
+    handle.write("]\n")
+  }
+}
+
diff --git a/Sources/generate-pipeline/main.swift b/Sources/generate-pipeline/main.swift
@@ -24,6 +24,10 @@ let ruleRegistryFile = sourcesDirectory
   .appendingPathComponent("SwiftFormatConfiguration")
   .appendingPathComponent("RuleRegistry+Generated.swift")
 
+let ruleNameCacheFile = sourcesDirectory
+  .appendingPathComponent("SwiftFormatRules")
+  .appendingPathComponent("RuleNameCache+Generated.swift")
+
 var ruleCollector = RuleCollector()
 try ruleCollector.collect(from: rulesDirectory)
 
@@ -34,3 +38,7 @@ try pipelineGenerator.generateFile(at: pipelineFile)
 // Generate the rule registry dictionary for configuration.
 let registryGenerator = RuleRegistryGenerator(ruleCollector: ruleCollector)
 try registryGenerator.generateFile(at: ruleRegistryFile)
+
+// Generate the rule name cache.
+let ruleNameCacheGenerator = RuleNameCacheGenerator(ruleCollector: ruleCollector)
+try ruleNameCacheGenerator.generateFile(at: ruleNameCacheFile)
diff --git a/Sources/swift-format/Frontend/Frontend.swift b/Sources/swift-format/Frontend/Frontend.swift
diff --git a/Sources/swift-format/VersionOptions.swift b/Sources/swift-format/VersionOptions.swift

Original file line number	Diff line number	Diff line change
`@@ -40,11 +40,13 @@ enum RuleRegistry {`
`40`	`40`	`"OnlyOneTrailingClosureArgument": true,`
`41`	`41`	`"OrderedImports": true,`
`42`	`42`	`"ReturnVoidInsteadOfEmptyTuple": true,`
	`43`	`+ "UseEarlyExits": false,`
`43`	`44`	`"UseLetInEveryBoundCaseVariable": true,`
`44`	`45`	`"UseShorthandTypeNames": true,`
`45`	`46`	`"UseSingleLinePropertyGetter": true,`
`46`	`47`	`"UseSynthesizedInitializer": true,`
`47`	`48`	`"UseTripleSlashForDocumentationComments": true,`
	`49`	`+ "UseWhereClausesInForLoops": false,`
`48`	`50`	`"ValidateDocumentationComments": false,`
`49`	`51`	`]`
`50`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ open class SyntaxFormatRule: SyntaxRewriter, Rule {`
`31`	`31`	`open override func visitAny(_ node: Syntax) -> Syntax? {`
`32`	`32`	`// If the rule is not enabled, then return the node unmodified; otherwise, returning nil tells`
`33`	`33`	`// SwiftSyntax to continue with the standard dispatch.`
`34`		`- guard context.isRuleEnabled(Self.ruleName, node: node) else { return node }`
	`34`	`+ guard context.isRuleEnabled(type(of: self), node: node) else { return node }`
`35`	`35`	`return nil`
`36`	`36`	`}`
`37`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -324,7 +324,7 @@ fileprivate func generateLines(codeBlockItemList: CodeBlockItemListSyntax, conte`
`324`	`324`	`lines.append(currentLine)`
`325`	`325`	`currentLine = Line()`
`326`	`326`	`}`
`327`		`- let sortable = context.isRuleEnabled(OrderedImports.ruleName, node: Syntax(block))`
	`327`	`+ let sortable = context.isRuleEnabled(OrderedImports.self, node: Syntax(block))`
`328`	`328`	`currentLine.syntaxNode = .importCodeBlock(block, sortable: sortable)`
`329`	`329`	`} else {`
`330`	`330`	`guard let syntaxNode = currentLine.syntaxNode else {`