Add explicit_return opt-in rule: rebase, upgrade

Author: talanov

.swiftlint.yml

@@ -25,6 +25,7 @@ disabled_rules:
   - discouraged_optional_collection
   - explicit_acl
   - explicit_enum_raw_value
+  - explicit_return
   - explicit_top_level_acl
   - explicit_type_interface
   - file_types_order

CHANGELOG.md

@@ -33,6 +33,13 @@
   built-in rules in accordance with the SARIF specification.  
   [ahmadalfy](https://github.com/ahmadalfy)
   [#6499](https://github.com/realm/SwiftLint/issues/6499)
+  
+* Add `explicit_return` opt-in rule that warns against omitting the `return`
+  keyword inside closures, functions and getters.
+  [m-chojnacki](https://github.com/m-chojnacki)
+  [talanov](https://github.com/talanov)
+  [#3632](https://github.com/realm/SwiftLint/issues/3632)
+  [#3859](https://github.com/realm/SwiftLint/issues/3859)
 
 * Add `allow_underscore_prefixed_names` option to `unused_parameter` so
   underscore-prefixed parameter names can be treated as intentionally
@@ -3033,10 +3040,6 @@ accordingly._
   [JP Simard](https://github.com/jpsim)
 
 ### Bug Fixes
-* Add `explicit_return` opt-in rule that warns against omitting the `return`
-  keyword inside closures, functions and getters.
-
-#### Bug Fixes
 
 * Fix false positive in `self_in_property_initialization` rule when using
   closures inside `didSet` and other accessors.  

Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/ExplicitReturnConfiguration.swift

@@ -1,47 +1,32 @@
-public struct ExplicitReturnConfiguration: RuleConfiguration, Equatable {
-    public enum ReturnKind: String, CaseIterable {
+import SwiftLintCore
+
+@AutoConfigParser
+struct ExplicitReturnConfiguration: SeverityBasedRuleConfiguration {
+    @AcceptableByConfigurationElement
+    enum ReturnKind: String, CaseIterable, Comparable {
         case closure
         case function
         case getter
-    }
+        case `subscript`
+        case initializer
 
-    public static let defaultIncludedKinds = Set(ReturnKind.allCases)
+        static func < (lhs: Self, rhs: Self) -> Bool {
+            lhs.rawValue < rhs.rawValue
+        }
+    }
 
-    private(set) var severityConfiguration = SeverityConfiguration(.warning)
+    static let defaultIncludedKinds: Set<ReturnKind> = [.function, .getter, .subscript, .initializer]
 
+    @ConfigurationElement(key: "severity")
+    private(set) var severityConfiguration = SeverityConfiguration<Parent>(.warning)
+    @ConfigurationElement(key: "included")
     private(set) var includedKinds = Self.defaultIncludedKinds
 
-    public var consoleDescription: String {
-        let includedKinds = self.includedKinds.map { $0.rawValue }
-        return severityConfiguration.consoleDescription +
-            ", included: [\(includedKinds.sorted().joined(separator: ", "))]"
-    }
-
-    public init(includedKinds: Set<ReturnKind> = Self.defaultIncludedKinds) {
+    init(includedKinds: Set<ReturnKind> = Self.defaultIncludedKinds) {
         self.includedKinds = includedKinds
     }
 
-    public mutating func apply(configuration: Any) throws {
-        guard let configuration = configuration as? [String: Any] else {
-            throw ConfigurationError.unknownConfiguration
-        }
-
-        if let includedKinds = configuration["included"] as? [String] {
-            self.includedKinds = try Set(includedKinds.map {
-                guard let kind = ReturnKind(rawValue: $0) else {
-                    throw ConfigurationError.unknownConfiguration
-                }
-
-                return kind
-            })
-        }
-
-        if let severityString = configuration["severity"] as? String {
-            try severityConfiguration.apply(configuration: severityString)
-        }
-    }
-
-    public func isKindIncluded(_ kind: ReturnKind) -> Bool {
-        return self.includedKinds.contains(kind)
+    func isKindIncluded(_ kind: ReturnKind) -> Bool {
+        includedKinds.contains(kind)
     }
 }

Source/SwiftLintBuiltInRules/Rules/Style/ExplicitReturnRule.swift

@@ -1,122 +1,115 @@
 import Foundation
-import SourceKittenFramework
 import SwiftSyntax
 
-public struct ExplicitReturnRule: ConfigurationProviderRule, SubstitutionCorrectableRule, OptInRule {
-    public var configuration = ExplicitReturnConfiguration()
+@SwiftSyntaxRule(correctable: true, optIn: true)
+struct ExplicitReturnRule: Rule {
+    var configuration = ExplicitReturnConfiguration()
 
-    public init() {}
-
-    public static let description = RuleDescription(
+    static let description = RuleDescription(
         identifier: "explicit_return",
         name: "Explicit Return",
-        description: "Prefer explicit returns in closures, functions and getters.",
+        description: "Prefer explicit returns in closures, functions and getters",
         kind: .style,
         nonTriggeringExamples: ExplicitReturnRuleExamples.nonTriggeringExamples,
         triggeringExamples: ExplicitReturnRuleExamples.triggeringExamples,
         corrections: ExplicitReturnRuleExamples.corrections
     )
-
-    public func validate(file: SwiftLintFile) -> [StyleViolation] {
-        return violations(file: file).map {
-            StyleViolation(
-                ruleDescription: Self.description,
-                severity: configuration.severityConfiguration.severity,
-                location: Location(file: file, byteOffset: $0)
-            )
-        }
-    }
-
-    public func violationRanges(in file: SwiftLintFile) -> [NSRange] {
-        return violations(file: file).compactMap {
-            file.stringView.byteRangeToNSRange(ByteRange(location: $0, length: 0))
-        }
-    }
-
-    public func substitution(for violationRange: NSRange, in file: SwiftLintFile) -> (NSRange, String)? {
-        return (violationRange, "return ")
-    }
-
-    private func violations(file: SwiftLintFile) -> [ByteCount] {
-        guard let tree = file.syntaxTree else { return [] }
-
-        let visitor = ExplicitReturnVisitor(includedKinds: configuration.includedKinds)
-        visitor.walk(tree)
-
-        return visitor.positions.map { ByteCount($0.utf8Offset) }
-    }
 }
 
-private final class ExplicitReturnVisitor: SyntaxVisitor {
-    private let includedKinds: Set<ExplicitReturnConfiguration.ReturnKind>
-
-    private(set) var positions: [AbsolutePosition] = []
-
-    init(includedKinds: Set<ExplicitReturnConfiguration.ReturnKind>) {
-        self.includedKinds = includedKinds
-    }
-
-    override func visitPost(_ node: ClosureExprSyntax) {
-        guard includedKinds.contains(.closure),
-              let firstItem = node.statements.first?.item,
-              node.statements.count == 1 else { return }
+private extension ExplicitReturnRule {
+    final class Visitor: ViolationsSyntaxVisitor<ConfigurationType> {
+        override var skippableDeclarations: [any DeclSyntaxProtocol.Type] { [ProtocolDeclSyntax.self] }
 
-        if firstItem.isImplicitlyReturnable {
-            positions.append(firstItem.positionAfterSkippingLeadingTrivia)
+        override func visitPost(_ node: AccessorDeclSyntax) {
+            if configuration.isKindIncluded(.getter),
+               node.accessorSpecifier.tokenKind == .keyword(.get),
+               let body = node.body {
+                collectViolation(in: body.statements)
+            }
         }
-    }
 
-    override func visitPost(_ node: FunctionDeclSyntax) {
-        guard includedKinds.contains(.function),
-              node.signature.allowsImplicitReturns,
-              let firstItem = node.body?.statements.first?.item,
-              node.body?.statements.count == 1 else { return }
+        override func visitPost(_ node: ClosureExprSyntax) {
+            if configuration.isKindIncluded(.closure) {
+                collectViolation(in: node.statements, isInsideClosure: true)
+            }
+        }
 
-        if firstItem.isImplicitlyReturnable {
-            positions.append(firstItem.positionAfterSkippingLeadingTrivia)
+        override func visitPost(_ node: FunctionDeclSyntax) {
+            if configuration.isKindIncluded(.function),
+               node.signature.allowsImplicitReturns,
+               let body = node.body {
+                collectViolation(in: body.statements)
+            }
         }
-    }
 
-    override func visitPost(_ node: VariableDeclSyntax) {
-        guard includedKinds.contains(.getter) else { return }
+        override func visitPost(_ node: InitializerDeclSyntax) {
+            if configuration.isKindIncluded(.initializer),
+               node.optionalMark != nil,
+               let body = node.body {
+                collectViolation(in: body.statements)
+            }
+        }
 
-        for binding in node.bindings {
-            if let accessor = binding.accessor?.as(CodeBlockSyntax.self) {
-                // Shorthand syntax for getters: `var foo: Int { 0 }`
-                guard let firstItem = accessor.statements.first?.item,
-                      accessor.statements.count == 1 else { continue }
+        override func visitPost(_ node: PatternBindingSyntax) {
+            if configuration.isKindIncluded(.getter),
+               case let .getter(itemList) = node.accessorBlock?.accessors {
+                collectViolation(in: itemList)
+            }
+        }
 
-                if firstItem.isImplicitlyReturnable {
-                    positions.append(firstItem.positionAfterSkippingLeadingTrivia)
-                }
-            } else if let accessorBlock = binding.accessor?.as(AccessorBlockSyntax.self) {
-                // Full syntax for getters: `var foo: Int { get { 0 } }`
-                guard let accessor = accessorBlock.accessors.first(where: { $0.accessorKind.text == "get" }),
-                      let firstItem = accessor.body?.statements.first?.item,
-                      accessor.body?.statements.count == 1 else { continue }
+        override func visitPost(_ node: SubscriptDeclSyntax) {
+            if configuration.isKindIncluded(.subscript),
+               case let .getter(itemList) = node.accessorBlock?.accessors {
+                collectViolation(in: itemList)
+            }
+        }
 
-                if firstItem.isImplicitlyReturnable {
-                    positions.append(firstItem.positionAfterSkippingLeadingTrivia)
-                }
+        private func collectViolation(in itemList: CodeBlockItemListSyntax, isInsideClosure: Bool = false) {
+            guard let onlyItem = itemList.onlyElement?.item,
+                  !onlyItem.is(ReturnStmtSyntax.self),
+                  Syntax(onlyItem).isProtocol((any ExprSyntaxProtocol).self) else {
+                return
             }
+            if isInsideClosure, Syntax(onlyItem).isFunctionCallExpr {
+                return
+            }
+            let position = onlyItem.positionAfterSkippingLeadingTrivia
+            violations.append(
+                at: position,
+                correction: .init(
+                    start: position,
+                    end: position,
+                    replacement: "return "
+                )
+            )
         }
     }
 }
 
 private extension Syntax {
-    var isImplicitlyReturnable: Bool {
-        isProtocol(ExprSyntaxProtocol.self)
+    var isFunctionCallExpr: Bool {
+        if `is`(FunctionCallExprSyntax.self) {
+            return true
+        }
+        if let tryExpr = `as`(TryExprSyntax.self) {
+            return Syntax(tryExpr.expression).isFunctionCallExpr
+        }
+        if let awaitExpr = `as`(AwaitExprSyntax.self) {
+            return Syntax(awaitExpr.expression).isFunctionCallExpr
+        }
+        return false
     }
 }
 
 private extension FunctionSignatureSyntax {
     var allowsImplicitReturns: Bool {
-        if let simpleType = output?.returnType.as(SimpleTypeIdentifierSyntax.self) {
-            return simpleType.name.text != "Void" && simpleType.name.text != "Never"
-        } else if let tupleType = output?.returnType.as(TupleTypeSyntax.self) {
+        guard let returnClause else { return false }
+        if let identifierType = returnClause.type.as(IdentifierTypeSyntax.self) {
+            return identifierType.name.text != "Void" && identifierType.name.text != "Never"
+        }
+        if let tupleType = returnClause.type.as(TupleTypeSyntax.self) {
             return !tupleType.elements.isEmpty
-        } else {
-            return output != nil
         }
+        return true
     }
 }