7.0.1：嵌套值类型在 Task.detached 默认后台栈中解码溢出（Debug / Release，附独立复现）

[chen0807130004]

问题描述

将自动模型解析放到 Swift Concurrency 后台执行时，嵌套值类型可以触发线程栈溢出。已经将业务 App、网络、AES 解密和 UI 全部移除，整理成只依赖 Foundation / Darwin / SmartCodable 的 SwiftPM 可执行程序。

同一份模型、同一份完整 JSON、同一默认后台线程栈下：

• SmartCodable 7.0.1：Debug / Release 均崩溃。
• Foundation JSONDecoder：Debug / Release 均完成连续 10 次解析。

这里报告的是栈空间问题，不是已确认的数据竞争或内存泄漏；暂不预判是库内部泛型临时值、Swift 自动生成的 Decodable，还是两者共同造成。想请教是否属于已知限制，以及是否有保留自动解析的解决方向。

环境

• Apple M5 / arm64
• macOS 27.0.1（26A434）
• Xcode 27.1（27A9275）
• Apple Swift 6.4（swiftlang-6.4.0.34.1），本复现包显式使用 Swift 5 language mode
• SmartCodable 精确固定 7.0.1
• 对应 revision：bc1522f6b635128ea992331867fe65f231492dc0
• 实测后台线程 pthread_get_stacksize_np：536576 bytes
• MemoryLayout<Big>.size：24584 bytes

验证范围说明：下面的 7.0.1 结果来自独立 macOS 程序。业务 iOS App 中也有类似问题，但不把旧版本的 iOS 结果当成 7.0.1 已完成真机验证的证据。

最小复现

新建目录，放置以下两个文件。全部模型使用自动合成 Codable，没有手写 init(from:)，也没有引用环。

Package.swift

// swift-tools-version: 5.9
import PackageDescription

let package = Package(
    name: "Probe",
    platforms: [.macOS(.v13)],
    dependencies: [
        .package(url: "https://github.com/iAmMccc/SmartCodable.git", exact: "7.0.1")
    ],
    targets: [
        .executableTarget(name: "Probe", dependencies: ["SmartCodable"])
    ],
    swiftLanguageVersions: [.v5]
)

Sources/Probe/main.swift

import Foundation
import Darwin
import SmartCodable

struct Leaf: SmartCodableX {
    var a = ""; var b = ""; var c = ""; var d = ""; var e = ""; var f = ""; var g = ""; var h = ""
}
struct Node: SmartCodableX {
    var a = Leaf(); var b = Leaf(); var c = Leaf(); var d = Leaf(); var e = Leaf(); var f = Leaf(); var g = Leaf(); var h = Leaf()
}
struct Branch: SmartCodableX {
    var a = Node(); var b = Node(); var c = Node(); var d = Node(); var e = Node(); var f = Node(); var g = Node(); var h = Node()
}
struct Big: SmartCodableX {
    var a: Branch?; var b: Branch?; var c: Branch?; var list: [Branch] = []
}
struct Shell<T: SmartCodableX>: SmartCodableX {
    var code = 0; var message = ""; var data: T?
}
@main struct Probe {
    static func main() async {
        var value = Big()
        value.a = Branch(); value.b = Branch(); value.c = Branch(); value.list = [Branch()]
        var shell = Shell<Big>()
        shell.data = value
        let data = try! JSONEncoder().encode(shell)
        print("START bytes=\(MemoryLayout<Big>.size)");fflush(stdout)
        await Task.detached {
            workerInfo()
            for _ in 0..<10 {
                let result = parse(data)
                withExtendedLifetime(result) {}
            }
            print("PASSED");fflush(stdout)
        }.value
    }
    static func workerInfo() {
        print("WORKER main=\(Thread.isMainThread) stack=\(pthread_get_stacksize_np(pthread_self()))")
        fflush(stdout)
    }
    @inline(never) static func parse(_ data: Data) -> Any {
        if ProcessInfo.processInfo.arguments.contains("--native") {
            return parseNative(data)
        }
        return parseSDK(data)
    }
    @inline(never) static func parseNative(_ data: Data) -> Any {
        try! JSONDecoder().decode(Shell<Big>.self, from: data)
    }
    @inline(never) static func parseSDK(_ data: Data) -> Any {
        Shell<Big>.deserialize(from: data)!
    }
}

JSONEncoder 在进入后台任务之前生成完整 JSON；原生与 SmartCodable 读取的是同一份 Data。后台仅有一个 Task.detached，内部连续解码，不启动多个并发解析，也不调整线程栈。

两个解析入口分别放在 @inline(never) 函数中，避免把两套解析结果的大值临时对象堆在同一个分支函数栈帧上。返回 Any 仅用于保持结果存活；后台不做重新编码校验。

运行步骤

在上述 Package.swift 所在目录，逐条运行：

swift build -c debug
.build/debug/Probe
.build/debug/Probe --native

swift build -c release
.build/release/Probe
.build/release/Probe --native

不需要连接后端、登录 App 或准备业务数据。若从 Xcode 调试，需要移除已有异常断点对执行流程的干扰；命令行即可观察正常退出或信号退出。

预期结果

后台正常完成解析并打印 PASSED。如果这类值类型布局超出库的支持边界，希望有明确说明，而不是依赖线程碰巧有更大的栈。

实际结果

构建	SmartCodable 7.0.1	原生 JSONDecoder
Debug	SIGBUS / Stack Guard，退出码 138	完成 10 次，退出码 0
Release	SIGBUS / Stack Guard，退出码 138	完成 10 次，退出码 0

SmartCodable 两种构建都只输出：

START bytes=24584
WORKER main=false stack=536576

原生两种构建输出：

START bytes=24584
WORKER main=false stack=536576
PASSED

关键崩溃栈

Debug 的代表性调用链如下（完整系统日志显示访问了 Stack Guard 区域）：

EXC_BAD_ACCESS / SIGBUS
KERN_PROTECTION_FAILURE
___chkstk_darwin
Big.init(from:)
protocol witness for Decodable.init(from:) in conformance Big
dispatch thunk of Decodable.init(from:)
JSONDecoderImpl.unwrap<A>(as:)
JSONDecoderImpl.KeyedContainer._decodeDecodableIfPresentCore<A>(_:forKey:)
JSONDecoderImpl.KeyedContainer._decodeDecodableIfPresent<A>(_:forKey:)
JSONDecoderImpl.KeyedContainer.decodeIfPresent<A>(_:forKey:)
KeyedDecodingContainer.decodeIfPresent<A>(_:forKey:)
Shell.init(from:)
JSONDecoderImpl.unwrap<A>(as:)
SmartJSONDecoder.smartDecode<A>(_:from:)
_deserializeDict<A>(input:type:options:)
SmartDecodable.deserialize(from:designatedPath:options:)
Probe.parseSDK(_:)

Release 的最顶层停在 Swift 类型元数据解析附近，但系统日志同样指向 Stack Guard；其下仍经过 specialized Big.init(from:)、JSONDecoderImpl.unwrap<A>(as:) 与泛型 keyed decode 链路。没有把顶层元数据函数直接判定为根因。

已排除 / 尚未确认

• 已排除业务网络、解密、SwiftUI 生命周期和项目默认 MainActor 设置；独立包未启用项目的默认 MainActor 隔离。
• 没有循环类型或自定义解码递归，只是有限层级的内联 struct。
• 输入通过同一模型编码生成，不依赖缺字段容错来构造复现。
• 未使用自定义大栈线程、未切回主线程解码、未逐模型手写解析。
• 尚未证明是缓存导致。注意到 7.0.1 已重构为独立 DecodingSnapshot，但本例仍可复现，不能将上下文隔离修复等同于栈占用修复。
• 理解 请问是否支持actor？ #123 讨论的是 actor / Task 使用的并发安全，并不等同于所有值类型布局都能在有限线程栈中完成。

想请教

1. 7.0.1 在上述工具链上是否能复现？其他 Swift / Xcode 版本是否存在差异？
2. 泛型解析链中 T / T? 的中间值，是否可能与自动生成的 init(from:) 叠加出较高栈占用？
3. 是否可以在统一解析层减少这类临时值或调用链的栈压力，同时保持默认值、字段映射、属性包装器及自动模型写法？
4. 如果主要受 Swift 编译器或大值类型布局限制，是否建议提供支持边界或规避说明？

谢谢，愿意继续协助验证修复分支。
SmartCodable-7.0.1-stack-overflow-repro.zip