`redundantStaticSelf` removes required `Self` in extensions. about swiftformat HOT 17 CLOSED

public class LocationDeeplink: Deeplink {

   convenience init?(warnRegion: String) {

      guard let value = Self.location(for: warnRegion) else {
         return nil
      }
      self.init(location: value)
   }
}

extension LocationDeeplink {

   private static func location(for warnRegion: String) -> WCOMLocation? {
      return ...
   }
}

public struct Attributes: OptionSet, Decodable {
    public let rawValue: UInt

    public init(rawValue: UInt) {
        self.rawValue = rawValue
    }

    public init(from decoder: Decoder) throws {
        var container = try decoder.unkeyedContainer()
        var result: Attributes = []
        while !container.isAtEnd {
            let name = try container.decode(String.self)
            if let type = Self.mapping[name] { // <--- here
                result.insert(type)
            }
        }
        self = result
    }

    private static let mapping: [String: Attributes] = [
    ]
}

public class Store {
    private static let kUserName: String? = "USER_NAME"

    @objc lazy var userName: String = {
        if let name = Self.kUserName { // <---- here
            return name
        }
        return ""
    }
}

protocol ContentDetectionConfiguration {
    static var contentTypes: [ContentType] { get }
}

struct ContentDetectionConfigurationDelegate: ContentDetectionConfiguration {
    private static var configurator = ContentTypeConfigurator()

    func isEnabled(at index: Int) -> Bool {
        let contentType = Self.contentTypes[index] // <-- here
        return Self.configurator.isEnabled(contentType: contentType)
    }
}

public func XCTUnimplemented<Result>(
    _ path: KeyPath<some Any, some Any>,
    file: StaticString = #file,
    fileID: StaticString = #fileID,
    line: UInt = #line
) -> @Sendable () -> Result {
    return { fatalError("don't care") }
}

public struct Environment {
    let test: () -> Void

    init(test: @escaping () -> Void) {
        self.test = test
    }

    static var unimplemented: Self {
        .init(test: XCTUnimplemented(\Self.test)) // this `Self` is removed by SwiftFormat, but is necessary
    }
}

class A {
    static var p: Int = 0
}

class B: A {
    var test: Int {
        return Self.p.bitWidth // Still being removed
    }
}