Discouraged Optional Collection

Prefer empty collection over optional collection

• Identifier: discouraged_optional_collection
• Enabled by default: No
• Supports autocorrection: No
• Kind: idiomatic
• Analyzer rule: No
• Minimum Swift compiler version: 5.0.0
• Default configuration:

  Key	Value
  severity	warning

Non Triggering Examples

var foo: [Int]

var foo: [String: Int]

var foo: Set<String>

var foo: [String: [String: Int]]

let foo: [Int] = []

let foo: [String: Int] = [:]

let foo: Set<String> = []

let foo: [String: [String: Int]] = [:]

var foo: [Int] { return [] }

func foo() -> [Int] {}

func foo() -> [String: String] {}

func foo() -> Set<Int> {}

func foo() -> ([Int]) -> String {}

func foo(input: [String] = []) {}

func foo(input: [String: String] = [:]) {}

func foo(input: Set<String> = []) {}

class Foo {
    func foo() -> [Int] {}
}

class Foo {
    func foo() -> [String: String] {}
}

class Foo {
    func foo() -> Set<Int> {}
}

class Foo {
    func foo() -> ([Int]) -> String {}
}

struct Foo {
    func foo() -> [Int] {}
}

struct Foo {
    func foo() -> [String: String] {}
}

struct Foo {
    func foo() -> Set<Int> {}
}

struct Foo {
    func foo() -> ([Int]) -> String {}
}

enum Foo {
    func foo() -> [Int] {}
}

enum Foo {
    func foo() -> [String: String] {}
}

enum Foo {
    func foo() -> Set<Int> {}
}

enum Foo {
    func foo() -> ([Int]) -> String {}
}

class Foo {
    func foo(input: [String] = []) {}
}

class Foo {
    func foo(input: [String: String] = [:]) {}
}

class Foo {
    func foo(input: Set<String> = []) {}
}

struct Foo {
    func foo(input: [String] = []) {}
}

struct Foo {
    func foo(input: [String: String] = [:]) {}
}

struct Foo {
    func foo(input: Set<String> = []) {}
}

enum Foo {
    func foo(input: [String] = []) {}
}

enum Foo {
    func foo(input: [String: String] = [:]) {}
}

enum Foo {
    func foo(input: Set<String> = []) {}
}

Triggering Examples

var foo: ↓[Int]?

var foo: ↓[String: Int]?

var foo: ↓Set<String>?

let foo: ↓[Int]? = nil

let foo: ↓[String: Int]? = nil

let foo: ↓Set<String>? = nil

var foo: ↓[Int]? { return nil }

let foo: ↓[Int]? { return nil }()

func foo() -> ↓[T]? {}

func foo() -> ↓[String: String]? {}

func foo() -> ↓[String: [String: String]]? {}

func foo() -> [String: ↓[String: String]?] {}

func foo() -> ↓Set<Int>? {}

static func foo() -> ↓[T]? {}

static func foo() -> ↓[String: String]? {}

static func foo() -> ↓[String: [String: String]]? {}

static func foo() -> [String: ↓[String: String]?] {}

static func foo() -> ↓Set<Int>? {}

func foo() -> (↓[Int]?) -> String {}

func foo() -> ([Int]) -> ↓[String]? {}

func foo(input: ↓[String: String]?) {}

func foo(input: ↓[String: [String: String]]?) {}

func foo(input: [String: ↓[String: String]?]) {}

func foo(input: ↓[String: ↓[String: String]?]?) {}

func foo<K, V>(_ dict1: [K: V], _ dict2: ↓[K: V]?) -> [K: V]

func foo<K, V>(dict1: [K: V], dict2: ↓[K: V]?) -> [K: V]

static func foo(input: ↓[String: String]?) {}

static func foo(input: ↓[String: [String: String]]?) {}

static func foo(input: [String: ↓[String: String]?]) {}

static func foo(input: ↓[String: ↓[String: String]?]?) {}

static func foo<K, V>(_ dict1: [K: V], _ dict2: ↓[K: V]?) -> [K: V]

static func foo<K, V>(dict1: [K: V], dict2: ↓[K: V]?) -> [K: V]

class Foo {
    var foo: ↓[Int]?
}

class Foo {
    var foo: ↓[String: Int]?
}

class Foo {
    var foo: ↓Set<String>?
}

class Foo {
    let foo: ↓[Int]? = nil
}

class Foo {
    let foo: ↓[String: Int]? = nil
}

class Foo {
    let foo: ↓Set<String>? = nil
}

struct Foo {
    var foo: ↓[Int]?
}

struct Foo {
    var foo: ↓[String: Int]?
}

struct Foo {
    var foo: ↓Set<String>?
}

struct Foo {
    let foo: ↓[Int]? = nil
}

struct Foo {
    let foo: ↓[String: Int]? = nil
}

struct Foo {
    let foo: ↓Set<String>? = nil
}

class Foo {
    var foo: ↓[Int]? { return nil }
}

class Foo {
    let foo: ↓[Int]? { return nil }()
}

class Foo {
    var foo: ↓Set<String>? { return nil }
}

class Foo {
    let foo: ↓Set<String>? { return nil }()
}

struct Foo {
    var foo: ↓[Int]? { return nil }
}

struct Foo {
    let foo: ↓[Int]? { return nil }()
}

struct Foo {
    var foo: ↓Set<String>? { return nil }
}

struct Foo {
    let foo: ↓Set<String>? { return nil }()
}

enum Foo {
    var foo: ↓[Int]? { return nil }
}

enum Foo {
    let foo: ↓[Int]? { return nil }()
}

enum Foo {
    var foo: ↓Set<String>? { return nil }
}

enum Foo {
    let foo: ↓Set<String>? { return nil }()
}

class Foo {
    func foo() -> [T]? {}
}

class Foo {
    func foo() -> ↓[String: String]? {}
}

class Foo {
    func foo() -> [String: [String: String]]? {}
}

class Foo {
    func foo() -> [String: ↓[String: String]?] {}
}

class Foo {
    func foo() -> Set<Int>? {}
}

class Foo {
    static func foo() -> [T]? {}
}

class Foo {
    static func foo() -> ↓[String: String]? {}
}

class Foo {
    static func foo() -> [String: [String: String]]? {}
}

class Foo {
    static func foo() -> [String: ↓[String: String]?] {}
}

class Foo {
    static func foo() -> Set<Int>? {}
}

class Foo {
    func foo() -> ([Int]?) -> String {}
}

class Foo {
    func foo() -> ([Int]) -> [String]? {}
}

struct Foo {
    func foo() -> [T]? {}
}

struct Foo {
    func foo() -> ↓[String: String]? {}
}

struct Foo {
    func foo() -> [String: [String: String]]? {}
}

struct Foo {
    func foo() -> [String: ↓[String: String]?] {}
}

struct Foo {
    func foo() -> Set<Int>? {}
}

struct Foo {
    static func foo() -> [T]? {}
}

struct Foo {
    static func foo() -> ↓[String: String]? {}
}

struct Foo {
    static func foo() -> [String: [String: String]]? {}
}

struct Foo {
    static func foo() -> [String: ↓[String: String]?] {}
}

struct Foo {
    static func foo() -> Set<Int>? {}
}

struct Foo {
    func foo() -> ([Int]?) -> String {}
}

struct Foo {
    func foo() -> ([Int]) -> [String]? {}
}

enum Foo {
    func foo() -> [T]? {}
}

enum Foo {
    func foo() -> ↓[String: String]? {}
}

enum Foo {
    func foo() -> [String: [String: String]]? {}
}

enum Foo {
    func foo() -> [String: ↓[String: String]?] {}
}

enum Foo {
    func foo() -> Set<Int>? {}
}

enum Foo {
    static func foo() -> [T]? {}
}

enum Foo {
    static func foo() -> ↓[String: String]? {}
}

enum Foo {
    static func foo() -> [String: [String: String]]? {}
}

enum Foo {
    static func foo() -> [String: ↓[String: String]?] {}
}

enum Foo {
    static func foo() -> Set<Int>? {}
}

enum Foo {
    func foo() -> ([Int]?) -> String {}
}

enum Foo {
    func foo() -> ([Int]) -> [String]? {}
}

class Foo {
    func foo(input: ↓[String: String]?) {}
}

class Foo {
    func foo(input: ↓[String: [String: String]]?) {}
}

class Foo {
    func foo(input: [String: ↓[String: String]?]) {}
}

class Foo {
    func foo(input: ↓[String: ↓[String: String]?]?) {}
}

class Foo {
    func foo<K, V>(_ dict1: [K: V], _ dict2: ↓[K: V]?) -> [K: V]
}

class Foo {
    func foo<K, V>(dict1: [K: V], dict2: ↓[K: V]?) -> [K: V]
}

class Foo {
    static func foo(input: ↓[String: String]?) {}
}

class Foo {
    static func foo(input: ↓[String: [String: String]]?) {}
}

class Foo {
    static func foo(input: [String: ↓[String: String]?]) {}
}

class Foo {
    static func foo(input: ↓[String: ↓[String: String]?]?) {}
}

class Foo {
    static func foo<K, V>(_ dict1: [K: V], _ dict2: ↓[K: V]?) -> [K: V]
}

class Foo {
    static func foo<K, V>(dict1: [K: V], dict2: ↓[K: V]?) -> [K: V]
}

struct Foo {
    func foo(input: ↓[String: String]?) {}
}

struct Foo {
    func foo(input: ↓[String: [String: String]]?) {}
}

struct Foo {
    func foo(input: [String: ↓[String: String]?]) {}
}

struct Foo {
    func foo(input: ↓[String: ↓[String: String]?]?) {}
}

struct Foo {
    func foo<K, V>(_ dict1: [K: V], _ dict2: ↓[K: V]?) -> [K: V]
}

struct Foo {
    func foo<K, V>(dict1: [K: V], dict2: ↓[K: V]?) -> [K: V]
}

struct Foo {
    static func foo(input: ↓[String: String]?) {}
}

struct Foo {
    static func foo(input: ↓[String: [String: String]]?) {}
}

struct Foo {
    static func foo(input: [String: ↓[String: String]?]) {}
}

struct Foo {
    static func foo(input: ↓[String: ↓[String: String]?]?) {}
}

struct Foo {
    static func foo<K, V>(_ dict1: [K: V], _ dict2: ↓[K: V]?) -> [K: V]
}

struct Foo {
    static func foo<K, V>(dict1: [K: V], dict2: ↓[K: V]?) -> [K: V]
}

enum Foo {
    func foo(input: ↓[String: String]?) {}
}

enum Foo {
    func foo(input: ↓[String: [String: String]]?) {}
}

enum Foo {
    func foo(input: [String: ↓[String: String]?]) {}
}

enum Foo {
    func foo(input: ↓[String: ↓[String: String]?]?) {}
}

enum Foo {
    func foo<K, V>(_ dict1: [K: V], _ dict2: ↓[K: V]?) -> [K: V]
}

enum Foo {
    func foo<K, V>(dict1: [K: V], dict2: ↓[K: V]?) -> [K: V]
}

enum Foo {
    static func foo(input: ↓[String: String]?) {}
}

enum Foo {
    static func foo(input: ↓[String: [String: String]]?) {}
}

enum Foo {
    static func foo(input: [String: ↓[String: String]?]) {}
}

enum Foo {
    static func foo(input: ↓[String: ↓[String: String]?]?) {}
}

enum Foo {
    static func foo<K, V>(_ dict1: [K: V], _ dict2: ↓[K: V]?) -> [K: V]
}

enum Foo {
    static func foo<K, V>(dict1: [K: V], dict2: ↓[K: V]?) -> [K: V]
}