Configure expression folding by argument of @SwiftSyntaxRule macro (#…

…5255)
realm · Oct 3, 2023 · f6e5f77 · f6e5f77
1 parent 4716f59
commit f6e5f77
Show file tree

Hide file tree

Showing 12 changed files with 144 additions and 91 deletions.
diff --git a/Source/SwiftLintBuiltInRules/Rules/Idiomatic/LegacyMultipleRule.swift b/Source/SwiftLintBuiltInRules/Rules/Idiomatic/LegacyMultipleRule.swift
@@ -1,7 +1,6 @@
 import SwiftSyntax
 
-@Fold
-@SwiftSyntaxRule
+@SwiftSyntaxRule(foldExpressions: true)
 struct LegacyMultipleRule: OptInRule, ConfigurationProviderRule {
     var configuration = SeverityConfiguration<Self>(.warning)
 

diff --git a/Source/SwiftLintBuiltInRules/Rules/Lint/IdenticalOperandsRule.swift b/Source/SwiftLintBuiltInRules/Rules/Lint/IdenticalOperandsRule.swift
@@ -1,7 +1,6 @@
 import SwiftSyntax
 
-@Fold
-@SwiftSyntaxRule
+@SwiftSyntaxRule(foldExpressions: true)
 struct IdenticalOperandsRule: ConfigurationProviderRule, OptInRule {
     var configuration = SeverityConfiguration<Self>(.warning)
 

diff --git a/Source/SwiftLintBuiltInRules/Rules/Performance/ContainsOverFirstNotNilRule.swift b/Source/SwiftLintBuiltInRules/Rules/Performance/ContainsOverFirstNotNilRule.swift
@@ -1,7 +1,6 @@
 import SwiftSyntax
 
-@Fold
-@SwiftSyntaxRule
+@SwiftSyntaxRule(foldExpressions: true)
 struct ContainsOverFirstNotNilRule: OptInRule, ConfigurationProviderRule {
     var configuration = SeverityConfiguration<Self>(.warning)
 

diff --git a/Source/SwiftLintBuiltInRules/Rules/Performance/ContainsOverRangeNilComparisonRule.swift b/Source/SwiftLintBuiltInRules/Rules/Performance/ContainsOverRangeNilComparisonRule.swift
@@ -1,7 +1,6 @@
 import SwiftSyntax
 
-@Fold
-@SwiftSyntaxRule
+@SwiftSyntaxRule(foldExpressions: true)
 struct ContainsOverRangeNilComparisonRule: OptInRule, ConfigurationProviderRule {
     var configuration = SeverityConfiguration<Self>(.warning)
 

diff --git a/Source/SwiftLintBuiltInRules/Rules/Performance/EmptyCountRule.swift b/Source/SwiftLintBuiltInRules/Rules/Performance/EmptyCountRule.swift
@@ -1,6 +1,5 @@
 import SwiftSyntax
 
-@Fold
 struct EmptyCountRule: ConfigurationProviderRule, OptInRule, SwiftSyntaxRule {
     var configuration = EmptyCountConfiguration()
 
@@ -37,6 +36,10 @@ struct EmptyCountRule: ConfigurationProviderRule, OptInRule, SwiftSyntaxRule {
     func makeVisitor(file: SwiftLintFile) -> ViolationsSyntaxVisitor {
         Visitor(onlyAfterDot: configuration.onlyAfterDot)
     }
+
+    func preprocess(file: SwiftLintFile) -> SourceFileSyntax? {
+        file.foldedSyntaxTree
+    }
 }
 
 private extension EmptyCountRule {

diff --git a/Source/SwiftLintBuiltInRules/Rules/Style/ShorthandOperatorRule.swift b/Source/SwiftLintBuiltInRules/Rules/Style/ShorthandOperatorRule.swift
@@ -1,7 +1,6 @@
 import SwiftSyntax
 
-@Fold
-@SwiftSyntaxRule
+@SwiftSyntaxRule(foldExpressions: true)
 struct ShorthandOperatorRule: ConfigurationProviderRule {
     var configuration = SeverityConfiguration<Self>(.error)
 

diff --git a/Source/SwiftLintCore/Helpers/Macros.swift b/Source/SwiftLintCore/Helpers/Macros.swift
@@ -14,16 +14,10 @@ public macro MakeAcceptableByConfigurationElement() = #externalMacro(
 )
 
 /// Macro that adds a conformance to the `SwiftSyntaxRule` protocol and a default `makeVisitor(file:)` implementation
-/// that creates a visitor defined in the same file.
-@attached(extension, conformances: SwiftSyntaxRule, names: named(makeVisitor(file:)))
-public macro SwiftSyntaxRule() = #externalMacro(
+/// that creates a visitor defined in the same file. It also adds an implementation of `preprocess(file:)` which folds
+/// expressions if the `foldExpressions` argument is set.
+@attached(extension, conformances: SwiftSyntaxRule, names: named(makeVisitor(file:)), named(preprocess(file:)))
+public macro SwiftSyntaxRule(foldExpressions: Bool = false) = #externalMacro(
     module: "SwiftLintCoreMacros",
     type: "SwiftSyntaxRule"
 )
-
-/// Macro that preprocesses the file by folding its operators before processing it for rule violations.
-@attached(extension, names: named(preprocess(file:)))
-public macro Fold() = #externalMacro(
-    module: "SwiftLintCoreMacros",
-    type: "Fold"
-)
diff --git a/Source/SwiftLintCoreMacros/Fold.swift b/Source/SwiftLintCoreMacros/Fold.swift
diff --git a/Source/SwiftLintCoreMacros/SwiftLintCoreMacros.swift b/Source/SwiftLintCoreMacros/SwiftLintCoreMacros.swift
@@ -5,7 +5,6 @@ import SwiftSyntaxMacros
 struct SwiftLintCoreMacros: CompilerPlugin {
     let providingMacros: [Macro.Type] = [
         AutoApply.self,
-        Fold.self,
         MakeAcceptableByConfigurationElement.self,
         SwiftSyntaxRule.self
     ]

diff --git a/Source/SwiftLintCoreMacros/SwiftSyntaxRule.swift b/Source/SwiftLintCoreMacros/SwiftSyntaxRule.swift
@@ -15,8 +15,42 @@ struct SwiftSyntaxRule: ExtensionMacro {
                     func makeVisitor(file: SwiftLintFile) -> ViolationsSyntaxVisitor {
                         Visitor(viewMode: .sourceAccurate)
                     }
+                    \(createFoldingPreprocessor(from: node.foldArgument))
                 }
                 """)
         ]
     }
+
+    private static func createFoldingPreprocessor(from foldArgument: ExprSyntax?) -> DeclSyntax {
+        guard let foldArgument else {
+            return ""
+        }
+        if let booleanLiteral = foldArgument.as(BooleanLiteralExprSyntax.self)?.literal {
+            if booleanLiteral.text == "true" {
+                return """
+                    func preprocess(file: SwiftLintFile) -> SourceFileSyntax? {
+                        file.foldedSyntaxTree
+                    }
+                    """
+            }
+            if booleanLiteral.text == "false" {
+                return ""
+            }
+        }
+        return """
+            func preprocess(file: SwiftLintFile) -> SourceFileSyntax? {
+                if \(foldArgument) { file.foldedSyntaxTree } else { nil }
+            }
+            """
+    }
+}
+
+private extension AttributeSyntax {
+    var foldArgument: ExprSyntax? {
+        if case let .argumentList(args) = arguments, let first = args.first, first.label?.text == "foldExpressions" {
+            first.expression
+        } else {
+            nil
+        }
+    }
 }
diff --git a/Tests/MacroTests/MacroTests.swift b/Tests/MacroTests/MacroTests.swift
diff --git a/Tests/MacroTests/SwiftSyntaxRuleTests.swift b/Tests/MacroTests/SwiftSyntaxRuleTests.swift
@@ -0,0 +1,97 @@
+@testable import SwiftLintCoreMacros
+import SwiftSyntaxMacrosTestSupport
+import XCTest
+
+private let macros = [
+    "SwiftSyntaxRule": SwiftSyntaxRule.self
+]
+
+final class SwiftSyntaxRuleTests: XCTestCase {
+    func testNoFoldArgument() {
+        assertMacroExpansion(
+            """
+            @SwiftSyntaxRule
+            struct Hello {}
+            """,
+            expandedSource: """
+            struct Hello {}
+
+            extension Hello: SwiftSyntaxRule {
+                func makeVisitor(file: SwiftLintFile) -> ViolationsSyntaxVisitor {
+                    Visitor(viewMode: .sourceAccurate)
+                }
+
+            }
+            """,
+            macros: macros
+        )
+    }
+
+    func testFalseFoldArgument() {
+        assertMacroExpansion(
+            """
+            @SwiftSyntaxRule(foldExpressions: false)
+            struct Hello {}
+            """,
+            expandedSource: """
+            struct Hello {}
+
+            extension Hello: SwiftSyntaxRule {
+                func makeVisitor(file: SwiftLintFile) -> ViolationsSyntaxVisitor {
+                    Visitor(viewMode: .sourceAccurate)
+                }
+
+            }
+            """,
+            macros: macros
+        )
+    }
+
+    func testTrueFoldArgument() {
+        assertMacroExpansion(
+            """
+            @SwiftSyntaxRule(foldExpressions: true)
+            struct Hello {}
+            """,
+            expandedSource: """
+            struct Hello {}
+
+            extension Hello: SwiftSyntaxRule {
+                func makeVisitor(file: SwiftLintFile) -> ViolationsSyntaxVisitor {
+                    Visitor(viewMode: .sourceAccurate)
+                }
+                func preprocess(file: SwiftLintFile) -> SourceFileSyntax? {
+                    file.foldedSyntaxTree
+                }
+            }
+            """,
+            macros: macros
+        )
+    }
+
+    func testArbitraryFoldArgument() {
+        assertMacroExpansion(
+            """
+            @SwiftSyntaxRule(foldExpressions: variable)
+            struct Hello {}
+            """,
+            expandedSource: """
+            struct Hello {}
+
+            extension Hello: SwiftSyntaxRule {
+                func makeVisitor(file: SwiftLintFile) -> ViolationsSyntaxVisitor {
+                    Visitor(viewMode: .sourceAccurate)
+                }
+                func preprocess(file: SwiftLintFile) -> SourceFileSyntax? {
+                    if variable {
+                        file.foldedSyntaxTree
+                    } else {
+                        nil
+                    }
+                }
+            }
+            """,
+            macros: macros
+        )
+    }
+}