Add explicit_return opt-in rule

Add `explicit_return` opt-in rule that warns against omitting the `return` keyword inside closures, functions and getters. This rule provides behavior opposite to `implicit_return` and complements it. It's disabled by default and provides configurable return kinds and severity.

# Conflicts:
#	Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/ExplicitReturnConfiguration.swift
#	Source/SwiftLintBuiltInRules/Rules/Style/ExplicitReturnRule.swift
#	Source/SwiftLintBuiltInRules/Rules/Style/ExplicitReturnRuleExamples.swift
#	Tests/FileSystemAccessTests/ExplicitReturnConfigurationTests.swift
#	Tests/FileSystemAccessTests/ExplicitReturnRuleTests.swift

Author: m-chojnacki

CHANGELOG.md

@@ -3033,6 +3033,10 @@ 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/Models/BuiltInRules.swift

@@ -62,6 +62,7 @@ public let builtInRules: [any Rule.Type] = [
     ExplicitACLRule.self,
     ExplicitEnumRawValueRule.self,
     ExplicitInitRule.self,
+    ExplicitReturnRule.self,
     ExplicitSelfRule.self,
     ExplicitTopLevelACLRule.self,
     ExplicitTypeInterfaceRule.self,

Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/ExplicitReturnConfiguration.swift

@@ -0,0 +1,47 @@
+public struct ExplicitReturnConfiguration: RuleConfiguration, Equatable {
+    public enum ReturnKind: String, CaseIterable {
+        case closure
+        case function
+        case getter
+    }
+
+    public static let defaultIncludedKinds = Set(ReturnKind.allCases)
+
+    private(set) var severityConfiguration = SeverityConfiguration(.warning)
+
+    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) {
+        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)
+    }
+}

Source/SwiftLintBuiltInRules/Rules/Style/ExplicitReturnRule.swift

@@ -0,0 +1,122 @@
+import Foundation
+import SourceKittenFramework
+import SwiftSyntax
+
+public struct ExplicitReturnRule: ConfigurationProviderRule, SubstitutionCorrectableRule, OptInRule {
+    public var configuration = ExplicitReturnConfiguration()
+
+    public init() {}
+
+    public static let description = RuleDescription(
+        identifier: "explicit_return",
+        name: "Explicit Return",
+        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 }
+
+        if firstItem.isImplicitlyReturnable {
+            positions.append(firstItem.positionAfterSkippingLeadingTrivia)
+        }
+    }
+
+    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 }
+
+        if firstItem.isImplicitlyReturnable {
+            positions.append(firstItem.positionAfterSkippingLeadingTrivia)
+        }
+    }
+
+    override func visitPost(_ node: VariableDeclSyntax) {
+        guard includedKinds.contains(.getter) else { return }
+
+        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 }
+
+                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 }
+
+                if firstItem.isImplicitlyReturnable {
+                    positions.append(firstItem.positionAfterSkippingLeadingTrivia)
+                }
+            }
+        }
+    }
+}
+
+private extension Syntax {
+    var isImplicitlyReturnable: Bool {
+        isProtocol(ExprSyntaxProtocol.self)
+    }
+}
+
+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) {
+            return !tupleType.elements.isEmpty
+        } else {
+            return output != nil
+        }
+    }
+}