07 · 프로토콜과 디스패치

import Foundation

protocol Greeter { func greet() }
extension Greeter { func farewell() { print("bye") } }   // 요구사항이 아니다

struct S: Greeter { func greet() { print("S") } }

class Base: Greeter {
    func greet() { print("Base") }           // 오버라이드 가능
    final func sealed() { print("sealed") }  // final 메서드
}
final class Leaf: Greeter { func greet() { print("Leaf") } }

class ObjCish: NSObject {
    @objc dynamic func ping() { print("ping") }
}

func run() {
    let s = S();       s.greet()          // ① struct
    let b = Base();    b.greet()          // ② 오버라이드 가능한 클래스 메서드
                       b.sealed()         // ③ final 메서드
    let l = Leaf();    l.greet()          // ④ final 클래스
    let p: any Greeter = S()
                       p.greet()          // ⑤ 프로토콜 요구사항
                       p.farewell()       // ⑥ extension 기본 구현
    let o = ObjCish(); o.ping()           // ⑦ @objc dynamic
}
run()

S
Base
sealed
Leaf
S
bye
ping

   2 class_method
 114 function_ref
  15 objc_method
   6 witness_method

// ① s.greet()
function_ref @$s13dispatch_demo1SV5greetyyF : $@convention(method) (S) -> ()

// ② b.greet()
class_method #Base.greet : (Base) -> () -> (), $@convention(method) (@guaranteed Base) -> ()

// ③ b.sealed()
function_ref @$s13dispatch_demo4BaseC6sealedyyF

// ④ l.greet()
function_ref @$s13dispatch_demo4LeafC5greetyyF

// ⑤ p.greet()
witness_method $@opened("FBD88BD8-…", any Greeter) Self, #Greeter.greet

// ⑥ p.farewell()
function_ref @$s13dispatch_demo7GreeterPAAE8farewellyyF

// ⑦ o.ping()
objc_method #ObjCish.ping!foreign : (ObjCish) -> () -> (), $@convention(objc_method)

protocol Shape {
    func area() -> Double
}

struct Circle: Shape {
    let radius: Double
    func area() -> Double { .pi * radius * radius }
}

// ❌ [any Shape]는 원소마다 existential 컨테이너(최대 40바이트, 3-word 초과 시 힙 박싱)를
//    만들고, 합산 루프의 매 호출이 protocol witness table을 경유한다 — 인라인/특수화 불가.
func totalAreaExistential(_ shapes: [any Shape]) -> Double {
    shapes.reduce(0) { $0 + $1.area() }
}

// ✅ 제네릭 <T: Shape>는 호출부에서 구체 타입이 확정되므로, 같은 모듈 안에서는
//    컴파일러가 이 호출을 통째로 특수화해 witness table 자체를 없앨 수 있다.
func totalArea<T: Shape>(_ shapes: [T]) -> Double {
    shapes.reduce(0) { $0 + $1.area() }
}

let circles = (0..<10_000).map { _ in Circle(radius: 2.0) }
print(totalArea(circles))   // 동종 배열이라면 제네릭 버전을 우선 고려한다

import Foundation

// ❌ 오버라이드 가능성이 열려 있으면 컴파일러는 안전하게 vtable 호출을 없애지 못한다.
class JSONValidator {
    func validate(_ data: Data) -> Bool { !data.isEmpty }
}

// ✅ 실제로 서브클래싱할 계획이 없다면 final로 명시한다.
final class StrictJSONValidator {
    func validate(_ data: Data) -> Bool { !data.isEmpty }
}

import Foundation

protocol Greeter {
    func greet() -> String   // 프로토콜 "요구사항" — witness table에 슬롯이 생긴다
}

extension Greeter {
    // 요구사항의 기본 구현
    func greet() -> String { "Greeter 기본 인사" }

    // 요구사항이 아니다 — 어떤 프로토콜에도 선언된 적이 없다.
    // witness table에 슬롯이 없으므로 호출부는 컴파일 타임에 정적으로 바인딩된다.
    func farewell() -> String { "Greeter 확장의 작별인사" }
}

struct Person: Greeter {
    // greet()는 요구사항이므로 이 구현이 witness table 슬롯을 채운다 → 항상 이게 불린다.
    func greet() -> String { "Person의 인사" }

    // farewell()은 요구사항이 아니라서 "오버라이드"가 아니라, 같은 이름의
    // 별개 정적 함수를 하나 더 만든 것에 가깝다. Person 타입으로 직접 부를 때만 보인다.
    func farewell() -> String { "Person의 작별인사" }
}

let concrete = Person()
print(concrete.greet())        // "Person의 인사"        — 구체 타입 직접 호출
print(concrete.farewell())     // "Person의 작별인사"     — 구체 타입 직접 호출

let asProtocol: Greeter = concrete   // 같은 인스턴스, 정적 타입만 Greeter로 소거
print(asProtocol.greet())      // "Person의 인사"          — witness table 경유, 여전히 Person의 구현
print(asProtocol.farewell())   // "Greeter 확장의 작별인사" — ⚠️ 정적 바인딩, Person의 구현이 무시된다!

Person의 인사              ← concrete.greet()
Person의 작별인사           ← concrete.farewell()
Person의 인사              ← asProtocol.greet()      요구사항이라 Person 구현이 불린다
Greeter 확장의 작별인사      ← asProtocol.farewell()   요구사항이 아니라 extension 구현이 불린다

// concrete.greet()      — 구체 타입이라 정적으로 바인딩
function_ref @$s7greeter6PersonV5greetSSyF : (Person) -> @owned String

// concrete.farewell()   — 역시 정적
function_ref @$s7greeter6PersonV8farewellSSyF

// asProtocol.greet()    — 요구사항이므로 런타임에 witness table 조회
witness_method $@opened("…", any Greeter) Self, #Greeter.greet

// asProtocol.farewell() — 요구사항이 아니므로 여전히 정적!
function_ref @$s7greeter7GreeterPAAE8farewellSSyF

sil_witness_table hidden Person: Greeter module greeter {
  method #Greeter.greet: <Self where Self : Greeter> (Self) -> () -> String
       : @$s7greeter6PersonVAA7GreeterA2aDP5greetSSyFTW
}

// ❌ 커스텀 축출 정책을 만들고 싶은데 evict()가 확장에만 있다 — 오버라이드해도
//    프로토콜 타입을 통한 호출에서는 반영되지 않을 수 있다.
protocol Cache {
    associatedtype Key: Hashable
    associatedtype Value
    func store(_ value: Value, for key: Key)
}
extension Cache {
    func evict() { print("기본 LRU 축출") }   // 요구사항이 아님
}

// ✅ 오버라이드 가능해야 한다면 요구사항으로 선언하고, 확장은 "기본값"만 준다.
protocol Cache2 {
    associatedtype Key: Hashable
    associatedtype Value
    func store(_ value: Value, for key: Key)
    func evict()               // 요구사항으로 승격 → witness table 슬롯 생김
}
extension Cache2 {
    func evict() { print("기본 LRU 축출") }   // 이제 이건 "디폴트"이지 전부가 아니다
}

func testGreeterDispatchParity() {
    let concrete = Person()
    let asProtocol: Greeter = concrete

    // greet()는 요구사항이라 정적 타입과 무관하게 항상 같아야 한다.
    assert(concrete.greet() == asProtocol.greet())

    // farewell()은 요구사항이 아니므로 다른 게 "정상"이다 — 같아지면 오히려
    // 설계가 바뀌었다는 신호로 읽어야 한다.
    assert(concrete.farewell() != asProtocol.farewell())
}

class Animal {
    @inline(never) func speak() -> Int { 1 }
}
class Dog: Animal {                       // ← 이 블록의 유무가 변수 ①
    @inline(never) override func speak() -> Int { 2 }
}
@inline(never) func total(_ a: Animal, _ n: Int) -> Int {
    var s = 0
    for _ in 0..<n { s += a.speak() }     // ← 이 호출을 관찰한다
    return s
}
let arg = CommandLine.arguments.count
print(total(arg > 99 ? Dog() : Animal(), 3))

조건                                class_method   function_ref(speak)
──────────────────────────────────────────────────────────────────
서브클래스 있음 · -Onone                    1              0
서브클래스 있음 · -O                        1              0
서브클래스 있음 · -O -wmo                   1              0     ← 지워지지 않는다
서브클래스 없음 · -O                        1              0     ← WMO 없이는 안 된다
서브클래스 없음 · -O -wmo                   0              2     ← 여기서 바뀐다
final 클래스   · -O                        0              —     ← WMO 없이도 즉시

sil shared [noinline] @$s7e_final5totalySiAA6AnimalC_SitFTf4dn_n : (Int) -> Int {
bb1:
  …
  // function_ref specialized Animal.speak()
  %16 = function_ref @$s7e_final6AnimalC5speakSiyFTf4d_n : $@convention(thin) () -> Int
  %17 = apply %16() : $@convention(thin) () -> Int
  br bb3(…)                     ← 루프 진입 전이다

// ❌ 오버라이드 가능성이 열려 있으면, WMO가 꺼진 빌드에서는 vtable 호출이 남는다.
class ImageDecoder {
    func decode(_ data: Data) -> UIImage? { nil }
}

// ✅ 서브클래싱할 계획이 없다면 final로 명시 — 빌드 설정과 무관하게 직접 호출이 보장된다.
final class ImageDecoder2 {
    func decode(_ data: Data) -> UIImage? { nil }
}

// 이 파일 밖에서 서브클래싱할 계획이 없는 기반 클래스는, 메서드를 fileprivate으로
// 좁히면 컴파일러가 "이 파일만 보면" 오버라이드 후보가 없다는 걸 증명할 수 있다.
class RequestSigner {
    fileprivate func sign(_ payload: Data) -> Data { payload }   // 이 파일 밖 서브클래스는 못 건드림
    func send(_ payload: Data) { _ = sign(payload) }             // 내부에서만 호출
}

class Bird { func fly() {} }
class Swimmer { func swim() {} }
class Duck: Bird, Swimmer {}

multi.swift:3:19: error: multiple inheritance from classes 'Bird' and 'Swimmer'
                 [#MultipleInheritance]

protocol Flying  { func fly() }
protocol Swimming { func swim() }
protocol Quacking { func quack() }
protocol Walking  { func walk() }
struct Duck: Flying, Swimming, Quacking, Walking {
    func fly() {}; func swim() {}; func quack() {}; func walk() {}
}
print("프로토콜 4개 채택 OK:", Duck.self)

$ ./mo
프로토콜 4개 채택 OK: Duck

$ ./many          # 프로토콜 20개를 채택한 struct
프로토콜 20개 채택 OK

// ❌ 상속으로 표현하면 "날 수 있고 헤엄치는 동물"을 위한 다중 상속 자체가 불가능하다.
class Animal {}
class Bird: Animal { func fly() { print("날다") } }
// class Duck: Bird, Swimmer {}   // Swift는 클래스 다중 상속을 애초에 지원하지 않는다

// ✅ 능력을 프로토콜로 쪼개면 struct도, 여러 능력의 조합도 자유롭게 표현된다.
protocol Flying { func fly() }
protocol Swimming { func swim() }

struct Duck: Flying, Swimming {
    func fly() { print("날다") }
    func swim() { print("헤엄치다") }
}

// 여러 능력을 동시에 요구하는 함수도 합성 타입으로 자연스럽게 표현된다.
func showOff(_ animal: some Flying & Swimming) {
    animal.fly()
    animal.swim()
}

struct Order {
    let id: String
    let total: Decimal
}

protocol Summarizable {
    var summary: String { get }
}

// Order의 원래 정의를 건드리지 않고도 준수를 "나중에" 붙일 수 있다.
extension Order: Summarizable {
    var summary: String { "\(id) — \(total)" }
}

// 여기서는 내가 정의한 프로토콜에 내가 정의한 타입을 준수시키는 것이라
// @retroactive 경고 대상이 아니다(외부 타입 x 외부 프로토콜 조합만 해당 — 08장 참고).

// pure.swift
class Plain { func ping() -> Int { 1 } }
let p = Plain()
print(p.ping())

// dyn.swift
import Foundation
class Dyn: NSObject { @objc dynamic func ping() -> Int { 1 } }
let d = Dyn()
print(d.ping())

pure.swift → _objc_msgSend 심볼 0개,  바이너리 51,864 bytes
dyn.swift  → _objc_msgSend 심볼 2개,  바이너리 52,792 bytes

$ nm bin_dyn | grep objc_msgSend
                 U _objc_msgSend
                 U _objc_msgSendSuper2

import Foundation

// ❌ 클래스 전체에 @objcMembers를 걸면 모든 멤버가 objc_msgSend 경로를 타게 되어
//    devirtualization/인라인/제네릭 특수화를 전부 포기하게 된다.
@objcMembers
class BadProfile: NSObject {
    var name: String = ""       // KVO 대상이 아닌데도 덩달아 dynamic이 되어버림
    var isOnline: Bool = false
}

// ✅ 실제로 KVO로 관찰해야 하는 프로퍼티만 @objc dynamic으로 최소화한다.
class Profile: NSObject {
    @objc dynamic var isOnline: Bool = false   // KVO 관찰 대상 — objc_msgSend 경유
    var name: String = ""                        // 순수 Swift 프로퍼티 — 직접 접근
}

let profile = Profile()
let observation = profile.observe(\.isOnline, options: [.new]) { _, change in
    print("온라인 상태 변경:", change.newValue ?? false)
}

import Foundation
import ObjectiveC

class ViewController: NSObject {
    // dynamic이 없으면 이 메서드에 대한 다른 곳의 호출이 컴파일러에 의해
    // 직접 호출/인라인으로 굳어버릴 수 있어, 아래 스위즐링이 일부 호출 지점에서 무시된다.
    @objc dynamic func viewDidAppear() {
        print("원본 viewDidAppear")
    }

    @objc dynamic func swizzled_viewDidAppear() {
        print("계측 코드 실행")          // 예: 화면 노출 로깅
        swizzled_viewDidAppear()          // 스위즐링 후에는 실제로 원본을 가리킨다(IMP가 교환됐으므로)
    }
}

func swizzleViewDidAppear() {
    guard
        let original = class_getInstanceMethod(ViewController.self, #selector(ViewController.viewDidAppear)),
        let swizzled = class_getInstanceMethod(ViewController.self, #selector(ViewController.swizzled_viewDidAppear))
    else { return }
    method_exchangeImplementations(original, swizzled)   // IMP를 서로 맞바꾼다
}