Redundant Self in Closure

Explicit use of ‘self’ is not required

• Identifier: redundant_self_in_closure
• Enabled by default: No
• Supports autocorrection: Yes
• Kind: style
• Analyzer rule: No
• Minimum Swift compiler version: 5.0.0
• Default configuration:

  Key	Value
  severity	warning

Non Triggering Examples

struct S {
    var x = 0
    func f(_ work: @escaping () -> Void) { work() }
    func g() {
        f {
            x = 1
            f { x = 1 }
            g()
        }
    }
}

class C {
    var x = 0
    func f(_ work: @escaping () -> Void) { work() }
    func g() {
        f { [weak self] in
            self?.x = 1
            self?.g()
            guard let self = self ?? C() else { return }
            self?.x = 1
        }
        C().f { self.x = 1 }
        f { [weak self] in if let self { x = 1 } }
    }
}

struct S {
    var x = 0, error = 0, exception = 0
    var y: Int?, z: Int?, u: Int, v: Int?, w: Int?
    func f(_ work: @escaping (Int) -> Void) { work() }
    func g(x: Int) {
        f { u in
            self.x = x
            let x = 1
            self.x = 2
            if let y, let v {
                self.y = 3
                self.v = 1
            }
            guard let z else {
                let v = 4
                self.x = 5
                self.v = 6
                return
            }
            self.z = 7
            while let v { self.v = 8 }
            for w in [Int]() { self.w = 9 }
            self.u = u
            do {} catch { self.error = 10 }
            do {} catch let exception { self.exception = 11 }
        }
    }
}

enum E {
    case a(Int)
    case b(Int, Int)
}
struct S {
    var x: E = .a(3), y: Int, z: Int
    func f(_ work: @escaping () -> Void) { work() }
    func g(x: Int) {
        f {
            switch x {
            case let .a(y):
                self.y = 1
            case .b(let y, var z):
                self.y = 2
                self.z = 3
            }
        }
    }
}

Triggering Examples

struct S {
    var x = 0
    func f(_ work: @escaping () -> Void) { work() }
    func g() {
        f {
            ↓self.x = 1
            if ↓self.x == 1 { ↓self.g() }
        }
    }
}

class C {
    var x = 0
    func g() {
        {
            ↓self.x = 1
            ↓self.g()
        }()
    }
}

class C {
    var x = 0
    func f(_ work: @escaping () -> Void) { work() }
    func g() {
        f { [self] in
            ↓self.x = 1
            ↓self.g()
            f { self.x = 1 }
        }
    }
}

class C {
    var x = 0
    func f(_ work: @escaping () -> Void) { work() }
    func g() {
        f { [unowned self] in ↓self.x = 1 }
        f { [self = self] in ↓self.x = 1 }
        f { [s = self] in s.x = 1 }
    }
}

struct S {
    var x = 0
    var y: Int?, z: Int?, v: Int?, w: Int?
    func f(_ work: @escaping () -> Void) { work() }
    func g(w: Int, _ v: Int) {
        f {
            self.w = 1
            ↓self.x = 2
            if let y { ↓self.x = 3 }
            else { ↓self.y = 3 }
            guard let z else {
                ↓self.z = 4
                ↓self.x = 5
                return
            }
            ↓self.y = 6
            while let y { ↓self.x = 7 }
            for y in [Int]() { ↓self.x = 8 }
            self.v = 9
            do {
                let x = 10
                self.x = 11
            }
            ↓self.x = 12
        }
    }
}

class C {
    var x = 0
    func f(_ work: @escaping () -> Void) { work() }
    func g() {
        f { [weak self] in
            self?.x = 1
            guard let self else { return }
            ↓self.x = 1
        }
        f { [weak self] in
            self?.x = 1
            if let self = self else { ↓self.x = 1 }
            self?.x = 1
        }
        f { [weak self] in
            self?.x = 1
            while let self else { ↓self.x = 1 }
            self?.x = 1
        }
    }
}