04 · 에러 처리

// 원본
struct E: Error {}
@inline(never) func mayThrow(_ x: Int) throws -> Int {
    if x < 0 { throw E() }
    return x * 2
}
@inline(never) func caller(_ x: Int) -> Int {
    do { return try mayThrow(x) } catch { return -1 }
}

// swiftc -O -emit-assembly 결과 중 caller 본체 (주석은 설명용으로 덧붙임)
_$s8swifterr6calleryS2iF:
        sub     sp, sp, #48
        stp     x22, x21, [sp, #16]     // x21은 callee-saved라 호출자가 보존해준다
        stp     x29, x30, [sp, #32]
        add     x29, sp, #32
        mov     x21, #0                 // ① 호출 전 에러 레지스터를 0으로 초기화
        bl      _$s8swifterr8mayThrowyS2iKF
        cbz     x21, LBB2_2             // ② 0이면 '에러 없음' — 정상 경로로 분기
        mov     x0, x21                 //    0이 아니면 x21이 곧 에러 객체 포인터
        bl      _swift_errorRelease     //    catch에서 에러를 소비하고 해제
        mov     x0, #-1
LBB2_2:
        ldp     x29, x30, [sp, #32]
        ldp     x22, x21, [sp, #16]
        add     sp, sp, #48
        ret

// error_test.swift
enum E: Error { case bad }
func maybeThrow(_ b: Bool) throws -> Int {
    if b { throw E.bad }
    return 42
}
func caller(_ b: Bool) -> Int {
    (try? maybeThrow(b)) ?? -1
}

swiftc -O -emit-assembly error_test.swift -o error_test.s
grep -A6 "maybeThrow" error_test.s   # x21(ARM64)/r12(x86-64) 관련 mov·tst·b.ne 확인

swiftc -emit-sil error_test.swift | grep -B2 -A2 "error :"
# throws 함수 시그니처에 @error 파라미터가 별도로 붙는 것을 확인할 수 있다

// ❌ 실패를 옵셔널로 뭉개면 '왜' 실패했는지가 사라진다
func parseConfig(_ s: String) -> Config? { ... }

// ✅ 실패 사유를 타입으로 드러낸다 — 성능 차이는 무시 가능한 수준
enum ConfigError: Error { case emptyInput, invalidFormat(line: Int) }
func parseConfig(_ s: String) throws -> Config {
    guard !s.isEmpty else { throw ConfigError.emptyInput }
    // ...
    return Config()
}

// ❌ 루프 내부에서 매번 throws 호출 + try 분기
func sumBad(_ items: [String]) throws -> Int {
    var total = 0
    for s in items {
        total += try Int(validating: s)   // 매 반복마다 에러 레지스터 체크
    }
    return total
}

// ✅ 변환은 루프 밖에서 한 번에 끝내고, 루프 내부는 non-throwing
func sumGood(_ items: [String]) throws -> Int {
    let numbers = try items.map { try Int(validating: $0) }  // 경계는 여기 한 번
    return numbers.reduce(0, +)                                // 루프는 non-throwing
}

func maybeInt() throws -> Int? { return nil }
let x = try? maybeInt()
print(type(of: x))
// Swift 5.0+: Optional<Int> (즉 Int?)
// Swift 4 이하였다면: Optional<Optional<Int>> (Int??)

enum CacheError: Error { case corrupted, missing }
func loadCache() throws -> Data { throw CacheError.missing }

// ❌ 왜 실패했는지 영영 알 수 없다
let cached = try? loadCache()

// ✅ 원인을 알아야 한다면 do-catch로 명시적으로 처리
func loadCacheLogged() -> Data? {
    do {
        return try loadCache()
    } catch {
        print("캐시 로드 실패: \(error)")   // 원인을 남긴다
        return nil
    }
}

// ✅ 정당한 사례: 번들에 포함된, 빌드 시점에 항상 유효함이 보장되는 리소스
let config = try! JSONDecoder().decode(
    AppConfig.self,
    from: Bundle.main.data(forResource: "default_config", withExtension: "json")!
)
// 이 파일이 없거나 깨졌다면 그건 빌드 파이프라인 버그이므로,
// 조용히 넘어가기보다 즉시 크래시로 드러나는 게 맞다.

// ❌ 네트워크 응답처럼 외부 요인으로 실패할 수 있는 곳에 try!는 금물
let user = try! JSONDecoder().decode(User.self, from: networkResponse)

enum StatisticsError: Error { case noRatings, invalidRating(Int) }

func summarize(_ ratings: [Int]) throws(StatisticsError) {
    guard !ratings.isEmpty else { throw .noRatings }   // 짧은 형 throw 가능
}

do throws(StatisticsError) {
    try summarize([])
} catch {
    switch error {                 // error가 any Error가 아니라 StatisticsError로 추론됨
    case .noRatings: print("no ratings")
    case .invalidRating(let r): print("invalid: \(r)")
    }
}

swiftc -emit-sil -O typed_throws.swift | grep -A3 "function_ref"
// any Error 버전은 existential 박싱/언박싱 관련 런타임 콜이 섞여 나오고,
// 콘크리트 typed throws 버전은 그 부분이 사라진 SIL을 대조 관찰할 수 있다

enum JSONParseError: Error {
    case unexpectedToken(String)
    case unterminatedString
}

// internal 파서라 앞으로도 이 두 가지 실패 케이스로 충분하다는 확신이 있다
func parseToken(_ s: Substring) throws(JSONParseError) -> Token {
    guard let first = s.first else { throw .unterminatedString }
    // ...
    return Token(raw: String(first))
}

// ❌ 라이브러리 v1에서 이렇게 박아버리면
public func fetch(_ url: URL) throws(NetworkError) -> Data { ... }
// v2에서 DiskCacheError 같은 새 실패 원인을 추가하려면
// any Error로 넓혀야 하고, 그 순간 호출자의
// switch error { case .timeout: ... } 코드가 전부 깨진다

// ✅ 외부 공개 API는 무타입으로 유연성을 남긴다
public func fetch(_ url: URL) throws -> Data { ... }

enum NetworkError: Error { case timeout }

func fetch() -> Result<Data, NetworkError> { .failure(.timeout) }

// Result → throws
func fetchOrThrow() throws -> Data { try fetch().get() }

// throws → Result
func wrap() -> Result<Data, Error> {
    Result(catching: { try fetchOrThrow() })
}

enum ImageError: Error { case notFound, decodeFailed }

// throws로는 표현 불가 — 완료 시점이 미래이므로 값으로 들고 있어야 한다
func loadImage(url: URL, completion: @escaping (Result<UIImage, ImageError>) -> Void) {
    DispatchQueue.global().async {
        guard let data = try? Data(contentsOf: url) else {
            completion(.failure(.notFound)); return
        }
        guard let image = UIImage(data: data) else {
            completion(.failure(.decodeFailed)); return
        }
        completion(.success(image))
    }
}

// ❌ 굳이 Result로 감싸면 매번 switch로 꺼내야 해서 번거롭다
func parseBad(_ s: String) -> Result<Int, ParseError> { ... }
switch parseBad("42") {
case .success(let n): print(n)
case .failure(let e): print(e)
}

// ✅ 동기 로직은 throws가 더 간결하다
func parseGood(_ s: String) throws -> Int { ... }
do { print(try parseGood("42")) } catch { print(error) }

protocol CustomNSError: Error {
    static var errorDomain: String { get }   // static! (초안과 다른 부분)
    var errorCode: Int { get }
    var errorUserInfo: [String: Any] { get }
}

protocol LocalizedError: Error {
    var errorDescription: String? { get }
    var failureReason: String? { get }
    var recoverySuggestion: String? { get }
    var helpAnchor: String? { get }
}

enum MyError: Error { case badInput }

do { throw MyError.badInput }
catch {
    let ns = error as NSError
    print(ns.domain)   // 기본값: 모듈명.타입명 형태의 mangled 문자열 (환경에 따라 실제 출력 확인 권장)
    print(ns.code)     // enum case의 순번(0부터)
}

enum MyError2: Error, CustomNSError, LocalizedError {
    case badInput
    static var errorDomain: String { "com.example.MyError2" }
    var errorCode: Int { 42 }
    var errorUserInfo: [String: Any] { [:] }
    var errorDescription: String? { "잘못된 입력입니다" }
}

do { throw MyError2.badInput }
catch {
    let ns = error as NSError
    print(ns.domain, ns.code)               // com.example.MyError2 42
    print(ns.localizedDescription)          // 잘못된 입력입니다 (errorDescription이 반영됨)
}

enum UploadError: Error, CustomNSError {
    case fileTooLarge(bytes: Int)
    case serverRejected(statusCode: Int)

    static var errorDomain: String { "com.myapp.UploadError" }   // 안정적인 문자열로 고정

    var errorCode: Int {
        switch self {
        case .fileTooLarge: return 1
        case .serverRejected: return 2
        }
    }

    var errorUserInfo: [String: Any] {
        switch self {
        case .fileTooLarge(let bytes): return ["bytes": bytes]
        case .serverRejected(let code): return ["statusCode": code]
        }
    }
}

enum SignupError: Error, LocalizedError {
    case weakPassword, emailTaken

    var errorDescription: String? {
        switch self {
        case .weakPassword: return "비밀번호가 너무 약합니다."
        case .emailTaken: return "이미 가입된 이메일입니다."
        }
    }
}

// UI 레이어는 항상 이 한 줄만 신뢰하면 된다
func show(_ error: Error, in alert: UIAlertController) {
    alert.message = error.localizedDescription
}

func processFile(filename: String) throws {
    print("시작")
    defer { print("defer 1") }
    defer { print("defer 2") }
    defer { print("defer 3") }
    throw NSError(domain: "test", code: 1)
}

try? processFile(filename: "x")
// 출력: 시작 → defer 3 → defer 2 → defer 1 (throw 경로에서도 전부 실행됨)

func captureTrap() {
    var count = 0
    defer { print("종료 시점의 count: \(count)") }   // 변수 자체를 캡처 — 실행 시점 값을 읽는다
    count = 1
    count = 2
    // 출력: 종료 시점의 count: 2 (defer 등록 시점의 0이 아니다!)
}

import Foundation

func processFile(at url: URL) throws -> [String] {
    let handle = try FileHandle(forReadingFrom: url)
    defer { try? handle.close() }   // 이 함수의 어떤 return/throw 경로로 나가든 반드시 닫힌다

    guard let data = try handle.readToEnd() else { return [] }
    guard let text = String(data: data, encoding: .utf8) else {
        throw NSError(domain: "decode", code: 1)   // 여기서 나가도 handle은 닫힌다
    }
    return text.split(separator: "\n").map(String.init)
}

func processAll(_ urls: [URL]) {
    for url in urls {
        // ❌ "전부 끝나면 한 번 로그를 찍고 싶었다"는 의도라면 이 코드는 틀렸다.
        //    for 블록 스코프에 묶여 매 반복이 끝날 때마다 실행된다.
        defer { print("\(url) 처리 완료") }
        // ... 처리
    }

    // ✅ "전체가 끝나면 한 번만"이 의도라면 defer를 함수 스코프에 둔다
    defer { print("전체 \(urls.count)건 처리 완료") }
}