Variable Shadowing

Do not shadow variables declared in outer scopes

Key	Value
severity	warning
ignore_parameters	true

Non Triggering Examples

//
// ignore_parameters: true
//

var a: String?
func test(a: String?) {
    print(a)
}

var a: String = "hello"
if let b = a {
    print(b)
}

var a: String?
func test() {
    if let b = a {
        print(b)
    }
}

for i in 1...10 {
    print(i)
}
for j in 1...10 {
    print(j)
}

func test() {
    var a: String = "hello"
    func nested() {
        var b: String = "world"
        print(a, b)
    }
}

class Test {
    var a: String?
    func test(a: String?) {
        print(a)
    }
}

var outer: String = "hello"
if let inner = Optional(outer) {
    print(inner)
}

var a: String = "outer"
let (b, c) = ("first", "second")
print(a, b, c)

class Test {
    var property: String = "class property"
    func test() {
        var localVar = "local"
        print(property, localVar)
    }
}

func outer() {
    func inner() {
        print("no shadowing")
    }
}

var result: String?
if let unwrappedResult = result {
    print(unwrappedResult)
}

var value: Int? = 10
guard let safeValue = value else {
    return
}
print(safeValue)

var data: [Int?] = [1, nil, 3]
for case let item? in data {
    print(item)
}

let a: Int?
if let a { print(a) }

let a: Int?
guard let a else { return }

let a: Int?
while let a { print(a) }

var a = 1
if let a = a {
    print(a)
}

func test() {
    var a = 1
    var b = 2
}

var outer: String = "hello"
func test() {
    let ↓outer = "world"
    print(outer)
}

var x = 1
do {
    let ↓x = 2
    print(x)
}

var counter = 0
func incrementCounter() {
    var ↓counter = 1
    counter += 1
}

func outer() {
    var value = 10
    do {
        let ↓value = 20
        print(value)
    }
}

var globalName = "global"
func test() {
    for item in [1, 2, 3] {
        var ↓globalName = "local"
        print(globalName)
    }
}

var foo = 1
do {
    let ↓foo = 2
}

var bar = 1
func test() {
    let ↓bar = 2
}

var a = 1
if let ↓a = Optional(2) {
    let ↓a = 3
    print(a)
}

var i = 1
for ↓i in 1...3 {
    let ↓i = 2
    print(i)
}

func test() {
    var a = 1
    do {
        var ↓a = 2
        print(a)
    }
}

func test() {
    var a = 1
    if true {
        var ↓a = 2
        print(a)
    }
}

func test() {
    var a = 1
    for _ in 0..<1 {
        var ↓a = 2
        print(a)
    }
}

func test() {
    var a = 1
    while true {
        var ↓a = 2
        break
    }
}

var a = 1
if let ↓a = Optional(2) {}

var i = 1
for ↓i in 1...3 {}

//
// ignore_parameters: false
//

var a: String?
func test(↓a: String?) {
    print(a)
}

struct S {
    var a = 1
    var b: Int {
        let ↓a = 2
        return a
    }
}

var a: String?
while let ↓a = Optional("hello") {}

var a: String?
guard let ↓a = Optional("hello") else { return }