Rule: unused_closure_parameter does not respect parameters with backticks

[chosa91]

New Issue Checklist

• Updated SwiftLint to the latest version
• I searched for existing GitHub issues

Describe the bug

In the newly released 0.50.0 version, the rule unused_closure_parameter detects parameter names between backticks as unused parameters, even if they are in use.
This might be intended behavior but it was not an issue in (at least) 0.49.1.

Complete output when running SwiftLint, including the stack trace and command used

$ swiftlint lint
… warning: Unused Closure Parameter Violation: Unused parameter "`self`" in a closure should be replaced with _. (unused_closure_parameter)

Environment

• SwiftLint version: 0.50.0
• Installation method used: Homebrew
• Paste your configuration file:

only_rules:
  - unused_closure_parameter

• Are you using nested configurations?
  NO
• Which Xcode version are you using (check xcodebuild -version)?
  Xcode 14.1
  Build version: 14B47b

func weakify<Owner: AnyObject>(_ owner: Owner, closure: @escaping (Owner) -> Void) -> (() -> Void) {
    { [weak owner] in
        if let owner {
            closure(owner)
        }
    }
}

class Foo {
    struct Sut {
        var arg: (() -> Void)?
    }

    var sut = Sut()

    func bar() {
        var sut = Sut()
        sut.arg = weakify(self) { `self` in
            _ = self
        }
    }
}

[jpsim]

I think the rule might be working correctly here and that you're strongly capturing self in your closure.

To only weakly capture self you'd need to refer to it with backticks:

func weakify<Owner: AnyObject>(_ owner: Owner, closure: @escaping (Owner) -> Void) -> (() -> Void) {
    { [weak owner] in
        if let owner {
            closure(owner)
        }
    }
}

class Foo {
    struct Sut {
        var arg: (() -> Void)?
    }

    var sut = Sut()

    func bar() {
        var sut = Sut()
        sut.arg = weakify(self) { `self` in
            _ = `self`
        }
    }
}

Or to use a different closure argument name to avoid the confusion:

func weakify<Owner: AnyObject>(_ owner: Owner, closure: @escaping (Owner) -> Void) -> (() -> Void) {
    { [weak owner] in
        if let owner {
            closure(owner)
        }
    }
}

class Foo {
    struct Sut {
        var arg: (() -> Void)?
    }

    var sut = Sut()

    func bar() {
        var sut = Sut()
        sut.arg = weakify(self) { this in
            _ = this
        }
    }
}

[chosa91]

Yeah, you're right in the case of `self`, I gave a bad example, sorry.
But what about a parameter that doesn't exist in the func/class/global scope, like this:

class Foo {
    struct Sut {
        var arg: (() -> Void)?
    }

    var sut = Sut()

    func bar() {
        var sut = Sut()
        sut.arg = weakify(self) { `baz` in
            _ = baz
        }
    }
}

warning: Unused Closure Parameter Violation: Unused parameter "`baz`" in a closure should be replaced with _. (unused_closure_parameter)

ps.: It is a really dumb example to use backticks for a non-reserved keyword, so I accept if you close the post because of this. 🙄

[jpsim]

Because SwiftLint rules operate before typechecking and semantic analysis, there’s not enough information available to know if baz is referring to the backticked closure argument or some other declaration, perhaps even in a far away imported module.

I’ll do some more research to better understand the behavior of Swift’s identifier shadowing with backticks to see if there’s something we can do to improve this rule without requiring a separate, more semantically-aware analyzer rule.

[jpsim]

ok, so some lightweight research tells me that we should be able to ignore backticks when checking usage:

let foo = 0

let closure: (Int) -> Void = { `foo` in
    print(foo)
}

closure(1) // prints '1'

[jpsim]

Fix in #4590

[chosa91]

Thanks for the quick fix, have a nice day!