02 · 초기화와 생명주기

class Vehicle {
    var wheels: Int
    init(wheels: Int) { self.wheels = wheels }
}
class Car: Vehicle {
    var brand: String
    init(brand b: String) {
        super.init(wheels: 4)   // ❌ brand를 아직 초기화하지 않은 채 위로 위임
        self.brand = b
    }
}
// 실제 컴파일 에러 (swiftc 전체 빌드, DiagnosticsSIL.def의
// ivar_not_initialized_at_superinit):
// error: property 'self.brand' not initialized at super.init call

class Vehicle {
    var wheels: Int
    init() { self.wheels = 4 }
}
class Car: Vehicle {
    var brand: String
    init(brand: String) {
        self.brand = brand
        self.wheels = 6        // ❌ 아직 super.init을 안 불렀는데 상속 프로퍼티를 건드림
        super.init()
    }
}
// 실제 컴파일 에러 (self_use_before_fully_init):
// error: 'self' used in property access 'wheels' before 'super.init' call

class Car {
    var brand: String
    init(brand: String) { self.brand = brand }
    convenience init() {
        self.brand = "Unknown"      // ❌ self.init으로 위임하기 전에 프로퍼티 대입
        self.init(brand: "Tesla")
    }
}
// 실제 컴파일 에러 (self_before_selfinit_value_type):
// error: 'self' used before 'self.init' call or assignment to 'self'

// (a) 아직 저장 프로퍼티가 다 안 채워졌는데 인스턴스 메서드 호출
class Car {
    var brand: String
    init(brand: String) {
        self.describe()          // ❌ brand 초기화 전에 메서드 호출
        self.brand = brand
    }
    func describe() { print("brand =", brand) }
}
// error: 'self' used in method call 'describe' before all stored
//        properties are initialized

// (b) super.init 위임 전에 self를 값으로 참조
class Vehicle2 {
    var wheels: Int
    init(wheels: Int) { self.wheels = wheels }
}
class Car2: Vehicle2 {
    var brand: String
    init(brand: String) {
        print(self)               // ❌ 위로 위임하기 전에 self를 값으로 씀
        self.brand = brand
        super.init(wheels: 4)
    }
}
// error: 'self' used before 'super.init' call

swiftc -typecheck rule1.swift
# 종료 코드 0 — 에러 없음 (SIL이 아직 안 만들어졌으니 DI 패스도 안 돎)

swiftc rule1.swift -o /tmp/rule1
# error: property 'self.brand' not initialized at super.init call

class Car: Vehicle {
    var brand: String
    init(brand: String) {
        self.brand = brand       // ✅ 먼저 내 프로퍼티부터 (규칙1)
        super.init(wheels: 4)    // ✅ 그 다음 위로 위임 (규칙2)
    }
}

class Car {
    var brand: String
    init(brand: String) { self.brand = brand }
}
extension Car {
    init() {                  // ❌ extension에서 designated init 선언 시도
        self.brand = "Unknown"
    }
}
// 실제 컴파일 에러:
// error: designated initializer cannot be declared in an extension of
//        'Car'; did you mean this to be a convenience initializer?

class Car {
    var brand: String
    init(brand: String) { self.brand = brand }
}
extension Car {
    var year: Int = 2024      // ❌ 저장 프로퍼티를 extension에 추가하려는 시도
}
// 실제 컴파일 에러:
// error: extensions must not contain stored properties

class Empty {}
extension Empty {
    init(dummy: Int) {         // ❌ 프로퍼티가 없어도 여전히 에러
        print("dummy init", dummy)
    }
}
// error: designated initializer cannot be declared in an extension of
//        'Empty'; did you mean this to be a convenience initializer?

struct PointB {
    var x: Int
    var y: Int
}
extension PointB {
    init(diagonal: Int) { self.x = diagonal; self.y = diagonal }  // ✅ 직접 대입
}
let b1 = PointB(x: 1, y: 2)      // memberwise init 여전히 사용 가능
let b2 = PointB(diagonal: 5)     // extension init도 함께 사용 가능
print(b1, b2)
// 실행 결과: PointB(x: 1, y: 2) PointB(x: 5, y: 5)

// Car.swift — 프로덕션 designated init만
final class Car {
    let brand: String
    let year: Int
    init(brand: String, year: Int) {
        self.brand = brand
        self.year = year
    }
}

// Car+Preview.swift — SwiftUI 프리뷰 전용 convenience init을 별도 extension으로 분리
#if DEBUG
extension Car {
    convenience init(mock: Bool = true) {
        self.init(brand: "미리보기용", year: 2024)
    }
}
#endif

extension CGPoint {
    init(unitSquareCorner corner: Int) {
        // ❌ self.x = ... 직접 대입은 다른 모듈 타입에선 불가능
        // ✅ 반드시 원본이 제공하는 init에 먼저 위임한다
        self.init(x: CGFloat(corner % 2), y: CGFloat(corner / 2))
    }
}

class Base {
    required init(x: Int) { print(x) }
}
class Sub: Base {
    var y: Int = 0
    init(y: Int) { self.y = y; super.init(x: 0) }
    // required init(x:)를 재구현하지 않음
}
// 실제 컴파일 에러:
// error: 'required' initializer 'init(x:)' must be provided by
//        subclass of 'Base'
// note: 'required' initializer is declared in superclass here

class Base {
    required init(x: Int) { print("Base", x) }
}
class Sub: Base {
    // 새 저장 프로퍼티도, 새 designated init도 없음 → Rule 1로 자동 상속
}
let s = Sub(x: 10)
// 실행 결과: Base 10  ← 아무것도 안 썼는데 required init이 그대로 동작

final class NetworkClient {
    let session: URLSession
    let baseURL: URL
    init(session: URLSession, baseURL: URL) {   // designated — 테스트에서 목(mock) 세션 주입
        self.session = session
        self.baseURL = baseURL
    }
    convenience init(baseURL: URL) {            // convenience — 실무 기본값
        self.init(session: .shared, baseURL: baseURL)
    }
}

final class CustomView: UIView {
    let titleLabel = UILabel()
    override init(frame: CGRect) {
        super.init(frame: frame)
        setup()
    }
    required init?(coder: NSCoder) {   // ✅ 스토리보드/XIB 경로도 반드시 구현
        super.init(coder: coder)
        setup()
    }
    private func setup() { addSubview(titleLabel) }
}

struct Rating {
    let stars: Int
    init?(stars: Int) {
        guard (0...5).contains(stars) else { return nil }  // ✅ 크래시 대신 nil
        self.stars = stars
    }
}
let ok = Rating(stars: 4)     // Optional(Rating(stars: 4))
let bad = Rating(stars: 9)    // nil — 크래시 없이 실패를 표현

// one-time initialization token for shared
sil_global private @$s...C6shared_Wz : $Builtin.Word

// one-time initialization function for shared
sil private [global_init_once_fn] @$s...C6shared_WZ
    : $@convention(c) (Builtin.RawPointer) -> () {
bb0(%0 : $Builtin.RawPointer):
  alloc_global @$s...C6sharedACvpZ
  %2 = global_addr @$s...C6sharedACvpZ : $*Service
  %3 = metatype $@thick Service.Type
  %4 = function_ref @$s...init...
  %5 = apply %4(%3) : $@convention(method) (@thick Service.Type) -> @owned Service
  store %5 to %2
  return
}

// Service.shared.unsafeMutableAddressor
sil hidden [global_init] @$s...C6sharedACvau : $@convention(thin) () -> Builtin.RawPointer {
bb0:
  %0 = global_addr @$s...C6shared_Wz : $*Builtin.Word
  %1 = address_to_pointer %0 to $Builtin.RawPointer
  %2 = function_ref @$s...C6shared_WZ
  %3 = builtin "once"(%1, %2) : $Builtin.SILToken   // ← swift_once 호출이 바로 이 줄
  %4 = global_addr @$s...C6sharedACvpZ : $*Service depends_on %3
  return
}

sil hidden [lazy_getter] [noinline] @$s...C5valueSivg
    : $@convention(method) (@guaranteed Box) -> Int {
bb0(%0 : $Box):
  %2 = ref_element_addr %0, #Box.$__lazy_storage_$_value
  %3 = begin_access [read] [dynamic] %2
  %4 = load %3
  end_access %3
  switch_enum %4, case #Optional.some!enumelt: bb1, case #Optional.none!enumelt: bb2

bb1(%7 : $Int):
  br bb3(%7)          // 이미 값이 있으면 그냥 반환

bb2:                   // 값이 없으면(nil) — 락 없이 곧바로 계산
  %9 = function_ref @$s...closure...
  %10 = apply %9() : $@convention(thin) () -> Int
  %11 = enum $Optional<Int>, #Optional.some!enumelt, %10
  %12 = ref_element_addr %0, #Box.$__lazy_storage_$_value
  %13 = begin_access [modify] [dynamic] %12
  store %11 to %13     // 계산 결과를 저장 — 두 스레드가 동시에 여기 도달하면 경쟁한다
  end_access %13
  br bb3(%10)

bb3(%17 : $Int):
  return %17
}

import Dispatch

final class Box {
    lazy var value: Int = {
        print("C", terminator: "")   // 계산될 때마다 한 글자씩 찍는다
        return 42
    }()
}

let box = Box()
DispatchQueue.concurrentPerform(iterations: 50) { _ in
    _ = box.value
}
print()
// 실행 결과 (같은 코드를 3번 반복, 매번 다르다):
//   CCCCCCCCCCCCCC   (14번 계산됨)
//   CCCCCCCCCCC      (11번 계산됨)
//   CCCCCCCCCCC      (11번 계산됨)
// 50번 다 캐시가 안 먹은 것도, 그렇다고 매번 50번인 것도 아니다 — 순수한 레이스 컨디션이다.

import Dispatch

enum Holder {
    static let value: Int = {
        print("C", terminator: "")
        return 42
    }()
}
DispatchQueue.concurrentPerform(iterations: 50) { _ in _ = Holder.value }
print()
// 실행 결과: 5회 반복 모두 "C" 딱 한 번만 찍힌다

import Dispatch

enum Counter {
    static var count = 0   // 최초 초기화(0)는 swift_once로 안전
}
DispatchQueue.concurrentPerform(iterations: 10_000) { _ in
    Counter.count += 1     // read-modify-write, 원자적이지 않다
}
print("최종 count =", Counter.count, "(기대값 10000)")
// 실행 결과 (3회 반복):
//   최종 count = 2607 (기대값 10000)
//   최종 count = 2551 (기대값 10000)
//   최종 count = 2492 (기대값 10000)
// 초기화 자체(count = 0)는 정확히 1번 됐지만, += 1이 서로의 결과를 덮어쓰며
// 절반 넘게 유실됐다 — 이게 "atomic ≠ thread-safe"의 실제 증거다.

final class ImageDownloader {
    static let shared = ImageDownloader()   // ✅ swift_once가 알아서 스레드 세이프하게 처리
    private init() {}
}
// ❌ 이렇게 굳이 다시 만들 필요 없다 — 컴파일러가 이미 해준다
// private static var _shared: ImageDownloader?
// private static let lock = NSLock()
// static var shared: ImageDownloader { lock.lock(); defer { lock.unlock() }; ... }

// ❌ 백그라운드 큐에서도 접근 가능한 인스턴스에 lazy var를 두면 레이스 위험
final class ReportBuilder {
    lazy var formatter = makeExpensiveFormatter()
}

// ✅ actor로 격리 — 한 번에 한 태스크만 접근 가능해 레이스 자체가 없다
actor ReportBuilder2 {
    private var cached: DateFormatter?
    var formatter: DateFormatter {
        if let f = cached { return f }
        let f = makeExpensiveFormatter()
        cached = f
        return f
    }
}
func makeExpensiveFormatter() -> DateFormatter { DateFormatter() }

actor CounterActor {
    private(set) var count = 0
    func increment() { count += 1 }
}
// Counter.count += 1을 코드 곳곳에 흩뿌리는 대신,
// 반드시 counterActor.increment() 호출을 통해서만 값이 바뀌게 한다

class Animal {
    let name: String
    init(name: String) { self.name = name }
    deinit { print("Animal(\(name)) deinit") }
}
class Dog: Animal {
    let breed: String
    init(name: String, breed: String) {
        self.breed = breed
        super.init(name: name)
    }
    deinit { print("Dog(\(breed)) deinit") }
}
var d: Dog? = Dog(name: "바둑이", breed: "진돗개")
d = nil
// 실행 결과:
// Dog(진돗개) deinit
// Animal(바둑이) deinit

final class Zombie {
    let tag: Int
    init(tag: Int) { self.tag = tag }
    deinit {
        print("deinit 시작, tag=\(tag)")
        // ❌ deinit 안에서 self를 전역에 몰래 남겨 "부활"을 시도
        Graveyard.leaked = Unmanaged.passUnretained(self).toOpaque()
        print("deinit 끝 — 이 시점부터 메모리는 회수 대상")
    }
}
enum Graveyard { static var leaked: UnsafeMutableRawPointer? }

do {
    let z = Zombie(tag: 7)
    _ = z
}   // 스코프 종료 — 여기서 deinit이 이미 실행됨

if let ptr = Graveyard.leaked {
    let revived = Unmanaged<Zombie>.fromOpaque(ptr).takeUnretainedValue()
    print("부활 시도: tag =", revived.tag)   // 정의되지 않은 동작
}
// ── 같은 코드, 같은 기계(Swift 6.2.1 / arm64 / macOS 26). 빌드만 바꿔 실행한 결과 ──
//
// ① swift zombie.swift          (인터프리터, 5회 반복)
//    → 부활 시도: tag = 0        크래시 없음, 종료 코드 0
//
// ② swiftc zombie.swift         (디버그 빌드)
//    → tag 줄을 출력하지도 못하고 크래시  종료 코드 133 / 139
//
// ③ swiftc -O zombie.swift      (릴리스 빌드, 3회 반복)
//    → 부활 시도: tag = 7        원래 값이 멀쩡히 보인다. 크래시 없음, 종료 코드 0
//
// ③이 가장 위험하다. "돌려봤더니 잘 되던데요"가 나오는 경로이기 때문이다.
// UB는 '반드시 터진다'는 뜻이 아니라 '무엇이든 일어날 수 있다'는 뜻이다 —
// 값이 멀쩡해 보이는 것도 그 '무엇이든'에 포함된다.

final class Ticker {
    var timer: Timer?
    let name: String
    init(name: String) {
        self.name = name
        // ❌ 클로저가 self를 강하게 캡처 + self가 timer를 강하게 들고 있음 → 사이클
        self.timer = Timer.scheduledTimer(withTimeInterval: 0.2, repeats: true) { _ in
            print("\(self.name) tick")
        }
    }
    deinit { print("Ticker(\(name)) deinit 호출됨") }
}

var ticker: Ticker? = Ticker(name: "A")
RunLoop.current.add(ticker!.timer!, forMode: .common)
ticker = nil   // 마지막 강한 참조를 없앴다
RunLoop.current.run(until: Date().addingTimeInterval(1.0))
// 실행 결과: "Ticker(A) deinit 호출됨"이 단 한 번도 안 찍히고
//           "A tick"만 계속 찍힌다 — 사이클 때문에 deinit이 영원히 안 불림

final class Ticker {
    var timer: Timer?
    let name: String
    init(name: String) {
        self.name = name
        // ✅ weak self로 캡처 — 사이클이 끊긴다
        self.timer = Timer.scheduledTimer(withTimeInterval: 0.2, repeats: true) { [weak self] _ in
            guard let self else { return }
            print("\(self.name) tick")
        }
    }
    deinit {
        print("Ticker(\(name)) deinit 호출됨")
        timer?.invalidate()   // ✅ deinit에서도 한 번 더 확실히 무효화
    }
}
var ticker: Ticker? = Ticker(name: "B")
RunLoop.current.add(ticker!.timer!, forMode: .common)
ticker = nil
// 실행 결과: "Ticker(B) deinit 호출됨"이 ticker = nil 하는 즉시 찍힌다

final class FeedViewController {
    private var token: NSObjectProtocol?
    init() {
        token = NotificationCenter.default.addObserver(
            forName: .someEvent, object: nil, queue: .main
        ) { _ in /* ... */ }
    }
    deinit {
        if let token { NotificationCenter.default.removeObserver(token) }
    }
}

final class Uploader {
    var lastResult: String?
    deinit {
        // ❌ deinit에서 self를 캡처하는 Task를 새로 던지면
        //    실행 시점엔 self가 이미 해제된 메모리일 수 있다
        // Task { await self.reportDeallocation() }

        // ✅ self가 아니라 '지금 필요한 값만' 미리 꺼내서 넘긴다
        let snapshot = lastResult
        Task.detached { AnalyticsQueue.log(snapshot) }
    }
}
enum AnalyticsQueue { static func log(_ v: String?) {} }