Rule Request: Static Operator

[marcelofabri]

New Issue Checklist

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

New rule request

Operators should be declared as static functions, not free functions. Operators used to be declared as free functions but at some point (Swift 3?) they can also be declared as static methods on the type that they operate.

1. Why should this rule be added? Share links to existing discussion about what
   the community thinks about this.

https://docs.swift.org/swift-book/LanguageGuide/AdvancedOperators.html#ID42

2. Provide several examples of what would and wouldn't trigger violations.

Non Triggering Examples

class A: Equatable {
    static func == (lhs: A, rhs: A) -> Bool {
        return false
    }

class A<T>: Equatable {
    static func == <T>(lhs: A<T>, rhs: A<T>) -> Bool {
        return false
    }

public extension Array where Element == Rule {
    static func == (lhs: Array, rhs: Array) -> Bool {
        if lhs.count != rhs.count { return false }
        return !zip(lhs, rhs).contains { !$0.0.isEqualTo($0.1) }
    }
}

private extension Optional where Wrapped: Comparable {
    static func < (lhs: Optional, rhs: Optional) -> Bool {
        switch (lhs, rhs) {
        case let (lhs?, rhs?):
            return lhs < rhs
        case (nil, _?):
            return true
        default:
            return false
        }
    }
}

Triggering Examples

↓func == (lhs: A, rhs: A) -> Bool {
    return false
}

↓func == <T>(lhs: A<T>, rhs: A<T>) -> Bool {
    return false
}

↓func == (lhs: [Rule], rhs: [Rule]) -> Bool {
    if lhs.count != rhs.count { return false }
    return !zip(lhs, rhs).contains { !$0.0.isEqualTo($0.1) }
}

private ↓func < <T: Comparable>(lhs: T?, rhs: T?) -> Bool {
    switch (lhs, rhs) {
    case let (lhs?, rhs?):
        return lhs < rhs
    case (nil, _?):
        return true
    default:
        return false
    }
}

3. Should the rule be configurable, if so what parameters should be configurable?

Only severity.

4. Should the rule be opt-in or enabled by default? Why?
   See README.md for guidelines on when to mark a rule as opt-in.

Opt-in as a lot of code still uses free functions. Potentially there're also cases where declaring in a type is not possible.