How to use isOverridable method of without class

...331    332    guard !shouldGenerateDefaultInitializer else { return "" }333    let initializers = mockableType.methods334      .filter(isProxyable)335      .filter(isOverridable)336      .sorted()337      .compactMap({ methodTemplate(for: $0).classInitializerProxy })338    339    guard !initializers.isEmpty else {340      return "public enum InitializerProxy {}"341    }342    return NominalTypeDefinitionTemplate(declaration: "public enum InitializerProxy",343                                         body: String(lines: initializers, spacing: 2)).render()344  }345  346  /// Store the source location of where the mock was initialized. This allows `XCTest` errors from347  /// unstubbed method invocations to show up in the testing code.348  var shouldGenerateDefaultInitializer: Bool {349    // Opaque types can have designated initializers we don't know about, so it's best to ignore.350    guard mockableType.opaqueInheritedTypeNames.isEmpty else {351      logWarning(352        "Unable to synthesize default initializer for \(mockableType.name.singleQuoted) which inherits from an external type not defined in a supporting source file",353        diagnostic: .undefinedType,354        filePath: mockableType.filePath,355        line: self.mockableType.lineNumber356      )357      return false358    }359    360    let hasDesignatedInitializer =361      mockableType.methods.contains(where: { $0.isDesignatedInitializer })362    363    guard mockableType.kind == .protocol else { // Handle classes.364      if hasDesignatedInitializer {365        log("Skipping default initializer generation for \(mockableType.name.singleQuoted) because it is a class with a designated initializer")366      }367      return !hasDesignatedInitializer368    }369    370    // We can always generate a default initializer for protocols without class conformance.371    guard protocolClassConformance != nil else { return true }372    373    // Ignore protocols conforming to a class with a designated initializer.374    guard !hasDesignatedInitializer else {375      log("Skipping default initializer generation for \(mockableType.name.singleQuoted) because it is a protocol conforming to a class with a designated initializer")376      return false377    }378    379    let isMockableClassConformance = mockableType.primarySelfConformanceType?.shouldMock ?? true380    if !isMockableClassConformance {381      logWarning(382        "\(mockableType.name.singleQuoted) conforms to a class without public initializers and cannot be initialized",383        diagnostic: .notMockable,384        filePath: mockableType.filePath,385        line: self.mockableType.lineNumber386      )387    }388    return isMockableClassConformance389  }390  391  var defaultInitializer: String {392    guard shouldGenerateDefaultInitializer else { return "" }393    let canCallSuper = mockableType.kind == .class || protocolClassConformance != nil394    return FunctionDefinitionTemplate(395      declaration: "fileprivate init(sourceLocation: Mockingbird.SourceLocation)",396      body: String(lines: [397        canCallSuper ? "super.init()" : "",398        "self.mockingbirdContext.sourceLocation = sourceLocation",399        "\(mockableType.name)Mock.mockingbirdContext.sourceLocation = sourceLocation",400      ])).render()401  }402  403  lazy var containsOverridableDesignatedInitializer: Bool = {404    return mockableType.methods.contains(where: {405      $0.isOverridable && $0.isDesignatedInitializer && $0.isMockable406    })407  }()408  409  func renderVariables() -> String {410    return String(lines: mockableType.variables.sorted(by: <).map({411      VariableTemplate(variable: $0, context: self).render()412    }), spacing: 2)413  }414  415  func isOverridable(method: Method) -> Bool {416    let isClassMock = mockableType.kind == .class || mockableType.primarySelfConformanceType != nil417    let isGeneric = !method.whereClauses.isEmpty || !method.genericTypes.isEmpty418    guard isClassMock, isGeneric else { return true }419    420    // Not possible to override overloaded methods where uniqueness is from generic constraints.421    // https://forums.swift.org/t/cannot-override-more-than-one-superclass-declaration/22213422    // This is fixed in Swift 5.2, so non-overridable methods require compilation conditions.423    return mockableType.methodsCount[Method.Reduced(from: method)] == 1424  }425  426  func renderMethods() -> String {427    return String(lines: Set(mockableType.methods).sorted(by: <).filter({ $0.isMockable }).map({428      let renderedMethod = methodTemplate(for: $0).render()429      guard !isOverridable(method: $0) else { return renderedMethod }430      return String(lines: [431        "#if swift(>=5.2)",432        renderedMethod,433        "#endif",434      ])435    }), spacing: 2)436  }437  438  func specializeTypeName(_ typeName: String) -> String {439    // NOTE: Checking for an indicator prior to running `replacingOccurrences` is 4x faster.440    let concreteMockTypeName = mockableType.name + "Mock"441    442    if typeName.contains(SerializationRequest.Constants.selfTokenIndicator) {443      return typeName.replacingOccurrences(of: SerializationRequest.Constants.selfToken,...

...97  98  /// Declared in a class, or a class that the protocol conforms to.99  lazy var isClassBound: Bool = {100    let isClassDefinedProtocolConformance = context.protocolClassConformance != nil101      && method.isOverridable102    return context.mockableType.kind == .class || isClassDefinedProtocolConformance103  }()104  105  var overridableUniqueDeclaration: String {106    return "\(fullNameForMocking)\(returnTypeAttributesForMocking) -> \(mockableReturnType)\(genericConstraints)"107  }108  109  lazy var uniqueDeclaration: String = { return overridableUniqueDeclaration }()110  111  /// Methods synthesized specifically for the stubbing and verification APIs.112  var synthesizedDeclarations: String {113    let invocationType = "(\(separated: matchableParameterTypes)) \(returnTypeAttributesForMatching)-> \(matchableReturnType)"114    115    var methods = [String]()116    let genericTypes = [declarationTypeForMocking, invocationType, matchableReturnType]117    let returnType = "Mockingbird.Mockable<\(separated: genericTypes)>"118    119    let declaration = "public \(regularModifiers)func \(fullNameForMatching) -> \(returnType)"120    let genericConstraints = method.whereClauses.map({ context.specializeTypeName("\($0)") })121    122    let body = !context.shouldGenerateThunks ? MockableTypeTemplate.Constants.thunkStub : """123    return \(ObjectInitializationTemplate(124              name: "Mockingbird.Mockable",125              genericTypes: genericTypes,126              arguments: [("mock", mockObject), ("invocation", matchableInvocation())]))127    """128    methods.append(129      FunctionDefinitionTemplate(attributes: method.attributes.safeDeclarations,130                                 declaration: declaration,131                                 genericConstraints: genericConstraints,132                                 body: body).render())133    134    // Variadics generate both the array and variadic-forms of the function signature to allow use135    // of either when stubbing and verifying.136    if method.isVariadic {137      let body = !context.shouldGenerateThunks ? MockableTypeTemplate.Constants.thunkStub : """138      return \(ObjectInitializationTemplate(139                name: "Mockingbird.Mockable",140                genericTypes: genericTypes,141                arguments: [("mock", mockObject),142                            ("invocation", matchableInvocation(isVariadic: true))]))143      """144      let declaration = "public \(regularModifiers)func \(fullNameForMatchingVariadics) -> \(returnType)"145      methods.append(146        FunctionDefinitionTemplate(attributes: method.attributes.safeDeclarations,147                                   declaration: declaration,148                                   genericConstraints: genericConstraints,149                                   body: body).render())150    }151    152    return String(lines: methods, spacing: 2)153  }154  155  /// Modifiers specifically for stubbing and verification methods.156  lazy var regularModifiers: String = { return modifiers(allowOverride: false) }()157  /// Modifiers for mocked methods.158  lazy var overridableModifiers: String = { return modifiers(allowOverride: true) }()159  func modifiers(allowOverride: Bool = true) -> String {160    let isRequired = method.attributes.contains(.required)161    let required = (isRequired || method.isInitializer ? "required " : "")162    let shouldOverride = method.isOverridable && !isRequired && allowOverride163    let override = shouldOverride ? "override " : ""164    let `static` = method.kind.typeScope.isStatic ? "static " : ""165    return "\(required)\(override)\(`static`)"166  }167  168  lazy var genericTypes: [String] = {169    return method.genericTypes.map({ $0.flattenedDeclaration })170  }()171  172  lazy var genericConstraints: String = {173    guard !method.whereClauses.isEmpty else { return "" }174    return " where \(separated: method.whereClauses.map({ context.specializeTypeName("\($0)") }))"175  }()176  ...

1func isOverridable() -> Bool {2}3func isOverridable() -> Bool {4}5func isOverridable() -> Bool {6}7func isOverridable() -> Bool {8}9func isOverridable() -> Bool {10}11func isOverridable() -> Bool {12}13func isOverridable() -> Bool {14}15func isOverridable() -> Bool {16}17func isOverridable() -> Bool {18}19func isOverridable() -> Bool {20}21func isOverridable() -> Bool {22}23func isOverridable() -> Bool {24}25func isOverridable() -> Bool {26}27func isOverridable() -> Bool {28}29func isOverridable() -> Bool {30}

1class A {2  func f() {}3}4class B : A {5  override func f() {}6}7func isOverridable(_ x: A) {8  if x is B {9    print("is overridable")10  } else {11    print("is not overridable")12  }13}14isOverridable(A())15isOverridable(B())16class A {17  func f() {}18}19class B : A {20  override func f() {}21}22class C {23  func isOverridable(_ x: A) {24    if x is B {25      print("is overridable")26    } else {27      print("is not overridable")28    }29  }30}31let c = C()32c.isOverridable(A())33c.isOverridable(B())34func isOverridable(_ x: A) {35  if x is B {36    print("is overridable")37  } else {38    print("is not overridable")39  }40}41isOverridable(A())42isOverridable(B())43class C {44  func isOverridable(_ x: A) {45    if x is B {46      print("is overridable")47    } else {48      print("is not overridable")49    }50  }51}52let c = C()53c.isOverridable(A())54c.isOverridable(B())

1class A {2    func f() {}3}4class B: A {5    override func f() {}6}7class A {8    func f() {}9}10class B: A {11    override func f() {}12}

1import UIKit2class A {3    func m1() {4    }5}6class B: A {7    override func m1() {8    }9}10func isOverridable(_ a: Any) -> Bool {11    let m = Mirror(reflecting: a)12    for child in m.children {13        if child.label == "isOverridable" {14        }15    }16}17let a = A()18let b = B()19import UIKit20protocol A {21    func m1()22}23class B: A {24    func m1() {25    }26}27func isOverridable(_ a: Any) -> Bool {28    let m = Mirror(reflecting: a)29    for child in m.children {30        if child.label == "isOverridable" {31        }32    }33}

1import Foundation2class A {3    func method() {}4}5class B: A {6    override func method() {}7}8class C: A {9    override func method() {}10}11class D: A {12    func method() {}13}14let a = A()15let b = B()16let c = C()17let d = D()18import Foundation19protocol P {20    func method()21}22class A: P {23    func method() {}24}25class B: A {26    override func method() {}27}28class C: A {29    override func method() {}30}31class D: A {32    func method() {}33}34let a = A()35let b = B()36let c = C()37let d = D()38import Foundation39protocol P {40    func method()41}42class A: P {43    func method() {}44}45class B: A, P {46    func method() {}47}48class C: A, P {49    func method() {}50}51class D: A, P {52    func method() {}53}54let a = A()55let b = B()56let c = C()57let d = D()58import Foundation59protocol P {60    func method()61}62class A: P {63    func method() {}64}65class B: A, P {

1class A {2    func foo() { }3}4class B: A {5    override func foo() { }6}7class C: B {8    override func foo() { }9}10class A {11    func foo() -> A { return self }12}13class B: A {14    override func foo() -> B { return self }15}16class C: B {17    override func foo() -> C { return self }18}19class A {20    func foo() -> A { return self }21}22class B: A {