当前支持基线

最后同步：2026-04-10

这页只保留“今天真实可依赖的能力边界”。
详细切片过程、逐轮回归记录与旧版长文已归档到路线图归档。

真相源

当前基线以这几类文件为准：

实现：crates/*
executable 真运行矩阵：crates/ql-cli/tests/executable_examples.rs
library build / codegen pass 矩阵：crates/ql-cli/tests/codegen.rs、crates/ql-cli/tests/string_codegen.rs、crates/ql-cli/tests/string_compare_codegen.rs
project/workspace graph 矩阵：crates/ql-cli/tests/project_graph.rs
本地 executable smoke 样例约定：忽略的 ramdon_tests/executable_examples/ 与 ramdon_tests/async_program_surface_examples/，是否存在以开发者本地环境为准

如果文档和这些文件不一致，以代码与回归矩阵为准，再回头修正文档。

说明：当前 checkout 不提交 ramdon_tests/。本文若继续出现 ramdon_tests/... 路径，它们表示 crates/ql-cli/tests/executable_examples.rs 约定的本地忽略 smoke 目录或历史样例命名，不应当被当成仓库自带内容。

一页结论

Phase 1 到 Phase 6 地基已经落地：lexer、parser、formatter、diagnostics、HIR、resolve、typeck、MIR、borrowck、LLVM backend、driver、CLI、same-file LSP/query、same-file document symbol outline、以打开 package 为根的保守 workspace/symbol 搜索、FFI header projection 都已进入真实工程主干。
当前活跃主线是保守推进的 Phase 7：async/runtime/task-handle lowering、library/program build surface、Rust interop。
Phase 8 的前三条入口切片已继续向前推进：仓库现已具备最小 qlang.toml manifest graph loader、ql project graph 调试入口、.qi V1 emit 入口 ql project emit-interface、build-side .qi 写出开关 ql build --emit-interface，以及 package-aware ql check 对引用 .qi 的 syntax-aware 加载；当前入口已覆盖 package directory、qlang.toml、包内源码文件路径，以及 workspace-only 根 manifest，而 ql project emit-interface 现在也已支持从 workspace-only 根 manifest 批量写出成员包的默认 .qi，并新增 --changed-only 只跳过 valid 接口、仅重发 missing/invalid/unreadable/stale 的 package/member .qi，以及 --check 用于只校验当前 package/workspace 下的默认 .qi 是否都处于 valid 状态而不写文件；其中 workspace --check 现会汇总全部无效 member interface，逐个报出错误后再给出总数，而不是在首个失败处提前停止。ql project graph 在 package manifest 上现也会展示当前包默认 .qi 的路径与 valid/missing/invalid/stale 状态、引用包 interface 的解析状态；在 workspace-only 根 manifest 上则继续展开每个 member package 的 manifest、包名、默认 .qi 路径/状态、references 与引用 interface 状态，让声明产物是否可被后续 check/LSP 消费可以直接观察。stale 当前表示 manifest 或任一 src/**/*.ql 源文件比现有 .qi 更新，需要重新 emit/sync。ql check 现在会在 package-aware 路径上把 stale dependency interface 视为显式失败，并提示重新执行 --sync-interfaces 或单独 emit-interface；ql check --sync-interfaces 则会在分析前递归同步写出本地引用包默认 .qi，并且只对非 valid 的依赖 interface 执行重发。这个入口同样覆盖 package directory、qlang.toml、包内源码文件路径，以及 workspace-only 根 manifest，减少手工预生成步骤。ql-analysis::analyze_package 现也已把 dependency .qi 的公开符号收进 package 级查询面，并接通 imported dependency symbol 的最小 cross-file hover / definition / declaration / references、use ... 导入路径和平铺 / grouped import 位置里的 dependency package path segment / public symbol completion、dependency enum variant / explicit struct field-label 的最小非导入路径 completion contract，以及 dependency struct member-field / member-method token 的最小 completion contract；这条 receiver truth surface 除了 dependency-typed param、typed closure param、带 dependency type annotation 的 let、dependency struct literal let 结果、dependency method-call result 及其 direct alias、direct dependency field-projection result 及其 direct alias、struct destructuring / match destructuring 派生的 dependency local、inline tuple/array for loop binding、? 解包后的 dependency receiver、block tail result 及其 direct alias、结果稳定收敛到同一个 dependency struct 的 if / match 表达式结果及其 direct alias 之外，也已覆盖不经命名 local 的 direct dependency field-projection / method-call / structured receiver，例如 config.child.value、config.child.get()、config.child?.value、config.child()?.get()、config.child().value、config.child().get()、let current = config.child; current.value、let current = config.child(); let alias = current; alias.value、let current = if flag { config.child() } else { config.child() }; let alias = current; alias.value、let current = match flag { true => config.child(), false => config.child() }; let alias = current; alias.value、let current = { config.child() }; let alias = current; alias.value、let Cfg { child } = config; child.value、match config { Cfg { child } => child.get() }、for current in (config, config) { current.value }、for current in [config.child(), config.child()] { current.get() }、(if ...).value、(match ...).get()、let project = (current: Cfg) => current.value 与 let project = (current: Cfg) => current.get()；同一批 same-file / dependency-backed completion item 现在也会直接向 LSP 暴露 declaration snippet 与类型 markdown 文档，而 dependency member-field / member-method completion 现在也会带上解析后的字段类型 / 返回类型，而不是只剩 declaration 文本。显式 type-namespace 位置上的最小 textDocument/typeDefinition 也已接通，当前覆盖 same-file type use、generic type use、same-file local import type alias use、成功 package analysis 路径下的 dependency import/type-root .qi target、dependency enum variant token 到其 dependency public enum declaration、语法局部可恢复的 dependency struct value/root、dependency struct field token 到其 dependency public field type 的受控跳转，以及 dependency method token 到其 dependency public return type 的受控跳转；当 dependency field/method token 后面直接跟随 ? 时，这条跳转现在也会优先落到 Option[T] / Result[T, E] 解包后的 dependency public type；broken-source / semantic-error 场景下 parse-only 可恢复的 dependency import/type-root / dependency enum variant token / dependency value root / dependency struct field token / dependency method token typeDefinition fallback 现在也都已接通。broken-source / semantic-error 场景下的 import-root / variant / struct-field / dependency struct member-field token / dependency struct member-method token 最小 hover / definition / declaration / references fallback 也已落地，而 dependency value root（除了 parse-only 可恢复的 named local、typed closure param、inline for loop binding 与 self receiver 外，也包括 value-position 的 imported dependency function / const / static root token）现也已补上最小 hover / definition / declaration / references fallback，目标继续收敛到 dependency public struct declaration 与当前文件内仍解析到同一 root binding 的引入/使用位置。保守 workspace/symbol 现在除了当前包源码 modules 与已加载 dependency .qi public symbols 外，也会在已打开文档隶属于某个 workspace member 时继续搜索同一 workspace 的其它 member package 源码 modules；当当前包暂时因为 source diagnostics 无法完整装载时，这条搜索也不再直接退化成“只看当前打开文档”，而是会保留 dependency .qi 与 sibling workspace member source modules 的搜索。真实 dependency build graph 与更广义 cross-file LSP 仍未开放。
dependency for loop receiver 的同一条 identity contract 本轮已继续扩到 structured iterable root：只要 iterable 最终仍稳定收敛到同一个 dependency tuple/array element binding，block / unsafe / if / match 包裹的 root 也会复用同一 receiver，因此 for current in (if flag { (config, config) } else { (config, config) }) { current.value } 与 for current in match flag { true => [config.child(), config.child()], false => [config.child(), config.child()] } { current.get() } 这类路径现在也已进入 dependency member completion / query，以及 broken-source value-root references fallback 合同。
同一条 structured iterable root 现在也已由独立 regression 单独锁住完整 member 合同：for current in (if flag { (config, config) } else { (config, config) }) { current.va } 与 for current in match flag { true => [config.child(), config.child()], false => [config.child(), config.child()] } { current.ge } 这两条 member prefix 现在都已在成功 package analysis 路径与 same-file semantic-error fallback 上稳定只补出 dependency field value / method get，for current in (if flag { (config, config) } else { (config, config) }) { let first = current.value; let second = current.value; ... } 与 for current in match flag { true => [config.child(), config.child()], false => [config.child(), config.child()] } { let first = current.get(); let second = current.get(); ... } 这两条 member token 现在也都已在成功 package analysis 路径与 same-file semantic-error fallback 上由独立 regression 锁住 hover / definition / declaration / references，而 for current in (if flag { (config, config) } else { (config, config) }) { current.leaf.value } 与 for current in match flag { true => [config.child(), config.child()], false => [config.child(), config.child()] } { current.leaf().value } 这两条 member token 的 typeDefinition 现在也都已在成功 package analysis 路径与 same-file semantic-error fallback 上单独锁住到 dependency public Leaf declaration；至此这条 structured iterable root 的 standalone completion / query / member typeDefinition 合同现已闭合。
同一条 structured iterable root 这轮也补上了最小 standalone bindings regression：for current in (if flag { (config, config) } else { (config, config) }) { return current.value } 现已在成功 package analysis 路径上单独锁住 dependency field definition，而 for current in match flag { true => [config.child(), config.child()], false => [config.child(), config.child()] } { current.get() } 这条绑定后的 direct member definition 也已在 broken-source fallback 上由独立 regression 锁住到 dependency public method declaration；这让 structured iterable receiver 的最小 local-binding contract 不再继续停留在旧的 mixed bindings 回归里。
同一条 structured iterable root 现在也已由独立 regression 单独锁住 root-token query 与 typeDefinition：for current in (if flag { (config, config) } else { (config, config) }) { current.value } 与 for current in match flag { true => [config.child(), config.child()], false => [config.child(), config.child()] } { current.get() } 这两条路径上的 current token，现都已在成功 package analysis 路径与 broken-source fallback 上稳定提供 hover / definition / declaration / references，并继续分别跳到 dependency public Config / Child declaration；同一位置的 textDocument/typeDefinition 现在也会分别稳定落到 dependency public Config / Child declaration，而不是继续只靠通用 for-loop binding matrix 兜底。
同一条 for loop receiver identity 现在也开始把 block 包裹的 iterable root 从大矩阵里单独抽成 standalone regression：for current in { (config, config) } { current.va } 与 for current in { [config.child(), config.child()] } { current.ge } 这两条 member prefix 现在都已在成功 package analysis 路径与 same-file semantic-error fallback 上稳定只补出 dependency field value / method get，for current in { (config, config) } { let first = current.value; let second = current.value; ... } 与 for current in { [config.child(), config.child()] } { let first = current.get(); let second = current.get(); ... } 这两条 member token 现在也都已在成功 package analysis 路径与 same-file semantic-error fallback 上由独立 regression 锁住 hover / definition / declaration / references，而 for current in { (config, config) } { current.leaf.value } 与 for current in { [config.child(), config.child()] } { current.leaf().value } 这两条 member token 的 typeDefinition 现在也都已在成功 package analysis 路径与 same-file semantic-error fallback 上单独锁住到 dependency public Leaf declaration；至此这条 block-wrapped iterable root 的 standalone completion / query / member typeDefinition 合同现已闭合。
同一条 block-wrapped iterable root 这轮也补上了最小 standalone bindings regression：for current in { (config, config) } { current.value } 现已在成功 package analysis 路径上单独锁住 dependency field definition，而 for current in { [config.child(), config.child()] } { current.get() } 这条绑定后的 direct member definition 也已在 broken-source fallback 上由独立 regression 锁住到 dependency public method declaration；这让 block iterable receiver 的最小 local-binding contract 也不再只散落在既有 value-root / member 专项回归里。
同一条 block-wrapped iterable root 现在也已由独立 regression 单独锁住 value-root query：for current in { (config, config) } { current.value } 与 for current in { [config.child(), config.child()] } { current.value } 这两条路径上的 current token，现都已在成功 package analysis 路径与 broken-source fallback 上稳定提供 hover / definition / declaration / references，并继续分别跳到 dependency public Config / Child declaration；这让这条 block iterable root 的 value-root query 不再只靠通用 for-loop binding matrix 兜底。
同一条 block-wrapped iterable root 现在也已由独立 regression 单独锁住 value-root typeDefinition：for current in { (config, config) } { current.value } 与 for current in { [config.child(), config.child()] } { current.value } 这两条路径上的 current token，现都已在成功 package analysis 路径与 broken-source fallback 上稳定跳到 dependency public Config / Child declaration；连同上一轮已独立锁住的 value-root query，这条 block iterable root 的 root-token query / typeDefinition 合同现已闭合，而不再只靠通用 for-loop binding matrix 兜底。
同一条 for loop receiver identity 现在也开始把 unsafe 包裹的 iterable root 从大矩阵里单独抽成 standalone regression：for current in unsafe { (config, config) } { current.va } 与 for current in unsafe { [config.child(), config.child()] } { current.ge } 这两条 member prefix 现在都已在成功 package analysis 路径与 same-file semantic-error fallback 上稳定只补出 dependency field value / method get，for current in unsafe { (config, config) } { let first = current.value; let second = current.value; ... } 与 for current in unsafe { [config.child(), config.child()] } { let first = current.get(); let second = current.get(); ... } 这两条 member token 现在也都已在成功 package analysis 路径与 same-file semantic-error fallback 上由独立 regression 锁住 hover / definition / declaration / references，而 for current in unsafe { (config, config) } { current.leaf.value } 与 for current in unsafe { [config.child(), config.child()] } { current.leaf().value } 这两条 member token 的 typeDefinition 现在也都已在成功 package analysis 路径与 same-file semantic-error fallback 上单独锁住到 dependency public Leaf declaration；至此这条 unsafe-wrapped iterable root 的 standalone completion / query / member typeDefinition 合同现已闭合。
同一条 unsafe-wrapped iterable root 现在也已由独立 regression 单独锁住 value-root query 与 typeDefinition：for current in unsafe { (config, config) } { current.value } 与 for current in unsafe { [config.child(), config.child()] } { current.value } 这两条路径上的 current token，现都已在成功 package analysis 路径与 broken-source fallback 上稳定提供 hover / definition / declaration / references，并继续跳到 dependency public struct declaration；同一位置的 textDocument/typeDefinition 现在也会分别稳定落到 dependency public Config / Child declaration，而不是继续只靠通用 for-loop binding matrix 兜底。
同一条 unsafe-wrapped iterable root 这轮也补上了最小 standalone bindings regression：for current in unsafe { (config, config) } { current.value } 现已在成功 package analysis 路径上单独锁住 dependency field definition，而 for current in unsafe { [config.child(), config.child()] } { current.get() } 这条绑定后的 direct member definition 也已在 broken-source fallback 上由独立 regression 锁住到 dependency public method declaration；这让 unsafe iterable receiver 的最小 local-binding contract 也不再只散落在既有 value-root / member 专项回归里。
同一条 for loop receiver contract 现在也已不再要求 iterable 必须内联书写：当 let items = (config, config)、let items = if flag { (config, config) } else { (config, config) }、let items = match flag { ... } 这类 named iterable alias 最终仍收敛到同一个 dependency tuple/array element binding 时，for current in items { current.value } / for current in items { current.get() } 也会继续复用同一 receiver identity。
同一条 named iterable alias receiver 现在也已由独立 regression 单独锁住完整 member 合同：let items = (config, config); for current in items { current.va } / { current.ge } 这两条 member prefix 现在都会稳定只补出 dependency field value / method get，let items = (config, config); for current in items { current.value } / { current.get() } 这两条 member token 现在也都已在成功 package analysis 路径与 same-file semantic-error fallback 上由独立 regression 锁住 hover / definition / declaration / references，而 let items = (config, config); for current in items { current.leaf.value } / { current.leaf().value } 这两条 member token 的 typeDefinition 现在也都已在成功 package analysis 路径与 same-file semantic-error fallback 上单独锁住到 dependency public Leaf declaration；至此这条 named iterable alias receiver 的 standalone completion / query / member typeDefinition 合同现已闭合。
同一条 named iterable alias receiver 现在也已由独立 regression 单独锁住 value-root query 与 typeDefinition：let items = (config, config); for current in items { current.value } 与 let items = [config.child(), config.child()]; for current in items { current.value } 这两条路径上的 current token，现都已在成功 package analysis 路径与 broken-source fallback 上稳定提供 hover / definition / declaration / references，并继续分别跳到 dependency public Config / Child declaration；同一位置的 textDocument/typeDefinition 现在也会分别稳定落到 dependency public Config / Child declaration，而不是继续只靠通用 receiver identity 兜底。
同一条 named iterable alias receiver 这轮也补上了最小 standalone bindings regression：let items = (config, config); for current in items { return current.value } 现已在成功 package analysis 路径上单独锁住 dependency field definition，而 let items = match flag { ... }; for current in items { let value = current.get() } 这条绑定后的 direct member definition 也已在 broken-source fallback 上由独立 regression 锁住到 dependency public method declaration；这让 named iterable alias receiver 的最小 local-binding contract 也不再只散落在 member/root 专项回归里。
这条 identity contract 现在也继续扩到了同文件 helper-return iterable root：当 free function 显式返回 (Cfg, Cfg) 或 [Child; 2] 这类 tuple/array，且 element 最终仍唯一收敛到同一个 dependency struct binding 时，for current in configs(config) { current.value } / for current in children(config) { current.get() } 也已进入 dependency member completion / query；其中 helper-array receiver 在 broken-source / semantic-error 场景下也会继续复用 dependency method definition fallback。
同一条 helper-return iterable receiver 现在也已由独立 regression 单独锁住完整 member 合同：for current in configs(config) { current.va } 与 for current in children(config) { current.ge } 这两条 member prefix 现在都已在成功 package analysis 路径与 same-file semantic-error fallback 上稳定只补出 dependency field value / method get，for current in configs(config) { current.value } 与 for current in children(config) { current.get() } 这两条 member token 现在也都已在成功 package analysis 路径与 same-file semantic-error fallback 上由独立 regression 锁住 hover / definition / declaration / references，而 for current in configs(config) { current.leaf.value } 与 for current in children(config) { current.leaf().value } 这两条 member token 的 typeDefinition 现在也都已在成功 package analysis 路径与 same-file semantic-error fallback 上单独锁住到 dependency public Leaf declaration；至此 helper-return iterable receiver 的 standalone completion / query / member typeDefinition 合同现已闭合。
同一条 helper-return iterable root 现在也已由独立 regression 单独锁住 value-root query 与 typeDefinition：for current in configs(config) { current.value } 与 for current in children(config) { current.value } 这两条路径上的 current token，现都已在成功 package analysis 路径与 broken-source fallback 上稳定提供 hover / definition / declaration / references，并继续分别跳到 dependency public Config / Child declaration；同一位置的 textDocument/typeDefinition 现在也会分别稳定落到 dependency public Config / Child declaration，而不是继续只靠通用 helper receiver identity 兜底。
同一条 helper-return iterable receiver 这轮也补上了最小 standalone bindings regression：for current in configs(config) { return current.value } 现已在成功 package analysis 路径上单独锁住 dependency field definition，而 for current in children(config) { let value = current.get() } 这条绑定后的 direct member definition 也已在 broken-source fallback 上由独立 regression 锁住到 dependency public method declaration；这让 helper-return iterable receiver 的最小 local-binding contract 也不再只散落在 value-root / member 专项回归里。
同一条 iterable receiver identity 现在也已覆盖 dependency method-return root：当 dependency method 显式返回 [Child; 2] 或 (Child, Child) 这类 tuple/array 时，for current in config.children() { current.value } / for current in config.pair() { current.get() } 也会继续进入 dependency member completion / query，而不是要求用户先手工绑定到本地 iterable alias。
同一条 dependency method-return iterable receiver 现在也已由独立 regression 单独锁住完整 member 合同：for current in config.children() { current.va } 与 for current in config.pair() { current.ge } 这两条 member prefix 现在都已在成功 package analysis 路径与 same-file semantic-error fallback 上稳定只补出 dependency field value / method get，for current in config.children() { current.value } 与 for current in config.pair() { current.get() } 这两条 member token 现在也都已在成功 package analysis 路径与 same-file semantic-error fallback 上由独立 regression 锁住 hover / definition / declaration / references，而 for current in config.children() { current.leaf.value } 与 for current in config.pair() { current.leaf().value } 这两条 member token 的 typeDefinition 现在也都已在成功 package analysis 路径与 same-file semantic-error fallback 上单独锁住到 dependency public Leaf declaration；至此 method-return iterable receiver 的 standalone completion / query / member typeDefinition 合同现已闭合。
同一条 dependency method-return iterable root 现在也已由独立 regression 单独锁住 value-root query 与 typeDefinition：for current in config.children() { current.value } 与 for current in config.pair() { current.get() } 这两条路径上的 current token，现都已在成功 package analysis 路径与 broken-source fallback 上稳定提供 hover / definition / declaration / references，并继续固定到 dependency public Child declaration；同一位置的 textDocument/typeDefinition 现在也会稳定落到 dependency public Child declaration，而不是继续只靠通用 method-return receiver identity 兜底。
同一条 dependency method-return iterable receiver 这轮也补上了最小 standalone bindings regression：for current in config.children() { return current.value } 现已在成功 package analysis 路径上单独锁住 dependency field definition，而 for current in config.pair() { let value = current.get() } 这条绑定后的 direct member definition 也已在 broken-source fallback 上由独立 regression 锁住到 dependency public method declaration；这让 method-return iterable receiver 的最小 local-binding contract 也不再只散落在 value-root / member 专项回归里。
同一条 iterable receiver identity 现在也已覆盖 dependency field iterable root：当 dependency field 类型本身就是 [Child; 2] 或 (Child, Child) 这类 tuple/array 时，for current in config.children { current.value } / for current in config.pair { current.get() } 也会继续进入 dependency member completion / query。
同一条 dependency field iterable receiver 现在也已由独立 regression 单独锁住完整 member 合同：for current in config.children { current.va } 与 for current in config.pair { current.ge } 这两条 member prefix 现在都已在成功 package analysis 路径与 same-file semantic-error fallback 上稳定只补出 dependency field value / method get，for current in config.children { current.value } 与 for current in config.pair { current.get() } 这两条 member token 现在也都已在成功 package analysis 路径与 same-file semantic-error fallback 上由独立 regression 锁住 hover / definition / declaration / references，而 for current in config.children { current.leaf.value } 与 for current in config.pair { current.leaf().value } 这两条 member token 的 typeDefinition 现在也都已在成功 package analysis 路径与 same-file semantic-error fallback 上单独锁住到 dependency public Leaf declaration；至此 field iterable receiver 的 standalone completion / query / member typeDefinition 合同现已闭合。
同一条 dependency field iterable root 现在也已由独立 regression 单独锁住 value-root query 与 typeDefinition：for current in config.children { current.value } 与 for current in config.pair { current.get() } 这两条路径上的 current token，现都已在成功 package analysis 路径与 broken-source fallback 上稳定提供 hover / definition / declaration / references，并继续固定到 dependency public Child declaration；同一位置的 textDocument/typeDefinition 现在也会稳定落到 dependency public Child declaration，而不是继续只靠通用 field receiver identity 兜底。
同一条 dependency field iterable receiver 这轮也补上了最小 standalone bindings regression：for current in config.children { return current.value } 现已在成功 package analysis 路径上单独锁住 dependency field definition，而 for current in config.pair { let value = current.get() } 这条绑定后的 direct member definition 也已在 broken-source fallback 上由独立 regression 锁住到 dependency public method declaration；这让 field iterable receiver 的最小 local-binding contract 也不再只散落在 value-root / member 专项回归里。
同一条 iterable receiver identity 现在也已覆盖 question-wrapped iterable root：当 dependency field / method 返回 Option[[Child; 2]]、Option[(Child, Child)] 或等价 Result[...] 包裹的 iterable 时，for current in config.children? { current.value } / for current in config.pair()? { current.get() } 也会继续进入 dependency member completion / query，而不是在 ? 这一层丢失 element binding；此前已把 for current in config.children? { current.va } 与 for current in config.pair()? { current.ge } 这两条 direct question iterable member prefix，在成功 package analysis 路径与 same-file semantic-error fallback 上单独锁住到 dependency field value / method get，并把 for current in config.children? { current.value } 与 for current in config.pair()? { current.get() } 这两条 member token 的 hover / definition / declaration / references 也在同一路径上单独锁住；这轮再把 for current in config.children? { current.leaf.value } 与 for current in config.pair()? { current.leaf().value } 这两条 member token 的 typeDefinition，在成功 package analysis 路径与 same-file semantic-error fallback 上单独锁住到 dependency public Leaf declaration，因此 direct question iterable receiver 的 standalone completion / query / member typeDefinition 合同现已闭合。
同一条 iterable receiver identity 现在也已覆盖同文件本地 receiver method iterable root：当 impl/extend 中的方法 target 能唯一收敛到当前 dependency receiver，并显式返回 [Child; 2] 或 (Child, Child) 这类 tuple/array 时，for current in config.children() { current.value } / for current in self.pair() { current.get() } 也会继续进入 dependency member completion / query。
同一条同文件本地 receiver method iterable root 现在也已由独立 regression 单独锁住完整 member 合同：for current in config.children() { current.va } 与 for current in self.pair() { current.ge } 这两条 member prefix 现在都已在成功 package analysis 路径与 same-file semantic-error fallback 上稳定只补出 dependency field value / method get，for current in config.children() { current.value } 与 for current in self.pair() { current.get() } 这两条 member token 现在也都已在成功 package analysis 路径与 same-file semantic-error fallback 上由独立 regression 锁住 hover / definition / declaration / references，而 for current in config.children() { current.leaf.value } 与 for current in self.pair() { current.leaf().value } 这两条 member token 的 typeDefinition 现在也都已在成功 package analysis 路径与 same-file semantic-error fallback 上单独锁住到 dependency public Leaf declaration；至此这条 local-method iterable receiver 的 standalone completion / query / member typeDefinition 合同现已闭合。
同一条同文件本地 receiver method iterable root 现在也已由独立 regression 单独锁住 root-token query 与 typeDefinition：for current in config.children() { current.value } 与 for current in self.pair() { current.get() } 这两条路径上的 current token，现都已在成功 package analysis 路径与 broken-source fallback 上稳定提供 hover / definition / declaration / references，并继续固定到 dependency public Child declaration；同一位置的 textDocument/typeDefinition 现在也会稳定落到 dependency public Child declaration，而不是继续只靠既有 member/query 矩阵隐式兜底。
同一条同文件本地 receiver method iterable root 这轮也补上了最小 standalone bindings regression：for current in config.children() { return current.value } 现已在成功 package analysis 路径上单独锁住 dependency field definition，而 for current in self.pair() { let value = current.get() } 这条绑定后的 direct member definition 也已在 broken-source fallback 上由独立 regression 锁住到 dependency public method declaration；这让 local-method iterable receiver 的最小 local-binding contract 也不再只散落在 value-root / member 专项回归里。
这条 identity contract 现在也已把 structured root 和 ? 重新并回同一份 truth source：for current in (if flag { config.children? } else { config.children? }) { current.value } 与 for current in match flag { true => config.pair()?, false => config.pair()? } { current.get() } 这类路径现在也会继续保留解包后的 iterable element binding；此前已把 for current in (if flag { config.children? } else { config.children? }) { current.va } 与 for current in match flag { true => config.pair()?, false => config.pair()? } { current.ge } 这两条 structured question iterable member prefix，在成功 package analysis 路径与 same-file semantic-error fallback 上单独锁住到 dependency field value / method get，并把 for current in (if flag { config.children? } else { config.children? }) { current.value } 与 for current in match flag { true => config.pair()?, false => config.pair()? } { current.get() } 这两条 member token 的 hover / definition / declaration / references 也在同一路径上由独立 regression 单独锁住；这轮再把 for current in (if flag { config.children? } else { config.children? }) { current.leaf.value } 与 for current in match flag { true => config.pair()?, false => config.pair()? } { current.leaf().value } 这两条 member token 的 typeDefinition，在成功 package analysis 路径与 same-file semantic-error fallback 上单独锁住到 dependency public Leaf declaration，因此 structured question iterable receiver 的 standalone completion / query / member typeDefinition 合同现已闭合。
imported dependency public function 的返回值现在也已接入同一条 receiver truth surface：当 use demo.dep.load / use demo.dep.maybe_load / use demo.dep.children 这类导入唯一映射到 dependency .qi 里的 public function，且返回类型可唯一收敛到 dependency public struct、Option/Result 解包后的 dependency public struct，或 [Child; 2] / (Child, Child) 这类 iterable element binding 时，load().value、maybe_load()?.value 与 for current in children() { current.get() } 现在也会继续进入 dependency member completion / query；broken-source / semantic-error 场景下的 dependency-only fallback 也会保留这条 function-return iterable receiver 路径。
imported dependency public const/static 根值现在也已接入同一条 receiver truth surface：当 use demo.dep.DEFAULT as cfg、use demo.dep.MAYBE as child、use demo.dep.ITEMS 这类导入唯一映射到 dependency .qi 里的 public const/static，且声明类型能唯一收敛到 dependency public struct、Option/Result 解包后的 dependency public struct，或 [Child; 2] / (Child, Child) 这类 iterable element binding 时，cfg.value、child?.value 与 for current in ITEMS { current.get() } 现在也会继续进入 dependency member completion / query；broken-source / semantic-error 场景下的 dependency-only fallback 也会保留这条 const/static iterable receiver 路径。
同一条 imported value receiver truth surface 现在也已显式覆盖 direct question-wrapped non-iterable receiver：当 use demo.dep.maybe_load / use demo.dep.MAYBE as child 这类 direct import 唯一映射到 dependency .qi 里的 public function / const / static，且 ? 解包后仍能唯一收敛到同一个 dependency public struct 时，maybe_load()?.va / maybe_load()?.ge 与 child?.va / child?.ge 这四条 direct member prefix，当前都已在成功 package analysis 路径与 broken-source / semantic-error fallback 上由独立 regression 锁住 dependency field / method completion；与此同时，maybe_load()?.value / maybe_load()?.get() 与 child?.value / child?.get() 这四条 direct member token 也都已在成功 package analysis 路径与 broken-source / semantic-error fallback 上由独立 regression 锁住 hover / definition / declaration / references；再加上 maybe_load()?.leaf.value / maybe_load()?.leaf().value 与 child?.leaf.value / child?.leaf().value 这四条 direct member token 的 typeDefinition 也已在成功 package analysis 路径与 broken-source / semantic-error fallback 上单独锁住，因此这条 direct question-wrapped non-iterable receiver 的 member completion + query + typeDefinition 合同现已明确闭合。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 function-root field completion success-path 单独抽成了独立 regression：maybe_load()?.va 这条路径上的 va 前缀，现已在成功 package analysis 路径上由独立 regression 锁住到 dependency field value completion；这让这条 function-root field completion 不再只继续混在旧的 question_value_completion 半矩阵里。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 function-root field completion fallback 单独抽成了独立 regression：let broken: Int = "oops"; return maybe_load()?.va 这条路径上的 va 前缀，现已在 broken-source fallback 上由独立 regression 锁住到 dependency field value completion；连同此前已单独锁住的 success-path regression，这条 function-root field completion 现在也不再继续混在旧的 question_value_completion 半矩阵里。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 function-root method completion success-path 单独抽成了独立 regression：maybe_load()?.ge 这条路径上的 ge 前缀，现已在成功 package analysis 路径上由独立 regression 锁住到 dependency method get completion；这让这条 function-root method completion 也开始从旧的 question_value_completion 半矩阵里拆出来。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 function-root method completion fallback 单独抽成了独立 regression：let broken: Int = "oops"; return maybe_load()?.ge 这条路径上的 ge 前缀，现已在 broken-source fallback 上由独立 regression 锁住到 dependency method get completion；连同此前已单独锁住的 success-path regression，这条 function-root method completion 现在也不再继续混在旧的 question_value_completion 半矩阵里。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 static-root field completion success-path 单独抽成了独立 regression：child?.va 这条路径上的 va 前缀，现已在成功 package analysis 路径上由独立 regression 锁住到 dependency field value completion；这让这条 static-root field completion 也开始从旧的 question_value_completion 半矩阵里拆出来。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 static-root field completion fallback 单独抽成了独立 regression：let broken: Int = "oops"; return child?.va 这条路径上的 va 前缀，现已在 broken-source fallback 上由独立 regression 锁住到 dependency field value completion；连同此前已单独锁住的 success-path regression，这条 static-root field completion 现在也不再继续混在旧的 question_value_completion 半矩阵里。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 static-root method completion success-path 单独抽成了独立 regression：child?.ge 这条路径上的 ge 前缀，现已在成功 package analysis 路径上由独立 regression 锁住到 dependency method get completion；这让这条 static-root method completion 也开始从旧的 question_value_completion 半矩阵里拆出来。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 static-root method completion fallback 单独抽成了独立 regression：let broken: Int = "oops"; return child?.ge 这条路径上的 ge 前缀，现已在 broken-source fallback 上由独立 regression 锁住到 dependency method get completion；连同此前已单独锁住的 success-path regression，这条 static-root method completion 现在也不再继续混在旧的 question_value_completion 半矩阵里。
到这里，旧的 question_value_completion 混合半矩阵已经被 question_function_value_completion、question_function_value_fallback_completion、question_function_method_completion、question_function_method_fallback_completion、question_static_value_completion、question_static_value_fallback_completion、question_static_method_completion 与 question_static_method_fallback_completion 这八个独立 regression 全量替代；因此 direct question-wrapped non-iterable imported receiver 的 completion 半矩阵现已完成拆分，旧混合回归也可以正式退役。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 function-root field member queries success-path 单独抽成了独立 regression：let first = maybe_load()?.value; let second = maybe_load()?.value 这组 token，现已在成功 package analysis 路径上由独立 regression 锁住 dependency field value 的 hover / definition / declaration / references；这让这条 function-root field member queries 也开始从旧的 question_value_member_queries 半矩阵里拆出来。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 function-root field member queries fallback 单独抽成了独立 regression：let first = maybe_load()?.value; let second = maybe_load()?.value; return "oops" 这组 token，现已在 broken-source fallback 上由独立 regression 锁住 dependency field value 的 hover / definition / declaration / references；连同此前已单独锁住的 success-path regression，这条 function-root field member queries 现在也不再继续混在旧的 question_value_member_queries 半矩阵里。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 function-root method member queries success-path 单独抽成了独立 regression：let first = maybe_load()?.get(); let second = maybe_load()?.get() 这组 token，现已在成功 package analysis 路径上由独立 regression 锁住 dependency method get 的 hover / definition / declaration / references；这让这条 function-root method member queries 也开始从旧的 question_value_member_queries 半矩阵里拆出来。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 function-root method member queries fallback 单独抽成了独立 regression：let first = maybe_load()?.get(); let second = maybe_load()?.get(); return "oops" 这组 token，现已在 broken-source fallback 上由独立 regression 锁住 dependency method get 的 hover / definition / declaration / references；连同此前已单独锁住的 success-path regression，这条 function-root method member queries 现在也不再继续混在旧的 question_value_member_queries 半矩阵里。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 static-root field member queries success-path 单独抽成了独立 regression：let first = child?.value; let second = child?.value 这组 token，现已在成功 package analysis 路径上由独立 regression 锁住 dependency field value 的 hover / definition / declaration / references；这让这条 static-root field member queries 也开始从旧的 question_value_member_queries 半矩阵里拆出来。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 static-root field member queries fallback 单独抽成了独立 regression：let first = child?.value; let second = child?.value; return "oops" 这组 token，现已在 broken-source fallback 上由独立 regression 锁住 dependency field value 的 hover / definition / declaration / references；连同此前已单独锁住的 success-path regression，这条 static-root field member queries 现在也不再继续混在旧的 question_value_member_queries 半矩阵里。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 static-root method member queries success-path 单独抽成了独立 regression：let first = child?.get(); let second = child?.get() 这组 token，现已在成功 package analysis 路径上由独立 regression 锁住 dependency method get 的 hover / definition / declaration / references；这让这条 static-root method member queries 也开始从旧的 question_value_member_queries 半矩阵里拆出来。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 static-root method member queries fallback 单独抽成了独立 regression：let first = child?.get(); let second = child?.get(); return "oops" 这组 token，现已在 broken-source fallback 上由独立 regression 锁住 dependency method get 的 hover / definition / declaration / references；连同此前已单独锁住的 success-path regression，这条 static-root method member queries 现在也不再继续混在旧的 question_value_member_queries 半矩阵里。
到这里，旧的 question_value_member_queries 混合半矩阵已经被 question_function_value_member_queries、question_function_value_member_fallback_queries、question_function_method_member_queries、question_function_method_member_fallback_queries、question_static_value_member_queries、question_static_value_member_fallback_queries、question_static_method_member_queries 与 question_static_method_member_fallback_queries 这八个独立 regression 全量替代；因此 direct question-wrapped non-iterable imported receiver 的 member queries 半矩阵现已完成拆分，旧混合回归也可以正式退役。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 function-root field member typeDefinition success-path 单独抽成了独立 regression：let next = maybe_load()?.leaf.value 这条路径上的 leaf token，现已在成功 package analysis 路径上由独立 regression 锁住到 dependency public Leaf declaration；这让这条 function-root field member typeDefinition 也开始从旧的 question_value_member_type_definition 半矩阵里拆出来。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 function-root field member typeDefinition fallback 单独抽成了独立 regression：let next = maybe_load()?.leaf.value; return "oops" 这条路径上的 leaf token，现已在 broken-source fallback 上由独立 regression 锁住到 dependency public Leaf declaration；连同此前已单独锁住的 success-path regression，这条 function-root field member typeDefinition 现在也不再继续混在旧的 question_value_member_type_definition 半矩阵里。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 function-root method member typeDefinition success-path 单独抽成了独立 regression：let next = maybe_load()?.leaf().value 这条路径上的 leaf token，现已在成功 package analysis 路径上由独立 regression 锁住到 dependency public Leaf declaration；这让这条 function-root method member typeDefinition 也开始从旧的 question_value_member_type_definition 半矩阵里拆出来。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 function-root method member typeDefinition fallback 单独抽成了独立 regression：let next = maybe_load()?.leaf().value; return "oops" 这条路径上的 leaf token，现已在 broken-source fallback 上由独立 regression 锁住到 dependency public Leaf declaration；连同此前已单独锁住的 success-path regression，这条 function-root method member typeDefinition 现在也不再继续混在旧的 question_value_member_type_definition 半矩阵里。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 static-root field member typeDefinition success-path 单独抽成了独立 regression：let next = child?.leaf.value 这条路径上的 leaf token，现已在成功 package analysis 路径上由独立 regression 锁住到 dependency public Leaf declaration；这让这条 static-root field member typeDefinition 也开始从旧的 question_value_member_type_definition 半矩阵里拆出来。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 static-root field member typeDefinition fallback 单独抽成了独立 regression：let next = child?.leaf.value; return "oops" 这条路径上的 leaf token，现已在 broken-source fallback 上由独立 regression 锁住到 dependency public Leaf declaration；连同此前已单独锁住的 success-path regression，这条 static-root field member typeDefinition 现在也不再继续混在旧的 question_value_member_type_definition 半矩阵里。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 static-root method member typeDefinition success-path 单独抽成了独立 regression：let next = child?.leaf().value 这条路径上的 leaf token，现已在成功 package analysis 路径上由独立 regression 锁住到 dependency public Leaf declaration；这让这条 static-root method member typeDefinition 也开始从旧的 question_value_member_type_definition 半矩阵里拆出来。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 static-root method member typeDefinition fallback 单独抽成了独立 regression：let next = child?.leaf().value; return "oops" 这条路径上的 leaf token，现已在 broken-source fallback 上由独立 regression 锁住到 dependency public Leaf declaration；连同此前已单独锁住的 success-path regression，这条 static-root method member typeDefinition 现在也不再继续混在旧的 question_value_member_type_definition 半矩阵里。
到这里，旧的 question_value_member_type_definition 混合半矩阵已经被 question_function_value_member_type_definition、question_function_value_member_fallback_type_definition、question_function_method_member_type_definition、question_function_method_member_fallback_type_definition、question_static_value_member_type_definition、question_static_value_member_fallback_type_definition、question_static_method_member_type_definition 与 question_static_method_member_fallback_type_definition 这八个独立 regression 全量替代；因此 direct question-wrapped non-iterable imported receiver 的 member typeDefinition 半矩阵现已完成拆分，旧混合回归也可以正式退役。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 function-root field bindings success-path 单独抽成了独立 regression：return maybe_load()?.value 这条路径，现已在成功 package analysis 路径上由独立 regression 锁住 dependency field value definition；这让这条 function-root field binding 也开始从旧的 question_value_bindings 混合回归里拆出来。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 static-root field bindings success-path 单独抽成了独立 regression：return child?.value 这条路径，现已在成功 package analysis 路径上由独立 regression 锁住 dependency field value definition；这让这条 static-root field binding 也开始从旧的 question_value_bindings 混合回归里拆出来。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 function-root method bindings fallback 单独抽成了独立 regression：let first = maybe_load()?.get(); return "oops" 这条路径，现已在 broken-source fallback 上由独立 regression 锁住 dependency method get definition；这让这条 function-root method binding 也开始从旧的 question_value_bindings 混合回归里拆出来。
同一条 direct question-wrapped non-iterable imported receiver 这轮也把 static-root method bindings fallback 单独抽成了独立 regression：let second = child?.get(); return "oops" 这条路径，现已在 broken-source fallback 上由独立 regression 锁住 dependency method get definition；这让这条 static-root method binding 也开始从旧的 question_value_bindings 混合回归里拆出来。
到这里，旧的 question_value_bindings 混合回归已经被 question_function_value_bindings、question_static_value_bindings、question_function_method_bindings_fallback 与 question_static_method_bindings_fallback 这四个独立 regression 全量替代；因此 direct question-wrapped non-iterable imported receiver 的最小 standalone bindings 合同现已完成拆分，旧混合回归也可以正式退役。
同一条 direct question-wrapped non-iterable imported receiver 这轮也补上了最小 standalone bindings regression：return maybe_load()?.value 与 return child?.value 这两条路径，现已在成功 package analysis 路径上单独锁住 dependency field definition，而 let first = maybe_load()?.get() / let second = child?.get(); return "oops" 这组 direct question function/static root 绑定后的 direct member definition，也已在 broken-source fallback 上由独立 regression 锁住到 dependency public method declaration；这让这条 direct question-wrapped imported value receiver 的最小 local-binding contract 也不再只散落在既有混合 bindings 回归里。
同一条 imported value receiver truth surface 现在也已显式覆盖 structured direct question-wrapped non-iterable receiver 的 member completion + query + typeDefinition：(if flag { maybe_load()? } else { maybe_load()? }).va / .ge、(match flag { true => maybe_load()?, false => maybe_load()? }).va / .ge、(if flag { child? } else { child? }).va / .ge 与 (match flag { true => child?, false => child? }).va / .ge 这八条 direct member prefix，现在都已在成功 package analysis 路径与 broken-source / semantic-error fallback 上由独立 regression 锁住 dependency field / method completion；与此同时，(if flag { maybe_load()? } else { maybe_load()? }).value / .get()、(match flag { true => maybe_load()?, false => maybe_load()? }).value / .get()、(if flag { child? } else { child? }).value / .get() 与 (match flag { true => child?, false => child? }).value / .get() 这八条 direct member token，现在也都已在成功 package analysis 路径与 broken-source / semantic-error fallback 上由独立 regression 锁住 hover / definition / declaration / references；这轮再把 (if flag { maybe_load()? } else { maybe_load()? }).leaf.value / .leaf().value、(match flag { true => maybe_load()?, false => maybe_load()? }).leaf.value / .leaf().value、(if flag { child? } else { child? }).leaf.value / .leaf().value 与 (match flag { true => child?, false => child? }).leaf.value / .leaf().value 这八条 direct member token 的 typeDefinition 也在成功 package analysis 路径与 broken-source / semantic-error fallback 上由独立 regression 锁住；因此这条 structured direct question-wrapped non-iterable receiver 的 member completion + query + typeDefinition 合同现已闭合。
同一条 structured direct question-wrapped non-iterable imported receiver 这轮也补上了最小 standalone bindings regression：return (if flag { maybe_load()? } else { maybe_load()? }).value 与 return (match flag { true => child?, false => child? }).value 这两条路径，现已在成功 package analysis 路径上单独锁住 dependency field definition，而 let first = (match flag { true => maybe_load()?, false => maybe_load()? }).get() / let second = (if flag { child? } else { child? }).get(); return "oops" 这组 structured direct question function/static root 绑定后的 direct member definition，也已在 broken-source fallback 上由独立 regression 锁住到 dependency public method declaration；这让这条 structured direct question-wrapped imported value receiver 的最小 local-binding contract 也不再只散落在既有混合 bindings 回归里。
同一条 imported value receiver truth surface 现在也已显式覆盖 grouped alias + question-wrapped non-iterable root：当 use demo.dep.{maybe_load as load_cfg} / use demo.dep.{MAYBE as maybe_cfg} 这类 grouped alias 唯一映射到 dependency .qi 里的 public function / const / static，且 ? 解包后仍能唯一收敛到同一个 dependency public struct 时，load_cfg()?.va / load_cfg()?.ge 现在都会继续进入成功 package analysis 路径下的 dependency field / method completion，而 load_cfg()?.value / load_cfg()?.get() 与 maybe_cfg?.value / maybe_cfg?.get() 这四条 direct member token 现在也都已在成功 package analysis 路径与 broken-source / semantic-error fallback 上由独立 regression 锁住 hover / definition / declaration / references；这轮再把 load_cfg()?.leaf.value / load_cfg()?.leaf().value 与 maybe_cfg?.leaf.value / maybe_cfg?.leaf().value 这四条 direct member token 的 typeDefinition 在成功 package analysis 路径与 broken-source / semantic-error fallback 上单独锁住，因此这条 grouped alias + question-wrapped non-iterable receiver 的 direct member completion + query + typeDefinition 合同现已闭合。
同一条 grouped alias + question-wrapped non-iterable imported receiver 这轮也补上了最小 standalone bindings regression：return load_cfg()?.value 与 return maybe_cfg?.value 这两条路径，现已在成功 package analysis 路径上单独锁住 dependency field definition，而 let first = load_cfg()?.get() / let second = maybe_cfg?.get(); return "oops" 这组 grouped question function/static root 绑定后的 direct member definition，也已在 broken-source / semantic-error fallback 上由独立 regression 锁住到 dependency public method declaration；这让这条 grouped question-wrapped imported value receiver 的最小 local-binding contract 也不再只散落在既有混合 bindings 回归里。
同一条 grouped alias + question-wrapped non-iterable imported receiver 这轮也把 direct member completion 单独抽成了 standalone regression：load_cfg()?.va / load_cfg()?.ge 与 maybe_cfg?.va / maybe_cfg?.ge 这四条 direct member prefix，现都已在成功 package analysis 路径与 broken-source / semantic-error fallback 上由独立 regression 锁住到 dependency field value / method get；连同此前已独立锁住的 direct member query / typeDefinition，以及已单独抽出的最小 standalone bindings，这条 grouped question value receiver 的 standalone completion / query / typeDefinition / local-binding contract 现已全部闭合。
同一条 imported value receiver truth surface 现在也已显式覆盖 structured grouped alias + question-wrapped non-iterable receiver：(if flag { load_cfg()? } else { load_cfg()? }).va / .ge、(match flag { true => load_cfg()?, false => load_cfg()? }).va / .ge、(if flag { maybe_cfg? } else { maybe_cfg? }).va / .ge 与 (match flag { true => maybe_cfg?, false => maybe_cfg? }).va / .ge 这八条 direct member prefix，现在都已在成功 package analysis 路径与 broken-source / semantic-error fallback 上由独立 regression 锁住 dependency field / method completion；与此同时，(if flag { load_cfg()? } else { load_cfg()? }).value / .get()、(match flag { true => load_cfg()?, false => load_cfg()? }).value / .get()、(if flag { maybe_cfg? } else { maybe_cfg? }).value / .get() 与 (match flag { true => maybe_cfg?, false => maybe_cfg? }).value / .get() 这八条 direct member token，当前也都已在成功 package analysis 路径与 broken-source / semantic-error fallback 上由独立 regression 锁住 hover / definition / declaration / references；这轮再把 (if flag { load_cfg()? } else { load_cfg()? }).leaf.value / .leaf().value、(match flag { true => load_cfg()?, false => load_cfg()? }).leaf.value / .leaf().value、(if flag { maybe_cfg? } else { maybe_cfg? }).leaf.value / .leaf().value 与 (match flag { true => maybe_cfg?, false => maybe_cfg? }).leaf.value / .leaf().value 这八条 direct member token 的 typeDefinition 也在成功 package analysis 路径与 broken-source / semantic-error fallback 上由独立 regression 锁住；因此这条 structured grouped alias + question-wrapped non-iterable receiver 的 member completion + query + typeDefinition 合同现也已闭合。
同一条 structured grouped alias + question-wrapped non-iterable imported receiver 这轮也补上了最小 standalone bindings regression：return (if flag { load_cfg()? } else { load_cfg()? }).value 与 return (match flag { true => maybe_cfg?, false => maybe_cfg? }).value 这两条路径，现已在成功 package analysis 路径上单独锁住 dependency field definition，而 let first = (match flag { true => load_cfg()?, false => load_cfg()? }).get() / let second = (if flag { maybe_cfg? } else { maybe_cfg? }).get(); return "oops" 这组 structured grouped question function/static root 绑定后的 direct member definition，也已在 broken-source / semantic-error fallback 上由独立 regression 锁住到 dependency public method declaration；这让这条 structured grouped question-wrapped imported value receiver 的最小 local-binding contract 也不再只散落在既有混合 bindings 回归里。
同一条 imported iterable receiver truth surface 这轮继续把 grouped alias + question-wrapped iterable receiver 的 direct member contract 从 grouped-import 大矩阵里往 standalone regression 收口：for current in kids()? { current.leaf.value } 与 for current in maybe_items? { current.leaf().value }，现都已在成功 package analysis 路径与 broken-source / semantic-error fallback 上由独立 regression 锁住到 dependency public Leaf declaration；连同前两轮已独立锁住的 for current in kids()? { current.va } / for current in maybe_items? { current.ge } 两条 member completion，以及 for current in kids()? { let first = current.value; let second = current.value } / for current in maybe_items? { let first = current.get(); let second = current.get() } 两条 member query，这条 direct grouped question iterable receiver 的 standalone member completion + query + typeDefinition 合同现已闭合；这轮再把 direct grouped question iterable 的 standalone member completion 也补齐成 field/method × function/static × success/fallback 的完整 8-case 矩阵，因此这条 direct grouped question iterable member completion / query / typeDefinition 现已全部只保留完整 standalone truth surface，而旧 mixed 文件也已整体退役。
同一条 grouped alias + question-wrapped iterable receiver truth surface 这轮也已继续往 receiver binding 的 root-token 级别延伸：for current in kids()? { current.value } 与 for current in maybe_items? { current.get() } 这两条路径上的 current token，现都已在成功 package analysis 路径与 broken-source / semantic-error fallback 上由独立 regression 锁住 hover / definition / declaration / references，并继续固定到 dependency public Child declaration；同一位置的 textDocument/typeDefinition 这轮也已在成功 package analysis 路径与 broken-source / semantic-error fallback 上由独立 regression 锁住，因此这条 grouped question iterable receiver root-token query / typeDefinition 合同现已闭合。
同一条 grouped alias + question-wrapped iterable receiver truth surface 的 bindings 这轮也已补齐成完整 standalone regression 矩阵：for current in kids()? { return current.value } / { return current.get() }、for current in maybe_items? { return current.value } / { return current.get() } 这四条 direct grouped iterable binding definition，现都已在成功 package analysis 路径与 broken-source / semantic-error fallback 上由独立 regression 锁住到 dependency public field / method declaration；旧 grouped-question-import mixed bindings 文件里的同组 direct definition case 也已同时退役，因此这条 direct grouped question iterable receiver 的 standalone bindings 合同现已闭合。
同一条 structured grouped alias + question-wrapped iterable receiver truth surface 这轮也开始往 receiver binding 的 root-token 级别延伸：for current in (if flag { kids()? } else { kids()? }) { current.value }、for current in match flag { true => kids()?, false => kids()? } { current.value }、for current in (if flag { maybe_items? } else { maybe_items? }) { current.get() } 与 for current in match flag { true => maybe_items?, false => maybe_items? } { current.get() } 这四条路径上的 current token，现都已在成功 package analysis 路径与 broken-source / semantic-error fallback 上由独立 regression 锁住 hover / definition / declaration / references，并继续固定到 dependency public Child declaration；同一位置的 textDocument/typeDefinition 这轮也已在成功 package analysis 路径与 broken-source / semantic-error fallback 上由独立 regression 锁住，因此这条 structured grouped question iterable receiver root-token query / typeDefinition 合同现已闭合。
同一条 structured grouped alias + question-wrapped iterable receiver truth surface 的 bindings 这轮也已补齐成完整 standalone regression 矩阵：for current in (if flag { kids()? } else { kids()? }) { return current.value } / { return current.get() }、for current in match flag { true => kids()?, false => kids()? } { return current.value } / { return current.get() }、for current in (if flag { maybe_items? } else { maybe_items? }) { return current.value } / { return current.get() } 与 for current in match flag { true => maybe_items?, false => maybe_items? } { return current.value } / { return current.get() } 这八条 structured grouped iterable binding definition，现都已在成功 package analysis 路径与 broken-source / semantic-error fallback 上由独立 regression 锁住到 dependency public field / method declaration；旧 grouped-question-import mixed bindings 文件里的同组 structured definition case 也已同时退役，因此这条 structured grouped question iterable receiver 的 standalone bindings 合同现已闭合。
同一条 direct question-wrapped iterable receiver truth surface 这轮也补上了最小 standalone bindings regression：for current in maybe_children()? { current.va } 现已在成功 package analysis 路径与 broken-source fallback 上单独锁住 dependency field completion，而 for current in items? { current.get() } 这条绑定后的 direct member definition 也已在 broken-source fallback 上由独立 regression 锁住到 dependency public method declaration；这让 direct question iterable receiver 的最小 local-binding contract 不再只散落在既有 member/root 专项回归里。
同一条 structured direct question-wrapped iterable receiver truth surface 这轮也补上了最小 standalone bindings regression：for current in (if flag { maybe_children()? } else { maybe_children()? }) { current.va } 现已在成功 package analysis 路径与 broken-source fallback 上单独锁住 dependency field completion，而 for current in match flag { true => items?, false => items? } { current.get() } 这条绑定后的 direct member definition 也已在 broken-source fallback 上由独立 regression 锁住到 dependency public method declaration；这让 structured direct question iterable receiver 的最小 local-binding contract 也不再只散落在既有 member/root 专项回归里。
同一条 structured grouped alias + question-wrapped iterable receiver truth surface 的 member completion 这轮也已补齐成完整 standalone regression 矩阵：for current in (if flag { kids()? } else { kids()? }) { current.va } / { current.ge }、for current in match flag { true => kids()?, false => kids()? } { current.va } / { current.ge }、for current in (if flag { maybe_items? } else { maybe_items? }) { current.va } / { current.ge } 与 for current in match flag { true => maybe_items?, false => maybe_items? } { current.va } / { current.ge } 这八条 structured grouped iterable member prefix，现都已在成功 package analysis 路径与 broken-source / semantic-error fallback 上由独立 regression 锁住到 dependency field value / method get；连同此前已独立锁住的同组 member query / typeDefinition，这条 structured grouped question iterable receiver 的 standalone member completion + query + typeDefinition 合同现已闭合，而旧 grouped-question-import mixed bindings 文件也已不再承担这组 completion case。
同一条 structured grouped alias + question-wrapped iterable receiver truth surface 的 member query 这轮也已补齐成完整 standalone regression 矩阵：for current in (if flag { kids()? } else { kids()? }) { let first = current.value; let second = current.value } / { let first = current.get(); let second = current.get() }、for current in match flag { true => kids()?, false => kids()? } { let first = current.value; let second = current.value } / { let first = current.get(); let second = current.get() }、for current in (if flag { maybe_items? } else { maybe_items? }) { let first = current.value; let second = current.value } / { let first = current.get(); let second = current.get() } 与 for current in match flag { true => maybe_items?, false => maybe_items? } { let first = current.value; let second = current.value } / { let first = current.get(); let second = current.get() } 这八条 structured grouped iterable member query，现都已在成功 package analysis 路径与 broken-source / semantic-error fallback 上由独立 regression 锁住 hover / definition / declaration / references；旧 grouped-question-import mixed bindings 文件里的同组 structured query case 也已同时退役，因此这条 structured grouped question iterable receiver 的 standalone member query 合同现已闭合。
同一条 structured grouped alias + question-wrapped iterable receiver truth surface 的 member typeDefinition 这轮也已补齐成完整 standalone regression 矩阵：for current in (if flag { kids()? } else { kids()? }) { current.leaf.value } / { current.leaf().value }、for current in match flag { true => kids()?, false => kids()? } { current.leaf.value } / { current.leaf().value }、for current in (if flag { maybe_items? } else { maybe_items? }) { current.leaf.value } / { current.leaf().value } 与 for current in match flag { true => maybe_items?, false => maybe_items? } { current.leaf.value } / { current.leaf().value } 这八条 structured grouped iterable member token，现都已在成功 package analysis 路径与 broken-source / semantic-error fallback 上由独立 regression 锁住到 dependency public Leaf declaration；旧 grouped-question-import mixed bindings 文件里的同组 structured typeDefinition case 也已同时退役，因此这条 structured grouped question iterable receiver 的 standalone member completion + query + typeDefinition 合同现已闭合。
同一条 imported iterable receiver truth surface 现在也已显式覆盖 structured direct question-wrapped root 的 member completion + query + typeDefinition：for current in (if flag { maybe_children()? } else { maybe_children()? }) { current.va } / { current.ge }、for current in match flag { true => maybe_children()?, false => maybe_children()? } { current.va } / { current.ge }、for current in (if flag { items? } else { items? }) { current.va } / { current.ge } 与 for current in match flag { true => items?, false => items? } { current.va } / { current.ge } 这八条 direct structured iterable member prefix，现在都已在成功 package analysis 路径与 broken-source / semantic-error fallback 上由独立 regression 锁住 dependency field / method completion；而前一轮已把 for current in (if flag { maybe_children()? } else { maybe_children()? }) { current.value } / { current.get() }、for current in match flag { true => maybe_children()?, false => maybe_children()? } { current.value } / { current.get() }、for current in (if flag { items? } else { items? }) { current.value } / { current.get() } 与 for current in match flag { true => items?, false => items? } { current.value } / { current.get() } 这八条 structured direct iterable member token，在成功 package analysis 路径与 broken-source / semantic-error fallback 上单独锁住了 hover / definition / declaration / references；这轮再把 for current in (if flag { maybe_children()? } else { maybe_children()? }) { current.leaf.value } / { current.leaf().value }、for current in match flag { true => maybe_children()?, false => maybe_children()? } { current.leaf.value } / { current.leaf().value }、for current in (if flag { items? } else { items? }) { current.leaf.value } / { current.leaf().value } 与 for current in match flag { true => items?, false => items? } { current.leaf.value } / { current.leaf().value } 这八条 structured direct iterable member token 的 typeDefinition 也都在成功 package analysis 路径与 broken-source / semantic-error fallback 上由独立 regression 锁住；连同更早已单独锁住的同组 structured root token query / typeDefinition，这条 structured direct question-wrapped iterable receiver 的 member completion + query + typeDefinition 合同现已闭合。
imported dependency public function / const / static 的 value / iterable root token 现在也已并进同一条 dependency value-root query slice：load().value 上的 load、maybe_load()?.value 上的 maybe_load、cfg.value / cfg?.value 上的 cfg、child?.value 上的 child、for current in children() { current.get() } 上的 children、for current in ITEMS { current.get() } 上的 ITEMS、for current in maybe_children()? { current.get() } 上的 maybe_children、for current in items? { current.get() } 上的 items，以及 grouped import alias 形态下的 use demo.dep.{children as kids} / use demo.dep.{ITEMS as items} 后续 kids() / items，grouped alias + question-wrapped non-iterable 形态下 use demo.dep.{maybe_load as load_cfg} / use demo.dep.{MAYBE as maybe_cfg} 后续 load_cfg()? / maybe_cfg?，和 grouped alias + question-wrapped iterable 形态下 use demo.dep.{maybe_children as kids} / use demo.dep.{MAYBE_ITEMS as maybe_items} 后续 kids()? / maybe_items? 这类 token，当前已在成功 package analysis 路径与 parse-only 可恢复的 dependency-only fallback 上接通 hover / definition / declaration / references，以及同一条 textDocument/typeDefinition；其中 hover / definition / declaration 会落到解析后的 dependency public struct，references 会返回该 dependency public struct declaration，以及当前文件内仍解析到同一 root binding 的 import local name 引入/使用位置；typeDefinition 也会沿同一 binding 直接跳到对应的 dependency public struct declaration，而 grouped alias 形态下的 kids() / items、question-wrapped iterable root 形态下的 maybe_children / items，以及 grouped alias + question-wrapped 形态下成功路径与 broken-source fallback 都已单独回归锁定的 load_cfg()? / maybe_cfg? / kids()? / maybe_items?，连同 direct question-wrapped 形态下成功路径与 broken-source fallback 都已单独回归锁定的 maybe_load()? / child? / maybe_children()? / items?，现在也不会再退回 imported symbol 本身的 query 语义；此前 direct function iterable fallback 里的 maybe_children()? query 已经接通，前一轮又把 direct question-wrapped iterable root query 单独抽成独立 regression，覆盖 maybe_children()? 与 items? 两条 direct root 在成功 package analysis 路径与 broken-source fallback 上的 hover / definition / declaration / references；这轮再把 direct question-wrapped iterable root 的 typeDefinition 单独抽成独立 regression，覆盖同一组 maybe_children()? 与 items? root 在成功 package analysis 路径与 broken-source fallback 上到 dependency public struct declaration 的跳转；随后已锁住的则是 structured direct function iterable success path 里的 (if flag { maybe_children()? } else { maybe_children()? }) root token query / typeDefinition，以及 match flag { true => maybe_children()?, false => maybe_children()? } 这条 structured direct function iterable root 的成功路径与 broken-source fallback query / typeDefinition，再往后又把 direct static 形态下 (if flag { cfg? } else { cfg? })、match flag { true => cfg?, false => cfg? }、(if flag { items? } else { items? }) 与 match flag { true => items?, false => items? }，以及 grouped alias 形态下的 (if flag { maybe_cfg? } else { maybe_cfg? })、match flag { true => maybe_cfg?, false => maybe_cfg? }、(if flag { load_cfg()? } else { load_cfg()? })、match flag { true => load_cfg()?, false => load_cfg()? }、(if flag { kids()? } else { kids()? }) 与 match flag { true => kids()?, false => kids()? } 都在成功路径与 broken-source fallback 上单独回归锁住了；前一轮再把 direct question-wrapped non-iterable 形态下 (if flag { maybe_load()? } else { maybe_load()? })、match flag { true => maybe_load()?, false => maybe_load()? }、(if flag { child? } else { child? }) 与 match flag { true => child?, false => child? } 这四条 structured root 的 hover / definition / declaration / references 单独抽成独立 regression，而这轮又把同一组 structured root 的 typeDefinition 也单独抽成独立 regression，覆盖成功 package analysis 路径与 broken-source fallback 上到 dependency public struct declaration 的跳转，因此 direct structured question-wrapped non-iterable root 的 query + typeDefinition 合同现也已闭合；前一轮进一步把 direct grouped alias + question-wrapped iterable root query / typeDefinition 都从大矩阵里单独抽成独立 regression：前者覆盖 kids()? 与 maybe_items? 这两条 root 在成功 package analysis 路径与 broken-source fallback 上的 hover / definition / declaration / references，后者覆盖同一组 direct root 在成功 package analysis 路径与 broken-source fallback 上的 struct 跳转；与此同时，structured grouped alias + question-wrapped iterable root query / typeDefinition 现在也都已单独抽成独立 regression，前者覆盖 (if flag { kids()? } else { kids()? })、match flag { true => kids()?, false => kids()? }、(if flag { maybe_items? } else { maybe_items? }) 与 match flag { true => maybe_items?, false => maybe_items? } 这四条 structured root 在成功 package analysis 路径与 broken-source fallback 上的 hover / definition / declaration / references，后者覆盖同一组 structured root 在成功 package analysis 路径与 broken-source fallback 上的 struct 跳转；前一轮再把 direct question-wrapped iterable 形态下的 structured root query 单独抽成独立 regression，覆盖 (if flag { maybe_children()? } else { maybe_children()? })、match flag { true => maybe_children()?, false => maybe_children()? }、(if flag { items? } else { items? }) 与 match flag { true => items?, false => items? } 这四条 direct structured root 在成功 package analysis 路径与 broken-source fallback 上的 hover / definition / declaration / references；这轮再把同一组 direct structured question-wrapped iterable root 的 typeDefinition 也单独抽成独立 regression，覆盖同一组四条 root 在成功 package analysis 路径与 broken-source fallback 上到 dependency public struct declaration 的跳转；这轮又把 direct question-wrapped iterable member 的 current.leaf.value / current.leaf().value 单独抽成独立 regression，覆盖 for current in maybe_children()? { current.leaf.value }、for current in maybe_children()? { current.leaf().value }、for current in items? { current.leaf.value } 与 for current in items? { current.leaf().value } 在成功 package analysis 路径与 broken-source fallback 上到 dependency public Leaf declaration 的跳转，因此 direct question-wrapped iterable receiver 的 member completion + query + typeDefinition 合同现也已闭合。相对地，use demo.dep.load / use demo.dep.DEFAULT as cfg 这类 import binding token 仍继续保留 imported dependency symbol contract，不和 value / iterable root token 混用。
外部稳定互操作边界仍是 C ABI；Rust 继续走 build.rs + staticlib + header 路线。
async 已经不是“只有语法”，而是有真实 build、真实样例和真实回归的受控子集；但 broader async ABI、broader runtime semantics 仍然刻意关闭。
sync backend 的首个 String build 子集现已继续扩到 guarded ordinary capturing-closure string match call roots，并打通首个 String capturing-closure capture 子集：UTF-8 string literal 现可 lowering 为 { ptr, i64 }，并经过 local binding、const/static materialization、普通参数传递、返回值、== / != / < / <= / > / >= 比较、ordinary string match arm、ordinary capturing-closure string-match selected direct/local-binding call roots（现已继续复用现有 bool guard 子集），以及 cleanup direct match / cleanup-call match（当前统一覆盖 direct literal arm、same-file const / static path pattern，以及 _ / binding catch-all，并继续复用现有 bool guard 子集）与 fixed-shape aggregate transport 进入当前 LLVM/object build；与此同时，capturing sync closure 当前也已接受 immutable same-function String binding capture 的最小子集；其中 ordered compare、ordinary string match、ordinary capturing-closure string match 与 cleanup string match 当前都统一复用 memcmp-based lowering，而更广义 string-pattern surface 仍保持保守关闭。
sync closure value flow 现在也已开放首个 TaskHandle transport 子集：non-move capturing sync closure 现可捕获 immutable same-function TaskHandle binding，并经 ordinary direct local / local alias call，以及 ordinary if / integer-match 选出的 direct root / local binding root，把 handle 返回给外层 await；对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此任务句柄现在不再只停留在 item/const/static/root-level await value path，而是正式进入 capturing closure value flow。
ql ffi header 与 build-side header sidecar 现在也已支持最小 String 导出：当 extern "c" import/export surface 里出现 String 参数或返回值时，header 会稳定投影成 typedef struct ql_string { const uint8_t* ptr; int64_t len; } ql_string;，并在 declaration 里按值使用 ql_string；这条 header projection 现已由 driver 单测与 CLI 集成测试单独锁住。
cleanup lowering 已不再是“全量关闭”：首个 defer + cleanup branch/match + 透明 ? wrapper lowering 子集已进入真实 build 回归，并已接通 callable-value cleanup callee 与 cleanup guard-call 子路径的最小间接调用；capturing closure 当前也已打通 local alias 未重绑定前提下的 cleanup callee / cleanup guard-call 最小子集，并进一步开放 same-target cleanup control-flow root 与 cleanup block 内的局部 alias call/guard-call 子集；其中 statement-sequenced cleanup block 内的局部 mutable alias 现也开放 same-target reassign 后继续 direct call / guard-call，而 assignment-valued same-target mutable alias 现也可直接作为 cleanup callee / guard-call root，且 if / match 分支里只要最终仍收敛到同一个 same-target assignment-valued capturing-closure root，也已能继续 build；cleanup block 内的 let chosen = alias = run / let chosen = alias = check 这类 assignment-valued same-target binding 已进入当前 build surface，而 let chosen = if ... { alias = run } else { run } / let chosen = match ... { ... } 这类 control-flow 收敛到 same-target assignment-valued root 的 binding 现在也已可用；当前进一步开放了分支内 block-local alias tail binding，即 let chosen = if ... { let alias = run; alias } else { run }、let chosen = match ... { true => { var alias = check; alias = check; alias }, false => check }，以及同类的 direct cleanup callee / cleanup guard-call root 现在也已能继续 build；另外，statement-sequenced cleanup block 内的局部 mutable alias 现在还额外开放了首个 different-target mutable reassign 子集，即 var alias = left; alias = right; alias(...) / var alias = left_check; alias = right_check; if alias(...) { ... } 这类无 branch-join 的直线语句序列；同一类 block-local different-target mutable alias 现在也已可直接作为 cleanup callee / cleanup guard-call root 使用，即 defer ({ var alias = left; alias = right; alias })(...) / defer if ({ var alias = left_check; alias = right_check; alias })(...) { ... }；同一条 local mutable alias 的 different-target reassign 现在也已沿 shared local path 扩到 cleanup direct root、cleanup local binding root，以及 runtime if / match branch-join 子集；当前又进一步开放了 shared-local control-flow assignment-valued binding alias-chain root：cleanup if 已支持 let chosen = if ... { alias = right } else { left }; let rebound = chosen; rebound(...) 与对应 guard-call，cleanup bool match 已支持等价的 let chosen = match choose() { true => alias = right, false => left }; let rebound = chosen; ...，而 cleanup guarded match 现在也已接通首个子集，例如 let chosen = match choose() { true if guard() => alias = right, false => left, _ => left }; let rebound = chosen; ...；different-closure cleanup control-flow 也已开放首个子集：runtime if / match 现在可在 direct root / block-local alias tail / block binding / local alias chain root 之间选择不同 capturing closure 继续进入 cleanup callee / cleanup guard-call；其他 broader cleanup escape flow 仍保持保守拒绝。
普通 ? lowering 已接入当前 codegen 路径，并已流入当前 shipped cleanup 子集；当前 user-facing build blocker 不再包含 return helper()? 或 defer helper()? 这类透明 question-mark 表达式。
sync closure value surface 已从“仅 non-capturing”推进到首个 capturing 子集：当前开放 non-move、捕获 immutable same-function scalar binding，并允许原局部 direct ordinary call、local alias ordinary call（含 same-target mutable reassign）、local alias cleanup callee、local alias cleanup guard-call、assignment-valued cleanup callee / guard-call root、cleanup block 内局部 alias 的 direct call / guard-call（现含 statement-sequenced local mutable alias same-target reassign、statement-sequenced cleanup block 内局部 mutable alias 的 different-target reassign，以及 control-flow 分支内的 block-local alias tail binding），以及 ordinary match guard-call（现含 direct callee root、先绑定到 ordinary local 后再调用的 control-flow-selected root、block-local assignment-valued / control-flow-assignment-valued binding root，以及 different-closure control-flow 下的 block-local alias tail / block binding / local alias chain callee root）；runtime if / match 在 ordinary direct/local-binding/cleanup paths 上现也开放 same-target control-flow 子集，而 ordinary direct call、ordinary local binding root 及其后续 local alias chain 调用（现含后续未重写块）、ordinary match guard-call，以及 cleanup callee / cleanup guard-call 的 direct root / block-local alias tail / block binding / local alias chain root 子路径，当前都额外开放了首个 different-closure control-flow 子集；同一条 local mutable alias 的 different-target reassign 现在也已开放到 ordinary direct call、ordinary local binding root、ordinary control-flow assignment-valued direct/binding/alias-chain root、cleanup direct root、cleanup local binding root、ordinary match guard-call，以及 runtime if / match branch-join 子集；其他逃逸路径仍关闭。

当前已开放的构建表面

CLI 与产物

ql check
ql build --emit llvm-ir|obj|exe|dylib|staticlib
ql ffi header
ql fmt
ql mir
ql ownership
ql project graph [file-or-dir]
ql project emit-interface [file-or-dir] [-o <output>] [--changed-only] [--check]
ql runtime

最小 manifest / workspace 子集

当前 Phase 8 已开放的最小工程面：

qlang.toml upward discovery
[package].name
[workspace].members
[references].packages
ql project graph [file-or-dir] 文本输出当前 manifest graph；package manifest 现会额外显示当前包默认 .qi 路径/状态与引用 interface 状态，workspace-only 根 manifest 则会继续展开每个 member package 的 manifest、包名、默认 .qi 路径/状态、references 与引用 interface 状态；当前状态字面量为 valid、missing、invalid、stale
ql project emit-interface [file-or-dir] [-o <output>] [--changed-only] [--check]
ql build <file> --emit-interface：在构建成功后顺手写出当前包的默认 <package>.qi
.qi V1 emit：package manifest 仍默认扫描 manifest_dir/src/**/*.ql，逐文件通过 ql-analysis 后生成 <package>.qi；workspace-only manifest 上的 ql project emit-interface 则会顺序为每个 [workspace].members 成员写出默认 <package>.qi，该模式下 -o/--output 继续保持关闭；新增 --changed-only 后，只会重发非 valid 的目标接口，否则回报 up-to-date interface: ...
ql project emit-interface --check 当前会验证 package/workspace 范围内每个默认 <package>.qi 是否处于 valid 状态；成功时回报 ok interface: ...，失败时会把 missing/invalid/unreadable/stale 直接转成显式错误并提示重新 emit；workspace-only 根 manifest 现在会汇总全部无效 member interface，并在末尾输出总数摘要
.qi V1 文本当前只保留 public surface：去掉 function body、const/static value、struct field default，并按源文件分段写入 // source: ... section
ql check 当前已在 package-aware 路径上加载 [references].packages 指向的 <dependency>.qi，当入口是 package directory、qlang.toml、包内源码文件路径，或 workspace-only 根 manifest 时都会走这条路径，并在缺失 interface artifact 时显式失败；workspace-only 根会顺序检查每个 [workspace].members 成员包
ql check 当前也会在 package-aware 路径上把 stale dependency interface 视为显式失败，并建议重新执行 --sync-interfaces 或对对应依赖单独运行 ql project emit-interface
ql check --sync-interfaces 当前会在 package-aware check 前递归扫描本地 [references].packages，按默认输出位置同步写出 dependency <package>.qi；当前只会重发非 valid 状态的 dependency interface（例如 missing / invalid / unreadable / stale）；这个开关目前支持 package directory、qlang.toml 路径、能向上发现 manifest 的包内源码文件路径，以及 workspace-only 根 manifest；workspace-only 根会对成员包批量执行，并对重复 dependency 写出做去重
dependency .qi 当前已进入 syntax-aware load：每个 // source: ... section 会通过 interface-mode parser 解析为 AST，支持 bodyless fn / impl / extend 声明，以及无值的 const / static 接口声明
ql-analysis::analyze_package 当前已把 dependency .qi 的公开符号索引进 PackageAnalysis：覆盖 top-level fn / const / static / struct / enum / trait / type，以及 public trait / impl / extend methods；索引当前保留 package name、source section path、symbol kind、name、detail 与 interface span
ql-analysis / ql-lsp 当前已开放 imported dependency symbol 的最小 cross-file hover / definition / declaration / references：当当前文件里的 import binding 能唯一映射到 dependency .qi public symbol 时，hover 会显示 dependency declaration，go to definition 与 go to declaration 都会跳到 dependency .qi artifact 内的 declaration 位置，references 会在需要时把 dependency .qi declaration 与当前文件 import/use 位置一起返回；当前这一合同同样覆盖 grouped import alias 形态，例如 use demo.dep.{exported as run}
ql-analysis / ql-lsp 当前也已开放显式 type-namespace 位置上的最小 textDocument/typeDefinition，并开始小步扩到 value-position 的受控子集：same-file type use 现可跳到同文件 struct / enum / trait / type alias / generic 定义；same-file use LocalType as Alias 这类 local import type alias use 当前会优先跳到底层本地类型定义；当打开文档可成功装载其 package 时，dependency import/type root（例如 Buf[Int]）当前也可跳到 dependency .qi artifact 内的 public type declaration；与此同时，Cmd.Retry 这类 dependency enum variant token 现在也可跳到其 dependency public enum declaration，对能从语法局部恢复出 dependency struct 类型的 value/root，value token 本身现在也可通过 textDocument/typeDefinition 跳到 dependency public struct declaration；这条 value/root slice 现除了 dependency-typed param、typed closure param、普通 named local、destructured local、inline tuple/array for loop binding、question-wrapped iterable for loop binding、structured question-wrapped iterable for loop binding、question-unwrapped local，以及 direct field-projection / method-call / structured receiver 派生值外，也已覆盖 target 能唯一恢复为 dependency struct 的 impl / extend 方法体 self receiver，而 let project = (current: Cfg) => current.value 这类 typed closure param root token、let alias = config; alias.value 这类 named local root token、let current = config.child; let alias = current; alias.value 这类 field-projection result direct alias local root token、let current = config.child(); let alias = current; alias.value 这类 method-call result direct alias local root token、let Cfg { child } = config; child.value 这类 destructured local root token、extend Cfg { pub fn read(self) -> Int { return self.value } } 这类 self receiver root token、for current in (config, config) { current.value } / for current in [config.child(), config.child()] { current.value } 这类 inline tuple/array for loop binding root token、for current in config.children? { current.value } / for current in config.pair()? { current.get() } 这类 question-wrapped iterable for loop binding root token、for current in (if flag { config.children? } else { config.children? }) { current.value } / for current in match flag { true => config.pair()?, false => config.pair()? } { current.get() } 这类 structured question-wrapped iterable for loop binding root token、let current = config.child?; current.value 这类 question-unwrapped local root token、let current = if flag { config.child() } else { config.child() }; current.value、let current = match flag { ... }; current.value 这类 structured result local root token，以及 let current = { config.child() }; current.value 这类 block tail result local 的 success-path struct 跳转现在也都已由独立 regression 单独锁住；其中 for current in (config, config) { current.value } 与 for current in [config.child(), config.child()] { current.value } 这组 direct root token 的 broken-source fallback struct 跳转也已单独锁住，而 let current = config.child(); let alias = current; let value = alias.value; return "oops" 这条 method-call result direct alias local root token 的 broken-source fallback struct 跳转这轮也已单独锁住，let current = config.child; let alias = current; let value = alias.value; return "oops" 这条 field-projection result direct alias local root token 的 broken-source fallback struct 跳转这轮也已单独锁住，let current = { config.child() }; let alias = current; let value = alias.value; return "oops" 这条 block-tail result direct alias local root token 的 broken-source fallback struct 跳转这轮也已单独锁住，extend Cfg { pub fn read(self) -> Int { let value = self.value; return "oops" } } 这条 self receiver root token 的 broken-source fallback struct 跳转这轮也已单独锁住，let project = (current: Cfg) => { let value = current.value; return "oops" } 这条 typed closure param root token 的 broken-source fallback struct 跳转这轮也已单独锁住。与此同时，config.child、Cfg { child: ... }、let Cfg { child } = ...、config.child.value、config.child?.value、config.child().value、self.value、let current = if flag { config.child() } else { config.child() }; let alias = current; alias.leaf.value、let current = { config.child() }; let alias = current; alias.leaf.value 这类 dependency struct field token 现在也可在字段声明类型能唯一映射到 dependency public type 时跳到对应 .qi public type declaration；若字段 token 后面直接接 ?（例如 config.child?、config.child?.value），则会优先跳到 Option[T] / Result[T, E] 解包后的 dependency public type。同一条 truth surface 上，config.child.get()、config.child()?.get()、config.child() / built.child() / (match ...).next() / self.get()、let current = match flag { true => config.child(), false => config.child() }; let alias = current; alias.leaf().value、let current = { config.child() }; let alias = current; alias.leaf().value 这类 dependency method token 现在也可在其声明返回类型能唯一映射到 dependency public type 时跳到对应 .qi public type declaration；若方法 token 后面直接接 ?（例如 config.child()?、config.child()?.get()），则同样会优先跳到解包后的 dependency public type；当当前文档存在 same-file semantic errors、但语法仍可恢复且 dependency package 已可加载时，这几条 dependency typeDefinition 也都会继续工作，而 let Cfg { child } = config; child.leaf.value / let Cfg { child } = config; child.leaf().value 这组 destructured local receiver member typeDefinition 连同 broken-source 下 let Cfg { child } = config; let value = child.leaf.value; return "oops" / let Cfg { child } = config; let value = child.leaf().value; return "oops" 也已由独立 regression 单独锁住。当前这条能力仍不做更广义值位推断 type jump，也不扩到 broader non-type-context fallback
同一条 dependency struct value/root truth surface 这轮也把最直接的 named local direct root fallback 单独锁住了：let current = config; let first = current.value; let second = current.value; return "oops" 这条路径上的 current token，现在也已在 broken-source fallback 上继续返回 dependency public Config declaration，而对应的 textDocument/typeDefinition 也会落到同一 declaration。
同一条 dependency struct value/root truth surface 这轮也把最直接的 destructured local direct root fallback 单独锁住了：let Cfg { child } = config; let first = child.value; let second = child.value; return "oops" 这条路径上的 child token，现在也已在 broken-source fallback 上继续返回 dependency public Child declaration，而对应的 textDocument/typeDefinition 也会落到同一 declaration。
同一条 dependency struct value/root truth surface 这轮也把最直接的 direct field-projection result local fallback 单独锁住了：let current = config.child; let first = current.value; let second = current.value; return "oops" 这条路径上的 current token，现在也已在 broken-source fallback 上继续返回 dependency public Child declaration，而对应的 textDocument/typeDefinition 也会落到同一 declaration。
同一条 dependency struct value/root truth surface 这轮也把最直接的 direct method-call result local fallback 单独锁住了：let current = config.child(); let first = current.value; let second = current.value; return "oops" 这条路径上的 current token，现在也已在 broken-source fallback 上继续返回 dependency public Child declaration，而对应的 textDocument/typeDefinition 也会落到同一 declaration。
direct question-unwrapped dependency receiver 的最小 member token 合同现在也已由独立 regression 全矩阵锁住：config.child?.va / config.child?.value 上的 field completion / hover / declaration / references / definition / field typeDefinition，以及 config.child()?.ge / config.child()?.get() 上的 method completion / hover / declaration / references / definition / method typeDefinition，当前都已在成功 package analysis 路径与 broken-source fallback 上保持一致，因此这条 direct question-unwrapped receiver 的 member completion / query / definition / typeDefinition 合同现已闭合
同一条 direct question-unwrapped dependency receiver 这轮也把 member completion 从旧混合回归里单独抽成了 standalone regression 文件：config.child?.va 与 config.child()?.ge 这两条 direct member prefix，现都已在成功 package analysis 路径与 broken-source fallback 上由独立 completion regression 锁住到 dependency field value / method get；这让这条 receiver 的 completion 也不再只靠早期混合 question_dependency_bindings regression 隐式兜底。
同一条 direct question-unwrapped dependency receiver 这轮也把 field completion success-path 单独抽成了独立 regression：config.child?.va 这条路径上的 va 前缀，现已在成功 package analysis 路径上由独立 regression 锁住到 dependency field value completion；这让这条 field completion 不再只继续混在旧的 question_unwrapped_completion 半矩阵里。
同一条 direct question-unwrapped dependency receiver 这轮也把 field completion fallback 单独抽成了独立 regression：let broken: Int = "oops"; return config.child?.va 这条路径上的 va 前缀，现已在 broken-source fallback 上由独立 regression 锁住到 dependency field value completion；连同此前已单独锁住的 success-path regression，这条 field completion 现在也不再继续混在旧的 question_unwrapped_completion 半矩阵里。
同一条 direct question-unwrapped dependency receiver 这轮也把 method completion success-path 单独抽成了独立 regression：config.child()?.ge 这条路径上的 ge 前缀，现已在成功 package analysis 路径上由独立 regression 锁住到 dependency method get completion；这让这条 method completion 也不再只继续混在旧的 question_unwrapped_completion 半矩阵里。
同一条 direct question-unwrapped dependency receiver 这轮也把 method completion fallback 单独抽成了独立 regression：let broken: Int = "oops"; return config.child()?.ge 这条路径上的 ge 前缀，现已在 broken-source fallback 上由独立 regression 锁住到 dependency method get completion；连同此前已单独锁住的 success-path regression，这条 method completion 现在也不再继续混在旧的 question_unwrapped_completion 半矩阵里。
到这一步，direct question-unwrapped dependency receiver 的 completion 四个半边也已全部由独立 regression 收口：field / method 两侧的 success-path 与 broken-source fallback 现都已有各自的 standalone 文件，旧的混合 question_unwrapped_completion.rs 也已可以退场，不再继续承担半矩阵兜底职责。
同一条 direct question-unwrapped dependency receiver 这轮也把 member query 从旧混合回归里单独抽成了 standalone regression 文件：config.child?.value 与 config.child()?.get() 这两条 direct member token，现都已在成功 package analysis 路径与 broken-source fallback 上由独立 query regression 锁住 hover / definition / declaration / references；这让这条 receiver 的 query 也不再只靠早期混合 question_dependency_bindings regression 隐式兜底。
同一条 direct question-unwrapped dependency receiver 这轮也把 member typeDefinition 从旧混合回归里单独抽成了 standalone regression 文件：config.child?.leaf.value 与 config.child()?.leaf().value 这两条 direct member token，现都已在成功 package analysis 路径与 broken-source fallback 上由独立 typeDefinition regression 锁住到 dependency public Leaf declaration；这让这条 receiver 的 member typeDefinition 也不再只靠早期混合 question_dependency_bindings regression 隐式兜底。
同一条 direct question-unwrapped dependency receiver 这轮也把最小 standalone bindings 从旧混合回归里单独抽成了 regression 文件：return config.child?.value 现已在成功 package analysis 路径上单独锁住 dependency field definition，而 let value = config.child()?.get(); return "oops" 这条绑定后的 direct member definition 也已在 broken-source fallback 上由独立 regression 锁住到 dependency public method declaration；这让这条 receiver 的 local-binding contract 也不再只靠早期混合 question_dependency_bindings regression 隐式兜底。
同一条 receiver truth surface 现在也已由独立 regression 锁住 structured question-unwrapped receiver 的完整 member 合同：(if flag { config.child? } else { config.child? }).va / .value、(match flag { true => config.child?, false => config.child? }).va / .value、(if flag { config.child()? } else { config.child()? }).ge / .get() 与 (match flag { true => config.child()?, false => config.child()? }).ge / .get() 这四条路径上的 member token，当前都已在成功 package analysis 路径与 broken-source fallback 上接通 field / method completion、hover / definition / declaration / references，以及 member typeDefinition；这轮又把 (...).value / (...).get() 这四条路径上的 hover / definition / declaration / references 单独抽成 direct structured question-unwrapped member query regression，而此前已独立锁住的 completion 与 (...).leaf.value / (...).leaf().value 这两条 member typeDefinition 继续复用同一 truth surface，因此这条 structured question-unwrapped receiver 的 member completion / query / definition / typeDefinition 合同现已闭合
同一条 syntax-local dependency value/root slice 现在也已由独立 regression 锁住 question-unwrapped receiver root token：除了 direct config.child? 与 config.child()? 之外，(if flag { config.child? } else { config.child? })、match flag { true => config.child?, false => config.child? }、(if flag { config.child()? } else { config.child()? }) 与 match flag { true => config.child()?, false => config.child()? } 这四条 structured root 上的 child token，当前也都已在成功 package analysis 路径与 broken-source fallback 上接通 hover / definition / declaration / references，并继续收敛到解包后的 dependency public struct declaration 与当前文件内仍解析到同一 root binding 的 token 位置；与此同时，这四条 structured root 连同 direct config.child? / config.child()? 现在也都已由独立 regression 锁住同一条 textDocument/typeDefinition 跳转，因此这条 direct + structured question-unwrapped root 合同现已闭合
同一条 direct question-unwrapped dependency receiver root，这轮也把 query 从旧的泛化 question_root_queries 里单独抽成了 standalone regression 文件：config.child? 与 config.child()? 这两条 direct root 上的 child token，现都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references；这让 direct question-unwrapped root query 也不再只靠更早的混合 root matrix 隐式兜底。
同一条 direct question-unwrapped dependency receiver root，这轮也把 typeDefinition 从旧的泛化 question_type_definition 里单独抽成了 standalone regression 文件：config.child? 与 config.child()? 这两条 direct root 上的 child token，现都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁到同一个解包后 dependency public Child declaration；这让 direct question-unwrapped root 的 typeDefinition 也不再只靠更早的混合 root type matrix 隐式兜底。
同一条 structured question-unwrapped dependency receiver 这轮也把最小 standalone bindings 从旧混合回归里单独抽成了 regression 文件：let first = (if flag { config.child? } else { config.child? }).value; let second = (match flag { true => config.child?, false => config.child? }).value 这组 field definition，现已在成功 package analysis 路径上由独立 regression 锁住，而 let first = (if flag { config.child()? } else { config.child()? }).get(); let second = (match flag { true => config.child()?, false => config.child()? }).get(); return "oops" 这组绑定后的 direct member definition 也已在 broken-source fallback 上由独立 regression 锁住到 dependency public method declaration；这让这条 receiver 的 local-binding contract 也不再只靠早期混合 question_structured_dependency_bindings regression 隐式兜底。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也开始拆 standalone member completion：let current = config.child?; return current.va 与 let current = config.child()?; return current.ge 现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 dependency field / method completion；这让这条 question-unwrapped local receiver 的 member completion 不再只靠更大的 local/root truth surface 隐式兜底。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也补上了 field-question completion success-path：let current = config.child?; return current.va 这条路径上的 va 前缀，现已在成功 package analysis 路径上由独立 regression 锁住到 dependency field value completion；这让这条 field-question completion 不再只继续混在旧的 question_unwrapped_local_completion 半矩阵里。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也补上了 field-question completion fallback：let current = config.child?; return "oops"; return current.va 这条路径上的 va 前缀，现已在 broken-source fallback 上由独立 regression 锁住到 dependency field value completion；连同此前已单独锁住的 success-path regression，这条 field-question completion 现在也不再继续混在旧的 question_unwrapped_local_completion 半矩阵里。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也补上了 method-return completion success-path：let current = config.child()?; return current.ge 这条路径上的 ge 前缀，现已在成功 package analysis 路径上由独立 regression 锁住到 dependency method get completion；这让这条 method-return completion 也不再只继续混在旧的 question_unwrapped_local_completion 半矩阵里。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也补上了 method-return completion fallback：let current = config.child()?; return "oops"; return current.ge 这条路径上的 ge 前缀，现已在 broken-source fallback 上由独立 regression 锁住到 dependency method get completion；连同此前已单独锁住的 success-path regression，这条 method-return completion 现在也不再继续混在旧的 question_unwrapped_local_completion 半矩阵里。
到这一步，question-unwrapped local receiver 的 completion 四个半边也已全部由独立 regression 收口：field-question / method-return 两侧的 success-path 与 broken-source fallback 现都已有各自的 standalone 文件，旧的混合 question_unwrapped_local_completion.rs 也已可以退场，不再继续承担半矩阵兜底职责。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也开始拆 standalone member query：let current = config.child?; let first = current.value; let second = current.value 与 let current = config.child()?; let first = current.get(); let second = current.get() 现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references；这让这条 question-unwrapped local receiver 的 member query 也不再只靠更大的 local/root truth surface 隐式兜底。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也补上了 field-question member query success-path：let current = config.child?; let first = current.value; let second = current.value 这条路径上的 value token，现已在成功 package analysis 路径上由独立 regression 锁住 hover / definition / declaration / references；这让这条 field-question member query 不再只继续混在旧的 question_unwrapped_local_member_queries 半矩阵里。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也补上了 field-question member query fallback：let current = config.child?; let first = current.value; let second = current.value; return "oops" 这条路径上的 value token，现已在 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references；连同此前已单独锁住的 success-path regression，这条 field-question member query 现在也不再继续混在旧的 question_unwrapped_local_member_queries 半矩阵里。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也补上了 method-return member query success-path：let current = config.child()?; let first = current.get(); let second = current.get() 这条路径上的 get token，现已在成功 package analysis 路径上由独立 regression 锁住 hover / definition / declaration / references；这让这条 method-return member query 也不再只继续混在旧的 question_unwrapped_local_member_queries 半矩阵里。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也补上了 method-return member query fallback：let current = config.child()?; let first = current.get(); let second = current.get(); return "oops" 这条路径上的 get token，现已在 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references；连同此前已单独锁住的 success-path regression，这条 method-return member query 现在也不再继续混在旧的 question_unwrapped_local_member_queries 半矩阵里。
到这一步，question-unwrapped local receiver 的 member query 四个半边也已全部由独立 regression 收口：field-question / method-return 两侧的 success-path 与 broken-source fallback 现都已有各自的 standalone 文件，旧的混合 question_unwrapped_local_member_queries.rs 也已可以退场，不再继续承担半矩阵兜底职责。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也补上了 standalone member typeDefinition：let current = config.child?; return current.leaf.value 与 let current = config.child()?; return current.leaf().value 现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住到 dependency public Leaf declaration；连同前两轮已单独锁住的 member completion 与 member query，这条 question-unwrapped local receiver 的 standalone member contract 现已闭合。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也补上了 field-question member typeDefinition success-path：let current = config.child?; return current.leaf.value 这条路径上的 leaf token，现已在成功 package analysis 路径上由独立 regression 锁到 dependency public Leaf declaration；这让这条 field-question member typeDefinition 不再只继续混在旧的 question_unwrapped_local_member_type_definition 半矩阵里。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也补上了 field-question member typeDefinition fallback：let current = config.child?; let broken: Int = "oops"; return current.leaf.value 这条路径上的 leaf token，现已在 broken-source fallback 上由独立 regression 锁到 dependency public Leaf declaration；连同此前已单独锁住的 success-path regression，这条 field-question member typeDefinition 现在也不再继续混在旧的 question_unwrapped_local_member_type_definition 半矩阵里。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也补上了 method-return member typeDefinition success-path：let current = config.child()?; return current.leaf().value 这条路径上的 leaf token，现已在成功 package analysis 路径上由独立 regression 锁到 dependency public Leaf declaration；这让这条 method-return member typeDefinition 也不再只继续混在旧的 question_unwrapped_local_member_type_definition 半矩阵里。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也补上了 method-return member typeDefinition fallback：let current = config.child()?; let broken: Int = "oops"; return current.leaf().value 这条路径上的 leaf token，现已在 broken-source fallback 上由独立 regression 锁到 dependency public Leaf declaration；连同此前已单独锁住的 success-path regression，这条 method-return member typeDefinition 现在也不再继续混在旧的 question_unwrapped_local_member_type_definition 半矩阵里。
到这一步，question-unwrapped local receiver 的 member typeDefinition 四个半边也已全部由独立 regression 收口：field-question / method-return 两侧的 success-path 与 broken-source fallback 现都已有各自的 standalone 文件，旧的混合 question_unwrapped_local_member_type_definition.rs 也已可以退场，不再继续承担半矩阵兜底职责。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也补上了最小 standalone bindings regression：let current = config.child?; return current.value 现已在成功 package analysis 路径上单独锁住 dependency field definition，而 let current = config.child()?; let value = current.get(); return "oops" 这条绑定后的 direct member definition 也已在 broken-source fallback 上由独立 regression 锁住到 dependency public method declaration；这让这条 question-unwrapped local receiver 的最小 local-binding contract 也不再只散落在 value-root / member 专项回归里。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也补上了 field-question bindings success-path：let current = config.child?; return current.value 这条路径上的 value token，现已在成功 package analysis 路径上由独立 regression 锁住到 dependency public field declaration；连同此前已单独锁住的 broken-source regression，这条 field-question local-binding contract 现在也不再继续混在旧的 question_unwrapped_local_bindings 半矩阵里。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也补上了 field-question bindings fallback：let current = config.child?; let broken: Int = "oops"; return current.value 这条路径上的 value token，现已在 broken-source fallback 上由独立 regression 锁住到 dependency public field declaration；连同此前已单独锁住的 success-path regression，这条 field-question local-binding contract 现在也不再继续混在旧的 question_unwrapped_local_bindings 半矩阵里。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也补上了 method-return bindings success-path：let current = config.child()?; return current.get() 这条路径上的 get token，现已在成功 package analysis 路径上由独立 regression 锁住到 dependency public method declaration；连同此前已单独锁住的 broken-source regression，这条 method-return local-binding contract 现在也不再继续混在旧的 question_unwrapped_local_bindings 半矩阵里。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也补上了 method-return bindings fallback：let current = config.child()?; let value = current.get(); return "oops" 这条路径上的 get token，现已在 broken-source fallback 上由独立 regression 锁住到 dependency public method declaration；连同此前已单独锁住的 success-path regression，这条 method-return local-binding contract 现在也不再继续混在旧的 question_unwrapped_local_bindings 半矩阵里。
到这一步，question-unwrapped local receiver 的 bindings 四个半边也已全部由独立 regression 收口：field-question / method-return 两侧的 success-path 与 broken-source fallback 现都已有各自的 standalone 文件，旧的混合 question_unwrapped_local_bindings.rs 也已可以退场，不再继续承担半矩阵兜底职责。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也补上了 field-question root query fallback：let current = config.child?; return current.value + current.value 这条 success-path 路径上的 current token，以及 let current = config.child?; let broken: Int = "oops"; return current.value + current.value 这条 broken-source fallback 路径上的 current token，现都已由独立 regression 锁住 hover / definition / declaration / references，并继续固定到 dependency public Child declaration；这条 question-unwrapped local field-question root query 现在也不再继续混在更大的 value-root fallback matrix 里。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也补上了 field-question root typeDefinition fallback：let current = config.child?; return current.value 这条 success-path 路径上的 current token，以及 let current = config.child?; let broken: Int = "oops"; return current.value 这条 broken-source fallback 路径上的 current token，现都已由独立 regression 锁到 dependency public Child declaration；这条 question-unwrapped local field-question root typeDefinition 现在也不再继续混在更大的 value-root fallback matrix 里。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也补上了 method-return root query：let current = config.child()?; return current.value + current.value 这条 success-path 路径上的 current token，以及 let current = config.child()?; let first = current.value; let second = current.value; return "oops" 这条 broken-source fallback 路径上的 current token，现都已由独立 regression 锁住 hover / definition / declaration / references，并继续固定到 dependency public Child declaration；这让 question-unwrapped local root query 不再只停留在 config.child? 这条 field-question 形态上。
同一条 syntax-local dependency question-unwrapped local receiver 这轮也补上了 method-return root typeDefinition：let current = config.child()?; return current.value 这条 success-path 路径上的 current token，以及 let current = config.child()?; let value = current.value; return "oops" 这条 broken-source fallback 路径上的 current token，现都已由独立 regression 锁到 dependency public Child declaration；连同上一轮已单独锁住的 method-return root query，这条 question-unwrapped local method-return root contract 也不再继续混在更大的 value-root type matrix 里。
同一条 syntax-local dependency value/root slice 现在也不再只剩 typeDefinition 与 broken-source fallback：当打开文档可成功装载其 package 时，dependency-typed param、typed closure param、普通 named local、destructured local、inline tuple/array for loop binding、question-wrapped iterable for loop binding、structured question-wrapped iterable for loop binding、question-unwrapped local、direct field-projection / method-call / structured receiver 派生值，以及 target 能唯一恢复为 dependency struct 的 impl / extend 方法体 self receiver，这些 value root token 本身现在也已支持 cross-file hover / definition / declaration / references；当前结果仍固定收敛到 dependency public struct declaration 与当前文件内的同 binding 局部引用，而独立 regression 现已至少锁住 let project = (current: Cfg) => current.value 这类 typed closure param、普通 named local、let current = config.child; let alias = current; alias.value 这类 field-projection result direct alias local、let current = config.child(); let alias = current; alias.value 这类 method-call result direct alias local、let Cfg { child } = config; child.value 这类 destructured local、let current = config.child?; current.value 这类 question-unwrapped local、let current = if flag { config.child() } else { config.child() }; current.value / let current = if flag { config.child() } else { config.child() }; let alias = current; alias.value、let current = match flag { ... }; current.value / let current = match flag { ... }; let alias = current; alias.value 这类 structured result local 及其 direct alias、let current = { config.child() }; current.value / let current = { config.child() }; let alias = current; alias.value 这类 block tail result local 及其 direct alias、extend Cfg { pub fn read(self) -> Int { return self.value } } 这类 self receiver，以及 for current in (config, config) { current.value } / for current in [config.child(), config.child()] { current.value } 这类 inline tuple/array for loop binding，加上 for current in config.children? { current.value } / for current in config.pair()? { current.get() } 这类 question-wrapped iterable for loop binding，以及 for current in (if flag { config.children? } else { config.children? }) { current.value } / for current in match flag { true => config.pair()?, false => config.pair()? } { current.get() } 这类 structured question-wrapped iterable for loop binding的 success-path 与 broken-source fallback 形态，避免 package analysis 退回到普通 local query 语义；其中 for current in (config, config) { current.value } 与 for current in [config.child(), config.child()] { current.value } 这组 direct root token 现已同时由 success-path 与 broken-source fallback 的独立 regression 锁住，而 let current = config.child(); let alias = current; let first = alias.value; let second = alias.value; return "oops" 这条 method-call result direct alias local root token 这轮也已补齐到同一条 broken-source fallback，let current = config.child; let alias = current; let first = alias.value; let second = alias.value; return "oops" 这条 field-projection result direct alias local root token 这轮也已补齐到同一条 broken-source fallback，let current = { config.child() }; let alias = current; let first = alias.value; let second = alias.value; return "oops" 这条 block-tail result direct alias local root token 这轮也已补齐到同一条 broken-source fallback，extend Cfg { pub fn read(self) -> Int { let first = self.value; let second = self.value; return "oops" } } 这条 self receiver root token 这轮也已补齐到同一条 broken-source fallback，let project = (current: Cfg) => { let first = current.value; let second = current.value; return "oops" } 这条 typed closure param root token 这轮也已补齐到同一条 broken-source fallback。
同一条 structured result local 的 direct root token 现在也已由独立 regression 单独锁住 let current = if flag { config.child() } else { config.child() }; current.value 与 let current = match flag { true => config.child(), false => config.child() }; current.value 这两条 direct structured local root query / typeDefinition：无论成功 package analysis 还是 broken-source fallback，current token 都会继续固定到 dependency public Child declaration，并保留当前文件内同一 local binding 的 query 结果；连同此前已单独锁住的 structured direct alias root fallback，这条 structured result local value-root contract 现已闭合；这轮再把 let current = { config.child() }; current.value 这条 direct block-tail local root 也用独立 regression 补齐到 success-path + broken-source fallback，因此 block-tail local root token 现在也已接通同一条 dependency query / typeDefinition truth surface
ql-analysis / ql-lsp 当前也已开放 use ... 导入路径位置上的 dependency completion：例如 use demo.d 可补全到 dep，use demo.dep.Bu 与 use demo.dep.{Bu} 都可补全到 .qi 里的 Buffer；grouped import 空补全位当前也会跳过已经写过的项，避免重复提示；该能力当前只覆盖导入路径，不代表更广义 symbol-space cross-file completion 已完成
ql-lsp 当前已把 workspace/symbol 扩到保守的 package-aware + dependency-aware 子集：只要当前有一个已打开文档能成功装载其 package，搜索就会扩到该 package 的全部源码 modules、同一 workspace 的其它 member package 源码 modules，以及已加载 dependency .qi artifact 里的 public symbols；同包里已打开且可成功分析的源码文档会优先覆盖磁盘版本。若当前包因为 source diagnostics 失败，则会退回到 manifest-aware fallback：当前打开文档仍按 same-file analysis 搜索，同时继续保留 dependency .qi 与 sibling workspace member source modules 的搜索；只有更底层的 manifest/package 加载失败时，才退回为当前已打开且可成功分析的源码文档。当前仍不会搜索未打开且与活动 package 无关的其它 packages、full workspace graph，或未加载的 dependency artifacts
上述 dependency-only 回退当前还额外覆盖了一个编辑中断场景：如果当前文档暂时存在 same-file 语义错误，只要 package manifest 与 dependency .qi 仍可装载，真实 ql-lsp backend 现在会在 source analysis 成功前先尝试 use ... 导入路径上的 dependency path segment / public symbol completion、dependency enum import-local root（alias、direct import、grouped direct import）上的 variant completion，以及 dependency struct explicit field-label completion；同一条回退链现在也已开放 imported dependency local name 的最小 hover / definition / declaration / references 查询，覆盖 import binding token 本身，以及 parse-only 可恢复的 single-segment use site/type root（例如 run(1)、Buf[Int]）；dependency enum variant token、explicit / shorthand struct-field token，以及语法局部可恢复出的 dependency struct receiver/member token 现在也已在同一路径下补齐最小 hover / definition / declaration / references 回退，覆盖 named local、typed closure param、direct dependency method-call、inline tuple/array for loop receiver，以及收敛 block/if/match 结果的 direct receiver，而 dependency enum variant token 的最小 textDocument/typeDefinition 回退现在也已接到同一路径上；同一条回退链里的 dependency value root 现在还额外补上了 hover / definition / declaration / references fallback，除了 parse-only 可恢复的 dependency named local、typed closure param、inline tuple/array for loop binding 与 impl / extend 方法体 self receiver 之外，也已覆盖 value-position 的 imported dependency function / const / static root token，并继续把结果固定到 dependency public struct declaration 与当前文件内仍解析到同一 root binding 的引入/使用位置；同一 receiver slice 上的 member-field / member-method completion 也可继续工作，而 let current = config; let value = current.get(); return "oops" 这类 broken-source named local receiver method definition fallback 现也已由独立 regression 单独锁住；它仍不扩展到 broader member query 或其它同文件语义查询
同一条 imported dependency value root 现在也已由独立 regression 单独锁住最小 member completion 合同：return load().va / return load().ge 这组 imported dependency function-result root，以及 return current.va / return current.ge 这组 imported dependency static root，现在都已在成功 package analysis 路径与 same-file semantic-error fallback 上稳定只补出 dependency field value / method get；这让 value-position 的 imported dependency function / static root token member completion 不再只散落在既有混合 bindings 回归里。
同一条 imported dependency value root 现在也已由独立 regression 单独锁住最小 member query 合同：let first = load().value; let second = load().value / let first = load().get(); let second = load().get() 这组 imported dependency function-result root member token，以及 let first = current.value; let second = current.value / let first = current.get(); let second = current.get() 这组 imported dependency static root member token，现在都已在成功 package analysis 路径与 same-file semantic-error fallback 上由独立 regression 锁住 hover / definition / declaration / references；这让 value-position 的 imported dependency function / static root member query 也不再只散落在既有混合 bindings 回归里。
同一条 imported dependency value root 现在也已由独立 regression 单独锁住最小 member typeDefinition 合同：return load().leaf.value / return load().leaf().value 这组 imported dependency function-result root member token，以及 return current.leaf.value / return current.leaf().value 这组 imported dependency static root member token，现在都已在成功 package analysis 路径与 same-file semantic-error fallback 上由独立 regression 锁住到 dependency public Leaf declaration；这让 value-position 的 imported dependency function / static root member typeDefinition 也不再只散落在既有混合测试里。
同一条 imported dependency value root 这轮也补上了最小 standalone bindings regression：return load().value 与 return current.value 这两条路径，现已在成功 package analysis 路径上单独锁住 dependency field definition，而 let first = load().get() / let second = current.get(); return "oops" 这组 imported dependency function-result / static root 绑定后的 direct member definition，也已在 broken-source fallback 上由独立 regression 锁住到 dependency public method declaration；这让 value-position 的 imported dependency function / static root 最小 local-binding contract 也不再只散落在既有混合 bindings 回归里。
上述 dependency-only 回退里的 for loop receiver 现也不再只限 direct tuple/array root；对应的 parse-only value-root fallback 也会继续复用同一 binding identity，因此 structured iterable root 下的 for current in { (config, config) } { current.value } / for current in match flag { ... } { current.get() } 也会落在同一条 dependency-only 容错合同里，而 imported root token 现在也已在同一路径下接通 hover / definition / declaration / references 与 typeDefinition，覆盖 non-iterable value root（例如 maybe_load()?.value 上的 maybe_load、child?.value 上的 child、load_cfg()?.value 上的 load_cfg、maybe_cfg?.value 上的 maybe_cfg）以及 iterable root（例如 for current in children() { current.get() } 上的 children、for current in ITEMS { current.get() } 上的 ITEMS、for current in maybe_children()? { current.get() } 上的 maybe_children、for current in items? { current.get() } 上的 items，grouped import alias 形态下 kids() / items 上的 alias token，以及 grouped alias + question-wrapped 形态下 kids()? / maybe_items? 上的 alias token）；其中 grouped alias non-iterable value root token、grouped alias iterable root token、question-wrapped imported iterable/value root token，以及 grouped alias + question-wrapped root token 的 typeDefinition 也都已显式锁定在这条 fallback 上，而 direct maybe_load()? / child? 这组 question-wrapped non-iterable root、direct maybe_children()? / items? 这组 question-wrapped iterable root、grouped load_cfg()? / maybe_cfg? 这组 question-wrapped non-iterable root，以及 grouped kids()? / maybe_items? 这组 question-wrapped iterable root 的 fallback query + typeDefinition 现在也都已分别由独立 regression 锁定；此前已补齐的是 structured direct function iterable fallback 里的 (if flag { maybe_children()? } else { maybe_children()? }) root token query / typeDefinition，随后又把 match flag { true => maybe_children()?, false => maybe_children()? } 这条 structured direct function iterable fallback 锁住，而这轮再把 direct static 形态下 (if flag { child? } else { child? })、match flag { true => child?, false => child? }、(if flag { items? } else { items? }) 与 match flag { true => items?, false => items? }，以及 grouped alias 形态下 (if flag { maybe_cfg? } else { maybe_cfg? })、match flag { true => maybe_cfg?, false => maybe_cfg? }、(if flag { load_cfg()? } else { load_cfg()? })、match flag { true => load_cfg()?, false => load_cfg()? }、(if flag { kids()? } else { kids()? }) 与 match flag { true => kids()?, false => kids()? } 这十条 structured root fallback 也用独立 regression 锁住了；本轮又把 grouped static 形态下 (if flag { maybe_items? } else { maybe_items? }) 与 match flag { true => maybe_items?, false => maybe_items? } 这两条 structured iterable root fallback 也单独锁住了，同时把 structured grouped-import completion fallback matrix 也用独立 regression 锁到 field/method 两侧，覆盖 for current in (if flag { kids()? } else { kids()? }) { current.va } / for current in (if flag { kids()? } else { kids()? }) { current.ge }、for current in (if flag { maybe_items? } else { maybe_items? }) { current.va } / for current in (if flag { maybe_items? } else { maybe_items? }) { current.ge }、for current in match flag { true => kids()?, false => kids()? } { current.va } / for current in match flag { true => kids()?, false => kids()? } { current.ge }，以及 for current in match flag { true => maybe_items?, false => maybe_items? } { current.va } / for current in match flag { true => maybe_items?, false => maybe_items? } { current.ge }；此前已锁住的 direct maybe_children()?、grouped maybe_cfg?、grouped load_cfg()?、grouped kids()? 与同文件 helper 返回的 [Child; 2] 这类 root 则继续复用各自对应的 dependency-only query fallback。
dependency enum import-local root 的首个非导入路径 contract 现已开放：当 use demo.dep.Command as Cmd、use demo.dep.Command 或 use demo.dep.{Command} 这类导入形态能唯一映射到 dependency .qi 里的 public enum 时，Cmd.Re / Command.Re 这类路径位置现在都会补全 dependency variants，而 Cmd.Retry / Command.Retry 这类已写出的 variant token 也都已支持 cross-file hover / definition / declaration / references，并可通过 textDocument/typeDefinition 跳到 dependency enum declaration；当当前文档仅有 same-file 语义错误时，真实 ql-lsp backend 现在也会继续从该 variant token 提供 dependency hover / definition / declaration / references 与 typeDefinition 回退。当前这条能力只覆盖 enum variant roots，还不代表更广义 dependency member completion 已完成
dependency struct import-local root 的首个 field contract 现也已继续扩到 value/member path：当 use demo.dep.Config as Cfg、use demo.dep.Config 或 use demo.dep.{Config} 这类导入形态能唯一映射到 dependency .qi 里的 public struct 时，Cfg { fl: true } / Config { fl: true } 与 let Cfg { fl: enabled } = built / let Config { fl: enabled } = built 这类显式 struct literal / struct pattern 字段标签现在已支持 dependency public field completion，并会跳过同一字面量/模式里已经写过的 sibling 字段；struct literal / struct pattern 里已写出的字段 token 当前继续支持 cross-file hover / definition / declaration / references，覆盖 explicit 与 shorthand 两种写法；此外，对能从语法局部恢复出 dependency struct 类型的 value/member receiver（当前覆盖 dependency-typed param、typed closure param、带 dependency type annotation 的 let、dependency struct literal let 结果、dependency method-call result、direct dependency field-projection result、struct destructuring / match destructuring 派生的 dependency local、inline tuple/array for loop binding、? 解包后的 dependency receiver、block tail result及其 direct alias、收敛到同一个 dependency struct 的 if / match 结果、它们的 direct alias、不经命名 local 的 direct dependency field-projection / method-call / structured receiver，以及 target 可唯一恢复为 dependency struct 的 impl / extend 方法体 self receiver），config.value / built.value / current.value / config.child.value / config.child?.value / config.child().value / self.value / let current = config.child; current.value / let current = if flag { config.child() } else { config.child() }; let alias = current; alias.value / let current = match flag { true => config.child(), false => config.child() }; let alias = current; alias.value / let current = { config.child() }; let alias = current; alias.value / let Cfg { child } = config; child.value / for current in (config, config) { current.value } / let project = (current: Cfg) => current.value 这类 member field token 现在也已接通同一条 dependency hover / definition / declaration / references 合同，而 config.va / built.va / (if ...).va / current.va / let current = if flag { config.child() } else { config.child() }; let alias = current; alias.va / let current = match flag { true => config.child(), false => config.child() }; let alias = current; alias.va / let current = { config.child() }; let alias = current; alias.va 这类 syntax-local member prefix 也已接通最小 dependency field completion；这轮又把 let current = config; current.value 这类最直接的 named local receiver field definition、return current.va / return current.ge 这组 named local receiver member completion、let first = current.value; let second = current.value / let first = current.get(); let second = current.get() 这组 named local receiver member query，以及 current.leaf.value / current.leaf().value 这组 named local receiver member typeDefinition 单独抽成独立 regression；更广义 member completion 仍未开放，而 destructured local receiver 的 return child.va / return child.ge 这组 standalone member completion 与 let Cfg { child } = config; let first = child.value; let second = child.value / let Cfg { child } = config; let first = child.get(); let second = child.get() 连同 broken-source 下 let Cfg { child } = config; let first = child.value; let second = child.value; return "oops" / let Cfg { child } = config; let first = child.get(); let second = child.get(); return "oops" 这组 standalone member query 现也已单独锁住
同一条 destructured local receiver 这轮也把最小 standalone bindings 从旧混合回归里单独抽成了 regression 文件：let Cfg { child } = config; return child.value 现已在成功 package analysis 路径上由独立 regression 锁住 dependency field definition，而 match config { Cfg { child } => child.get() } 这条绑定后的 direct member definition 也已在 broken-source fallback 上由独立 regression 锁住到 dependency public method declaration；这让这条 receiver 的 local-binding contract 也不再只靠早期混合 destructured_dependency_bindings regression 隐式兜底。
dependency struct import-local root 的首个 field contract 现也已继续扩到 value/member path：当 use demo.dep.Config as Cfg 唯一映射到 dependency .qi 里的 public struct 时，Cfg { fl: true } / let Cfg { fl: enabled } = built 这类显式 struct literal / struct pattern 字段标签现在已支持 dependency public field completion，并会跳过同一字面量/模式里已经写过的 sibling 字段；struct literal / struct pattern 里已写出的字段 token 当前继续支持 cross-file hover / definition / declaration / references，覆盖 explicit 与 shorthand 两种写法；此外，对能从语法局部恢复出 dependency struct 类型的 value/member receiver（当前覆盖 dependency-typed param、typed closure param、带 dependency type annotation 的 let、dependency struct literal let 结果、dependency method-call result、direct dependency field-projection result、struct destructuring / match destructuring 派生的 dependency local、inline tuple/array for loop binding、? 解包后的 dependency receiver、block tail result及其 direct alias、收敛到同一个 dependency struct 的 if / match 结果、它们的 direct alias、不经命名 local 的 direct dependency field-projection / method-call / structured receiver，以及 target 可唯一恢复为 dependency struct 的 impl / extend 方法体 self receiver），config.value / built.value / current.value / config.child.value / config.child?.value / config.child().value / self.value / let current = config.child; current.value / let current = if flag { config.child() } else { config.child() }; let alias = current; alias.value / let current = match flag { true => config.child(), false => config.child() }; let alias = current; alias.value / let current = { config.child() }; let alias = current; alias.value / let Cfg { child } = config; child.value / for current in (config, config) { current.value } / let project = (current: Cfg) => current.value 这类 member field token 现在也已接通同一条 dependency hover / definition / declaration / references 合同，而 config.va / built.va / (if ...).va / current.va / let current = if flag { config.child() } else { config.child() }; let alias = current; alias.va / let current = match flag { true => config.child(), false => config.child() }; let alias = current; alias.va / let current = { config.child() }; let alias = current; alias.va 这类 syntax-local member prefix 也已接通最小 dependency field completion；这轮又把 let current = config; current.value 这类最直接的 named local receiver field definition、return current.va / return current.ge 这组 named local receiver member completion、let first = current.value; let second = current.value / let first = current.get(); let second = current.get() 这组 named local receiver member query，以及 current.leaf.value / current.leaf().value 这组 named local receiver member typeDefinition 单独抽成独立 regression；更广义 member completion 仍未开放，而 direct structured receiver 的 return (if flag { config.child() } else { config.child() }).va / .ge 与 return (match flag { true => config.child(), false => config.child() }).va / .ge 这组 standalone member completion 现也已单独锁住
dependency struct import-local root 的首个 field contract 现也已继续扩到 value/member path：当 use demo.dep.Config as Cfg 唯一映射到 dependency .qi 里的 public struct 时，Cfg { fl: true } / let Cfg { fl: enabled } = built 这类显式 struct literal / struct pattern 字段标签现在已支持 dependency public field completion，并会跳过同一字面量/模式里已经写过的 sibling 字段；struct literal / struct pattern 里已写出的字段 token 当前继续支持 cross-file hover / definition / declaration / references，覆盖 explicit 与 shorthand 两种写法；此外，对能从语法局部恢复出 dependency struct 类型的 value/member receiver（当前覆盖 dependency-typed param、typed closure param、带 dependency type annotation 的 let、dependency struct literal let 结果、dependency method-call result、direct dependency field-projection result、struct destructuring / match destructuring 派生的 dependency local、inline tuple/array for loop binding、? 解包后的 dependency receiver、block tail result及其 direct alias、收敛到同一个 dependency struct 的 if / match 结果、它们的 direct alias、不经命名 local 的 direct dependency field-projection / method-call / structured receiver，以及 target 可唯一恢复为 dependency struct 的 impl / extend 方法体 self receiver），config.value / built.value / current.value / config.child.value / config.child?.value / config.child().value / self.value / let current = config.child; current.value / let current = if flag { config.child() } else { config.child() }; let alias = current; alias.value / let current = match flag { true => config.child(), false => config.child() }; let alias = current; alias.value / let current = { config.child() }; let alias = current; alias.value / let Cfg { child } = config; child.value / for current in (config, config) { current.value } / let project = (current: Cfg) => current.value 这类 member field token 现在也已接通同一条 dependency hover / definition / declaration / references 合同，而 config.va / built.va / (if ...).va / current.va / let current = if flag { config.child() } else { config.child() }; let alias = current; alias.va / let current = match flag { true => config.child(), false => config.child() }; let alias = current; alias.va / let current = { config.child() }; let alias = current; alias.va 这类 syntax-local member prefix 也已接通最小 dependency field completion；这轮又把 let current = config; current.value 这类最直接的 named local receiver field definition、return current.va / return current.ge 这组 named local receiver member completion、let first = current.value; let second = current.value / let first = current.get(); let second = current.get() 这组 named local receiver member query，以及 current.leaf.value / current.leaf().value 这组 named local receiver member typeDefinition 单独抽成独立 regression；更广义 member completion 仍未开放，而 direct structured receiver 的 return (if flag { config.child() } else { config.child() }).va / .ge 与 return (match flag { true => config.child(), false => config.child() }).va / .ge 这组 standalone member completion，以及 let first = (if flag { config.child() } else { config.child() }).value; let second = (if flag { config.child() } else { config.child() }).value / .get() 与 let first = (match flag { true => config.child(), false => config.child() }).value; let second = (match flag { true => config.child(), false => config.child() }).value / .get() 这组 standalone member query 现也已单独锁住
dependency struct import-local root 的首个 field contract 现也已继续扩到 value/member path：当 use demo.dep.Config as Cfg 唯一映射到 dependency .qi 里的 public struct 时，Cfg { fl: true } / let Cfg { fl: enabled } = built 这类显式 struct literal / struct pattern 字段标签现在已支持 dependency public field completion，并会跳过同一字面量/模式里已经写过的 sibling 字段；struct literal / struct pattern 里已写出的字段 token 当前继续支持 cross-file hover / definition / declaration / references，覆盖 explicit 与 shorthand 两种写法；此外，对能从语法局部恢复出 dependency struct 类型的 value/member receiver（当前覆盖 dependency-typed param、typed closure param、带 dependency type annotation 的 let、dependency struct literal let 结果、dependency method-call result、direct dependency field-projection result、struct destructuring / match destructuring 派生的 dependency local、inline tuple/array for loop binding、? 解包后的 dependency receiver、block tail result及其 direct alias、收敛到同一个 dependency struct 的 if / match 结果、它们的 direct alias、不经命名 local 的 direct dependency field-projection / method-call / structured receiver，以及 target 可唯一恢复为 dependency struct 的 impl / extend 方法体 self receiver），config.value / built.value / current.value / config.child.value / config.child?.value / config.child().value / self.value / let current = config.child; current.value / let current = if flag { config.child() } else { config.child() }; let alias = current; alias.value / let current = match flag { true => config.child(), false => config.child() }; let alias = current; alias.value / let current = { config.child() }; let alias = current; alias.value / let Cfg { child } = config; child.value / for current in (config, config) { current.value } / let project = (current: Cfg) => current.value 这类 member field token 现在也已接通同一条 dependency hover / definition / declaration / references 合同，而 config.va / built.va / (if ...).va / current.va / let current = if flag { config.child() } else { config.child() }; let alias = current; alias.va / let current = match flag { true => config.child(), false => config.child() }; let alias = current; alias.va / let current = { config.child() }; let alias = current; alias.va 这类 syntax-local member prefix 也已接通最小 dependency field completion；这轮又把 let current = config; current.value 这类最直接的 named local receiver field definition、return current.va / return current.ge 这组 named local receiver member completion、let first = current.value; let second = current.value / let first = current.get(); let second = current.get() 这组 named local receiver member query，以及 current.leaf.value / current.leaf().value 这组 named local receiver member typeDefinition 单独抽成独立 regression；更广义 member completion 仍未开放，而 direct structured receiver 的 return (if flag { config.child() } else { config.child() }).va / .ge 与 return (match flag { true => config.child(), false => config.child() }).va / .ge 这组 standalone member completion、let first = (if flag { config.child() } else { config.child() }).value; let second = (if flag { config.child() } else { config.child() }).value / .get() 与 let first = (match flag { true => config.child(), false => config.child() }).value; let second = (match flag { true => config.child(), false => config.child() }).value / .get() 这组 standalone member query，以及 return (if flag { config.child() } else { config.child() }).leaf.value / .leaf().value 与 return (match flag { true => config.child(), false => config.child() }).leaf.value / .leaf().value 这组 standalone member typeDefinition 现也已单独锁住；direct structured receiver 的 standalone bindings / completion / query / member typeDefinition 至此全部闭合
同一条 direct block-tail receiver slice 现也已全部拆完 standalone member regression：此前已独立锁住 return ({ config.child() }).va / .ge 这组 completion，以及 let first = ({ config.child() }).value; let second = ({ config.child() }).value; ... / .get() 这组 query；这轮再把 return ({ config.child() }).leaf.value / .leaf().value 这组 member typeDefinition 单独锁住；direct block-tail receiver 的 standalone completion / query / typeDefinition 至此全部闭合
dependency struct method/member path 的首个 method contract 现也已补齐到 completion 与 broken-source fallback：当 use demo.dep.Config as Cfg 能唯一映射到 dependency public struct，并且 .qi 中存在对该 nominal struct 的唯一 public method（遵守 impl 优先、再看 extend 的当前同文件规则）时，config.get() / built.get() / current.get() / config.child.get() / config.child()?.get() / config.child().get() / self.get() / let current = config.child; current.get() / let current = if flag { config.child() } else { config.child() }; let alias = current; alias.get() / let current = match flag { true => config.child(), false => config.child() }; let alias = current; alias.get() / let current = { config.child() }; let alias = current; alias.get() / match config { Cfg { child } => child.get() } / for current in [config.child(), config.child()] { current.get() } / let project = (current: Cfg) => current.get() 这类 member method token 现在已在成功分析路径与 same-file semantic-error fallback 上都支持 cross-file hover / definition / declaration / references，而 config.ge / built.ge / (match ...).ge / current.ge / let current = if flag { config.child() } else { config.child() }; let alias = current; alias.ge / let current = match flag { true => config.child(), false => config.child() }; let alias = current; alias.ge / let current = { config.child() }; let alias = current; alias.ge 这类 syntax-local member prefix 也已接通最小 dependency method completion；当前这条 receiver slice 也已继续扩到 typed closure param、direct dependency field-projection result、struct destructuring / match destructuring 派生的 dependency local、inline tuple/array for loop binding、? 解包后的 dependency receiver、block tail result及其 direct alias、收敛到同一个 dependency struct 的 if / match 结果、不经命名 local 的 direct dependency field-projection / method-call / structured receiver，以及 target 可唯一恢复为 dependency struct 的 impl / extend 方法体 self receiver，但仍不扩展到 broader dependency member semantics
上述 target 可唯一恢复为 dependency struct 的 impl / extend 方法体 self receiver 现在也已由独立 regression 单独锁住 extend Cfg { pub fn read(self) -> Int { let first = self.value; let second = self.value; ... } } 与 extend Cfg { pub fn read(self) -> Int { let first = self.get(); let second = self.get(); ... } } 这两条 member query：无论成功 package analysis 还是 same-file semantic-error fallback，hover / definition / declaration / references 都继续固定到 dependency public member declaration 与同一方法体里的本地 self member 引用；当前只是把 self receiver 的 member query 单独抽出，还不代表 self receiver 上的 completion / member typeDefinition 已全部拆成 standalone regression
同一条 dependency self receiver 现在也已由独立 regression 单独锁住 extend Cfg { pub fn read(self) -> Int { return self.va } } 与 extend Cfg { pub fn read(self) -> Int { return self.ge } } 这两条 member prefix completion：无论成功 package analysis 还是 same-file semantic-error fallback，self.va 仍只补出 dependency field value，self.ge 仍只补出 dependency method get，并继续沿用同一条 syntax-local dependency receiver identity
同一条 dependency self receiver 现在也已由独立 regression 单独锁住 extend Cfg { pub fn read(self) -> Int { return self.leaf.value } } 与 extend Cfg { pub fn read(self) -> Int { return self.leaf().value } } 这两条 member typeDefinition：无论成功 package analysis 还是 same-file semantic-error fallback，field token leaf 与 method token leaf 都会继续跳到 dependency public Leaf declaration；连同此前已独立锁住的 self receiver value-root query / typeDefinition、member query 与 completion，以及已存在的 member definition，这条 dependency self receiver 的 standalone completion / query / definition / typeDefinition 合同现已闭合
同一条 typed closure parameter receiver 现在也已由独立 regression 单独锁住 let project = (current: Cfg) => current.va 与 let project = (current: Cfg) => current.ge 这两条 member prefix completion：无论成功 package analysis 还是 same-file semantic-error fallback，current.va 仍只补出 dependency field value，current.ge 仍只补出 dependency method get；当前 typed closure receiver 已独立锁住的是 value-root query / typeDefinition 与 completion，member query / member typeDefinition 仍待继续拆出 standalone regression
同一条 typed closure parameter receiver 现在也已由独立 regression 单独锁住 let project = (current: Cfg) => { let first = current.value; let second = current.value; ... } 与 let project = (current: Cfg) => { let first = current.get(); let second = current.get(); ... } 这两条 member query：无论成功 package analysis 还是 same-file semantic-error fallback，hover / definition / declaration / references 都继续固定到 dependency public member declaration 与同一 closure body 里的本地 member 引用；当前 typed closure receiver 已独立锁住的是 value-root query / typeDefinition、completion 与 member query，而 member typeDefinition 仍待继续拆出 standalone regression
同一条 typed closure parameter receiver 现在也已由独立 regression 单独锁住 let project = (current: Cfg) => current.leaf.value 与 let project = (current: Cfg) => current.leaf().value 这两条 member typeDefinition：无论成功 package analysis 还是 same-file semantic-error fallback，field token leaf 与 method token leaf 都会继续跳到 dependency public Leaf declaration；连同此前已独立锁住的 typed closure receiver value-root query / typeDefinition、completion 与 member query，以及已存在的 member definition，这条 typed closure receiver 的 standalone completion / query / definition / typeDefinition 合同现已闭合
同一条 typed closure parameter receiver 这轮也补上了最小 standalone bindings regression：let project = (current: Cfg) => current.value 现已在成功 package analysis 路径上单独锁住 dependency field definition，而 let project = (current: Cfg) => current.get(); let value = project(config); return "oops" 这条绑定后的 direct member definition 也已在 broken-source fallback 上由独立 regression 锁住到 dependency public method declaration；这让 typed closure receiver 的最小 local-binding contract 也不再只散落在 value-root / member 专项回归里。
同一条 direct dependency field-projection result local 的 alias receiver 现在也已由独立 regression 单独锁住 let current = config.child; let alias = current; return alias.value 与 let current = config.child; let alias = current; let value = alias.get(); ... 这两条 member definition：前者在成功 package analysis 路径下继续把 field token value 跳到 dependency public field declaration，后者在 same-file semantic-error fallback 上继续把 method token get 跳到 dependency public method declaration
同一条 direct dependency field-projection result local 的 alias receiver 现在也已由独立 regression 单独锁住 let current = config.child; let alias = current; return alias.va 与 let current = config.child; let alias = current; return alias.ge 这两条 member prefix completion：无论成功 package analysis 还是 same-file semantic-error fallback，alias.va 仍只补出 dependency field value，alias.ge 仍只补出 dependency method get
同一条 direct dependency field-projection result local 的 alias receiver 现在也已由独立 regression 单独锁住 let current = config.child; let alias = current; let first = alias.value; let second = alias.value; ... 与 let current = config.child; let alias = current; let first = alias.get(); let second = alias.get(); ... 这两条 member query：无论成功 package analysis 还是 same-file semantic-error fallback，hover / definition / declaration / references 都继续固定到 dependency public member declaration 与当前文件内同一 alias receiver 的本地 member 引用
同一条 direct dependency field-projection result local 的 alias receiver 现在也已由独立 regression 单独锁住 let current = config.child; let alias = current; return alias.leaf.value 与 let current = config.child; let alias = current; return alias.leaf().value 这两条 member typeDefinition：无论成功 package analysis 还是 same-file semantic-error fallback，field token leaf 与 method token leaf 都会继续跳到 dependency public Leaf declaration；连同此前已单独锁住的 projected-field alias receiver value-root query / typeDefinition、member definition、completion 与 member query，这条 receiver 的 standalone completion / query / definition / typeDefinition 合同现已闭合
同一条 direct dependency field-projection result receiver 现在也已由独立 regression 单独锁住 return config.child.va 与 return config.child.ge 这两条 member prefix completion：无论成功 package analysis 还是 same-file semantic-error fallback，config.child.va 仍只补出 dependency field value，config.child.ge 仍只补出 dependency method get
同一条 direct dependency field-projection result receiver 现在也已由独立 regression 单独锁住 let first = config.child.value; let second = config.child.value; ... 与 let first = config.child.get(); let second = config.child.get(); ... 这两条 member query：无论成功 package analysis 还是 same-file semantic-error fallback，hover / definition / declaration / references 都继续固定到 dependency public member declaration 与当前文件内同一 direct receiver 的本地 member 引用
同一条 direct dependency field-projection result receiver 现在也已由独立 regression 单独锁住 return config.child.leaf.value 与 return config.child.leaf().value 这两条 member typeDefinition：无论成功 package analysis 还是 same-file semantic-error fallback，field token leaf 与 method token leaf 都会继续跳到 dependency public Leaf declaration；连同此前已单独锁住的 direct projected-field receiver completion 与 member query，这条 receiver 的 standalone completion / query / typeDefinition 合同现已闭合
同一条 dependency method-call result local 的 alias receiver 现在也已由独立 regression 单独锁住 let current = config.child(); let alias = current; return alias.value 与 let current = config.child(); let alias = current; let value = alias.get(); ... 这两条 member definition：前者在成功 package analysis 路径下继续把 field token value 跳到 dependency public field declaration，后者在 same-file semantic-error fallback 上继续把 method token get 跳到 dependency public method declaration
同一条 dependency method-call result local 的 alias receiver 现在也已由独立 regression 单独锁住 let current = config.child(); let alias = current; return alias.va 与 let current = config.child(); let alias = current; return alias.ge 这两条 member prefix completion：无论成功 package analysis 还是 same-file semantic-error fallback，alias.va 仍只补出 dependency field value，alias.ge 仍只补出 dependency method get
同一条 dependency method-call result local 的 alias receiver 现在也已由独立 regression 单独锁住 let current = config.child(); let alias = current; let first = alias.value; let second = alias.value; ... 与 let current = config.child(); let alias = current; let first = alias.get(); let second = alias.get(); ... 这两条 member query：无论成功 package analysis 还是 same-file semantic-error fallback，hover / definition / declaration / references 都继续固定到 dependency public member declaration 与当前文件内同一 alias receiver 的本地 member 引用
同一条 dependency method-call result local 的 alias receiver 现在也已由独立 regression 单独锁住 let current = config.child(); let alias = current; return alias.leaf.value 与 let current = config.child(); let alias = current; return alias.leaf().value 这两条 member typeDefinition：无论成功 package analysis 还是 same-file semantic-error fallback，field token leaf 与 method token leaf 都会继续跳到 dependency public Leaf declaration；连同此前已单独锁住的 method-result alias receiver value-root query / typeDefinition、member definition、completion 与 member query，这条 receiver 的 standalone completion / query / definition / typeDefinition 合同现已闭合
同一条 direct dependency method-call result receiver 现在也已由独立 regression 单独锁住 return config.child().va 与 return config.child().ge 这两条 member prefix completion：无论成功 package analysis 还是 same-file semantic-error fallback，config.child().va 仍只补出 dependency field value，config.child().ge 仍只补出 dependency method get
同一条 direct dependency method-call result receiver 现在也已由独立 regression 单独锁住 let first = config.child().value; let second = config.child().value; ... 与 let first = config.child().get(); let second = config.child().get(); ... 这两条 member query：无论成功 package analysis 还是 same-file semantic-error fallback，hover / definition / declaration / references 都继续固定到 dependency public member declaration 与当前文件内同一 direct receiver 的本地 member 引用
同一条 direct dependency method-call result receiver 现在也已由独立 regression 单独锁住 return config.child().leaf.value 与 return config.child().leaf().value 这两条 member typeDefinition：无论成功 package analysis 还是 same-file semantic-error fallback，field token leaf 与 method token leaf 都会继续跳到 dependency public Leaf declaration；连同此前已单独锁住的 direct method-result receiver completion 与 member query，这条 receiver 的 standalone completion / query / typeDefinition 合同现已闭合
同一条 direct dependency method-call result receiver 这轮也补上了最小 standalone bindings regression：return config.child().value 现已在成功 package analysis 路径上单独锁住 dependency field definition，而 let value = config.child().get(); return "oops" 这条绑定后的 direct member definition 也已在 broken-source fallback 上由独立 regression 锁住到 dependency public method declaration；这让 direct method-result receiver 的最小 local-binding contract 也不再只散落在既有 member 专项回归里。
上述 block tail result local 的 direct alias receiver 现在也已由独立 regression 单独锁住 let current = { config.child() }; let alias = current; alias.value 与 let current = { config.child() }; let alias = current; alias.get() 这两条 member query：无论成功 package analysis 还是 same-file semantic-error fallback，hover / definition / declaration / references 都继续固定到 dependency public member declaration 与当前文件内同一 alias receiver 的本地引用；连同此前已单独锁住的同 receiver 上的 value-root query / typeDefinition、member definition / typeDefinition 与 completion，这条 block-tail alias receiver 的 standalone completion / query / definition / typeDefinition 合同现已闭合
同一条 direct block-tail receiver 现在也已由独立 regression 单独锁住 let first = ({ config.child() }).value; let second = ({ config.child() }).value; ... 与 let first = ({ config.child() }).get(); let second = ({ config.child() }).get(); ... 这两条 member query：无论成功 package analysis 还是 same-file semantic-error fallback，hover / definition / declaration / references 都继续固定到 dependency public member declaration 与当前文件内同一 direct receiver 的本地 member 引用；连同此前已单独锁住的 direct block-tail receiver completion，这条 receiver 的 standalone completion / query 合同现已收口，剩余待拆的只剩 member typeDefinition
同一条 direct block-tail receiver 现在也已由独立 regression 单独锁住 return ({ config.child() }).leaf.value 与 return ({ config.child() }).leaf().value 这两条 member typeDefinition：无论成功 package analysis 还是 same-file semantic-error fallback，field token leaf 与 method token leaf 都会继续跳到 dependency public Leaf declaration；连同此前已单独锁住的 direct block-tail receiver completion 与 member query，这条 receiver 的 standalone completion / query / typeDefinition 合同现已闭合
同一条 direct block-tail receiver 这轮也补上了最小 standalone bindings regression：return ({ config.child() }).value 现已在成功 package analysis 路径上单独锁住 dependency field definition，而 let value = ({ config.child() }).get(); return "oops" 这条绑定后的 direct member definition 也已在 broken-source fallback 上由独立 regression 锁住到 dependency public method declaration；这让 direct block-tail receiver 的最小 local-binding contract 也不再只散落在既有 member 专项回归里。
dependency .qi 现在也已开放第一段 import-local rename 消费：当当前文件通过 use ... as Alias、use demo.dep.Config 或 grouped import 形态引入 dependency public symbol 时，导入到当前文件内的 local name 以及对应的 type/value 使用位置，现都已支持最小 textDocument/prepareRename 与 textDocument/rename；其中 direct import / grouped direct import 的定义位 rename 会自动改写成 Config as NewName 这类合法 alias 形式，而不是错误地改写 dependency path 本身；同一条 rename 现在也会在 package analysis 成功路径与 dependency-only broken-source fallback 上复用，而不会因为当前文件存在 same-file semantic errors 就整体失效。当前这条能力仍只覆盖 imported dependency local name，不扩到 dependency member token，或跨文件 workspace edit。

当前仍未开放：

dependency .qi 的更广义 rename 与更广义非导入路径 completion 的 cross-file 消费
真实 package build graph
dependency invalidation
更广义的 cross-file query / rename / completion

sync build 子集

当前 sync build surface 已稳定覆盖：

顶层 free function
unsafe fn body
extern "c" 顶层声明、extern block、顶层导出定义
main 程序入口
标量整数 / Bool / Void
最小 String 值传递子集
- UTF-8 string literal lowering 为 { ptr, i64 }
- direct literal local binding
- same-file const / static string item materialization
- 普通参数传递与返回值
- == / != / < / <= / > / >= compare lowering
- ordinary string match：当前已覆盖 direct literal arm、same-file const / static path pattern，以及 _ / binding catch-all，并继续复用现有 bool guard 子集
- ordinary capturing-closure string match call roots：当前已覆盖 string match 选出的 direct call root 与 local binding root，并已继续复用现有 bool guard 子集；当前仍限制在 direct literal arm、same-file const / static path pattern，以及 _ catch-all
- cleanup string match：当前已覆盖 defer match value { ... } 与 defer (match value { ... })(...)，并继续限制在 direct literal arm、same-file const / static path pattern，以及 _ / binding catch-all + 现有 bool guard 子集
- C header ql_string projection：typedef struct ql_string { const uint8_t* ptr; int64_t len; } ql_string;
- tuple / fixed-array / non-generic struct aggregate transport
- 仍未开放：更广义 string-pattern surface
let / var 局部绑定；当前已支持 statement-level 显式类型标注 let name: Type = value / var name: Type = value，以及 tuple / struct / fixed-array destructuring（叶子当前限 binding / _）
direct call 与 named arguments
same-file use ... as ... function alias call
最小 first-class sync function value 子集
- same-file sync function item
- same-file use ... as ... function alias
- transparently resolve 到 same-file sync function item 的 callable const / static，以及它们的 same-file use ... as ... alias
- non-capturing sync closure-backed callable const / static，以及它们的 same-file use ... as ... alias；当前 public regression 先锁定 ordinary positional indirect call 子集
- non-capturing sync closure value；当前 public regression 已锁定 ordinary positional indirect call 的最小子集：zero-arg 形态、显式 typed closure parameter 形态、由 statement-level local callable type annotation 驱动的 parameterized local 形态，以及由 call-site positional argument 反推参数类型的 parameterized local/immutable-alias 形态；当前 shipped cleanup / guard-call 子路径也已显式锁定 direct local non-capturing closure 的最小子集
- capturing sync closure value 的首个受控子集：当前只开放 non-move + immutable same-function scalar / String binding capture + direct local ordinary call、local alias ordinary call（含 same-target mutable reassign）、assignment-valued same-target ordinary direct callee root、control-flow 收敛到 same-target assignment-valued / block-local alias tail ordinary callee root、ordinary local binding 后再调用的 control-flow-selected / block-local assignment-valued / control-flow-assignment-valued / block-local alias tail binding root / local alias chain、local alias cleanup callee、local alias cleanup guard-call、assignment-valued cleanup callee / guard-call root、cleanup block 内局部 alias 的 direct call / guard-call（现含 statement-sequenced local mutable alias same-target reassign、statement-sequenced cleanup block 内局部 mutable alias 的 different-target reassign、assignment-valued same-target binding、control-flow 收敛到 same-target assignment-valued root 的 binding，以及 control-flow 分支内的 block-local alias tail binding；同类 direct cleanup callee / cleanup guard-call root 也已开放），以及 ordinary match guard-call（现含 direct callee root、先绑定到 ordinary local 后再调用的 control-flow-selected root、block-local assignment-valued / control-flow-assignment-valued binding root，以及 different-closure control-flow 下的 block-local alias tail / block binding / local alias chain callee root）；runtime if / match 当前也已开放 same-target control-flow 子集，即所有分支最终都收敛到同一个已支持 capturing closure local/alias 时，可继续进入 ordinary/local binding call、cleanup callee 与 cleanup guard-call；ordinary direct call、ordinary local binding root 及其后续 local alias chain 调用（现含后续未重写块）、ordinary match guard-call，以及 cleanup callee / cleanup guard-call 这边，现在都额外接受 runtime if / match 选出的首个 different-closure callee root 子集，只要各分支都仍落在当前 shipped direct root / block-local alias tail / block binding / local alias chain root 子集；同一条 local mutable alias 的 different-target reassign 现在也已开放到 ordinary direct call、ordinary local binding root、ordinary control-flow assignment-valued direct/binding/alias-chain root、cleanup direct root、cleanup local binding root、ordinary match guard-call，以及 runtime if / match branch-join 子集；其他 broader callable-value flow 的路径仍保持关闭
- capturing sync closure value 的首个 task-handle transport 子集：当前已开放 non-move + immutable same-function TaskHandle binding capture + ordinary direct local call / local alias ordinary call、ordinary if / integer-match 选出的 direct root / local binding root，以及 cleanup awaited-root 的最小 direct/local-binding matrix：defer if await <direct-root>()、defer if await <local-binding-root>()、defer match await <direct-root>()、defer match await <local-binding-root>()；在此之上，cleanup 侧现在还开放了首个 block-local alias tail / local alias chain 子集，例如 defer if await ({ let chosen = if ...; let alias = chosen; alias })() 与 defer match await ({ let chosen = match ...; let alias = chosen; alias })()，并进一步开放了首个 different-closure cleanup-awaited control-flow 子集：defer if await (if ... { left } else { right })() 与 defer match await (match ... { 1 => { let alias = left; alias }, _ => right })() 这类 root；当前 guarded-match 现在也已开放首个 different-closure cleanup-awaited root 子集，例如 defer if await (match branch { true if guard() => left, false => right, _ => right })() 与 defer match await (match branch { true if guard() => { let alias = left; alias }, false => right, _ => right })()；tagged/binding-pattern guarded match 现在也已开放首个 different-closure cleanup-awaited root 子集，例如 defer if await (match key { current if current == 42 => left, _ => right })() 与 defer match await (match key { current if current == 42 => { let alias = left; alias }, _ => right })()；同一条 guarded different-closure cleanup-awaited path 现也继续开放了首个 block-binding / local-alias-chain 版本，即 defer if await ({ let chosen = match branch { true if guard() => left, false => right, _ => right }; let rebound = chosen; rebound })() 与 defer match await ({ let chosen = match branch { true if guard() => { let alias = left; alias }, false => right, _ => right }; let rebound = chosen; rebound })()；tagged/binding-pattern guarded match 这条 different-closure cleanup-awaited path 现在也已继续开放首个 block-binding / local-alias-chain 版本，即 defer if await ({ let chosen = match key { current if current == 42 => left, _ => right }; let rebound = chosen; rebound })() 与 defer match await ({ let chosen = match key { current if current == 42 => { let alias = left; alias }, _ => right }; let rebound = chosen; rebound })()；当前还继续开放了这条 different-closure cleanup-awaited path 的非-guarded 首个 block-binding / local-alias-chain 版本，即 defer if await ({ let chosen = if ... { left } else { right }; let rebound = chosen; rebound })() 与 defer match await ({ let chosen = match ...; let rebound = chosen; rebound })()；此外，cleanup awaited path 现也开放了首个 helper/inline awaited-value 子集，例如 defer if helper_alias(42, await (if ... { left } else { right })()) 与 defer match State { value: (await (match ... )()).value }.value { ... } 这类 guard/scrutinee、首个 nested runtime projection awaited-value 子集，例如 defer if wrap(await (if ... { left } else { right })()).slot.value == 13、defer match [wrap(await (match ... )()).slot.value, 0][offset(...)] { ... } 这类 guard/scrutinee、首个 awaited aggregate current-binding scrutinee 子集，例如 defer match await (if ... { state_left } else { state_right })() { current => ... }、defer match await (match ... { true => pair_left, false => pair_right })() { current => ... } 这类 struct/tuple/fixed-array scrutinee，以及首个 awaited aggregate destructuring scrutinee 子集，例如 defer { sink(match await (if ... { pair_left } else { pair_right })() { (left, right) => ... }) }、defer match await (match ... { true => state_left, false => state_right })() { State { slot: Slot { value } } if value == 13 => ... }，以及 defer { sink(match await (if ... { left } else { right })() { [first, _, last] => ... }) } / defer match await (match ... { true => left, false => right })() { [first, middle, last] if first == 30 => ... } 这类 tuple / struct / fixed-array catch-all scrutinee；在此基础上还开放了首个 shared-local control-flow assignment-valued binding alias-chain 子集，例如 let chosen = if branch { alias = right } else { left }; let rebound = chosen; rebound 与对应的 bool-match / guarded-match 等价形态，其中 bool guarded 版本可写成 let chosen = match branch { true if guard() => alias = right, false => left, _ => left }; let rebound = chosen; rebound，而 tagged/binding-pattern guarded 版本现在也已接通首个子集，例如 let chosen = match key { current if current == 42 => alias = right, _ => left }; let rebound = chosen; rebound；调用端可对 closure 返回的 handle 继续做 local await，cleanup 侧也可继续把同一返回 handle 接到 helper/inline、nested projection、aggregate binding、aggregate destructuring 或最小 awaited guard/scrutinee path，而更广义的 cleanup control-flow / async callable path 仍保持关闭
- runtime if / match callable value 子集：当前 ordinary local binding 与 cleanup value path 也可从 same-file function item / alias、function-item-backed callable const / static / alias，以及 closure-backed callable const / static / alias 里选出 indirect callee
- ordinary call 可 direct call，或先绑定到 local 后再做 positional indirect call
- ordinary match guard，以及当前 shipped cleanup call / guard-call 子路径，也可通过 function-item-backed callable local / callable const / static / same-file alias 进入 positional indirect call；当前 public regression 也已显式锁定 direct closure-backed callable const guard + closure-backed callable static cleanup、direct local non-capturing closure cleanup + guard，以及 direct local capturing closure cleanup + cleanup guard + ordinary guard（现含 control-flow-selected direct callee root、local binding root、block assignment-bound root，以及 cleanup different-closure direct-root / block-local-alias-tail-root / block-binding / local-alias-chain-root 子集）的最小子集
最小 first-class async function value 子集
- same-file async function item
- same-file use ... as ... async function alias
- transparently resolve 到 same-file async function item 的 callable const / static，以及它们的 same-file use ... as ... alias
- 当前 public regression 已锁定 async fn 内 ordinary direct call 或 ordinary local positional indirect call + await 子集
- runtime if / match callable value 子集：当前 async fn 内 ordinary local binding + await，以及 cleanup value path 里的 await callable(...)，也可从 same-file async function item / alias 与 async callable const / static / alias 里选出 indirect callee
- capturing closure value，以及 cleanup callee / guard-call 上的 async callable path 仍保持关闭
fixed-shape for
- fixed-array
- homogeneous tuple
- binding / _ / tuple destructuring / struct destructuring / fixed-array destructuring loop pattern
- projected root / direct call-root / same-file import-alias call-root / nested call-root / same-file import-alias nested call-root
- block-valued / assignment-valued / runtime if / match valued projected root
- parenthesized / unparenthesized inline projected root
- same-file const / static root 及其 same-file alias
赋值表达式的当前可运行子集
- mutable local
- tuple literal index projection，以及 same-file const / static / use ... as ... alias、branch-selected const if / 最小 literal match item value、direct inline foldable if / match integer expression，和 immutable direct local alias 复用驱动的 foldable integer constant expression tuple index
- struct field
- fixed-array literal index projection
- projected-root / nested projected-root / call-root nested projected-root / import-alias call-root nested projected-root / inline nested projected-root tuple / struct-field / fixed-array literal-index chains
- assignment expr value form：当前已覆盖 direct call arg 与 valued block tail
动态数组索引赋值的当前可运行子集
- non-Task[...] element arrays
- nested dynamic array projections
- projected-root dynamic array projections
- direct-root / projected-root / call-root nested projected-root / import-alias call-root nested projected-root / inline nested projected-root assignment-expression result form
- nested projected-root assignment-expression result form
普通表达式与 if / while 条件里的 same-file foldable const / static，包括 computed/projected item value，以及 foldable const if / 最小 literal match 选出的 branch-selected item value
Bool && / || / unary !
最小 literal match lowering
- Bool / Int literal-path 子集
- 其他 current-loadable scrutinee 的 catch-all-only 子集；当前已锁定 direct / projected / nested projected / same-file import-alias projected / same-file import-alias nested projected / control-flow selected projected / control-flow selected nested projected / same-file import-alias control-flow selected projected / same-file import-alias control-flow selected nested projected / call-root / same-file import-alias call-root / control-flow selected call-root / same-file import-alias control-flow selected call-root / nested call-root projected / same-file import-alias nested call-root projected / control-flow selected nested call-root projected / same-file import-alias control-flow selected nested call-root projected tuple / struct / fixed-array scrutinee 的 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all，例如 match (1, 2) { (left, right) => ... }、match current { State { value } => ... }、match [1, 2, 3] { [first, _, last] => ... }，以及 match bundle.pair { (left, right) => ... }、match bundle.current { State { value } => ... }、match bundle.values { [first, _, last] => ... }、match tuple_env.outer.payload.values { (left, right) => ... }、match state_env.outer.payload.current { State { value } => ... }、match array_env.outer.payload.values { [first, _, last] => ... }、match bundle_alias.pair { (left, right) => ... }、match bundle_alias.current { State { value } => ... }、match bundle_alias.values { [first, _, last] => ... }、match tuple_alias.outer.payload.values { (left, right) => ... }、match state_alias.outer.payload.current { State { value } => ... }、match array_alias.outer.payload.values { [first, _, last] => ... }、match (if branch { tuple_left } else { tuple_right }).outer.payload.values { (left, right) => ... }、match (match branch { true => state_left, false => state_right }).outer.payload.current { State { value } => ... }、match (if branch { array_left } else { array_right }).outer.payload.values { [first, _, last] => ... }、match (if branch { left_bundle_alias } else { right_bundle_alias }).pair { (left, right) => ... }、match (match branch { true => left_bundle_alias, false => right_bundle_alias }).current { State { value } => ... }、match (if branch { left_bundle_alias } else { right_bundle_alias }).values { [first, _, last] => ... }、match (if branch { left_tuple_alias } else { right_tuple_alias }).outer.payload.values { (left, right) => ... }、match (match branch { true => left_state_alias, false => right_state_alias }).outer.payload.current { State { value } => ... }、match (if branch { left_array_alias } else { right_array_alias }).outer.payload.values { [first, _, last] => ... }、match (if branch { left } else { right }).pair { (left, right) => ... }、match (match branch { true => left, false => right }).current { State { value } => ... }、match (if branch { left } else { right }).values { [first, _, last] => ... }、match pair_value() { (left, right) => ... }、match state_value() { State { value } => ... }、match values() { [first, _, last] => ... }、match pair_alias() { (left, right) => ... }、match state_alias() { State { value } => ... }、match values_alias() { [first, _, last] => ... }、match (if branch { pair_value } else { alt_pair_value })() { (left, right) => ... }、match (match branch { true => state_value, false => alt_state_value })() { State { value } => ... }、match (if branch { values } else { alt_values })() { [first, _, last] => ... }、match (if branch { pair_alias } else { alt_pair_alias })() { (left, right) => ... }、match (match branch { true => state_alias, false => alt_state_alias })() { State { value } => ... }、match (if branch { values_alias } else { alt_values_alias })() { [first, _, last] => ... }、match tuple_env(1).payload.values { (left, right) => ... }、match state_env(3).payload.current { State { value } => ... }、match deep_env(6).outer.payload.values { [first, _, last] => ... }、match tuples(1).payload.values { (left, right) => ... }、match states(3).payload.current { State { value } => ... }、match deep(6).outer.payload.values { [first, _, last] => ... }、match (if ... { tuple_env } else { alt_tuple_env })(1).payload.values { (left, right) => ... }、match (match ... { true => state_env, false => alt_state_env })(3).payload.current { State { value } => ... }、match (if ... { deep_env } else { alt_deep_env })(4).outer.payload.values { [first, _, last] => ... }、match (if ... { tuples } else { alt_tuples })(1).payload.values { (left, right) => ... }、match (match ... { true => states, false => alt_states })(3).payload.current { State { value } => ... } 与 match (if ... { deep } else { alt_deep })(4).outer.payload.values { [first, _, last] => ... }
- transparent ? wrapper 下的 projected aggregate catch-all family；当前 ordinary / cleanup match (bundle_value()?).pair / match (bundle_value()?).current / match (bundle_value()?).values 这类 question-wrapped projected aggregate scrutinee 也已开放 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all。当前已锁定 match (bundle_value()?).pair { (left, right) => ... }、match (bundle_value()?).current { State { value } => ... } 与 match (bundle_value()?).values { [first, _, last] => ... }，以及对应的 defer match (bundle_value()?).pair / defer match (bundle_value()?).current / defer match (bundle_value()?).values 形态，都会沿同一条 projected scrutinee lowering 继续复用 ? wrapper，而不会在字段投影前丢失 current-loadable root
- transparent ? wrapper 下的 same-file import-alias projected aggregate catch-all family；当前 ordinary / cleanup match (bundle_alias()?).pair / match (bundle_alias()?).current / match (bundle_alias()?).values 与 match (cleanup_bundle_alias()?).pair / match (cleanup_bundle_alias()?).current / match (cleanup_bundle_alias()?).values 这类 import-alias question-wrapped projected aggregate scrutinee 也已开放 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all。当前已锁定 match (bundle_alias()?).pair { (left, right) => ... }、match (bundle_alias()?).current { State { value } => ... }、match (bundle_alias()?).values { [first, _, last] => ... }，以及对应的 defer match (cleanup_bundle_alias()?).pair / defer match (cleanup_bundle_alias()?).current / defer match (cleanup_bundle_alias()?).values 形态，都会沿同一条 alias-resolved projected scrutinee lowering 继续复用 ? wrapper，而不会在别名解析后丢失字段投影 root
- transparent ? wrapper 下的 control-flow selected projected aggregate catch-all family；当前 ordinary / cleanup match ((if branch { bundle_value } else { alt_bundle_value })()?).pair / match ((match branch { true => bundle_value, false => alt_bundle_value })()?).current / match ((if branch { bundle_value } else { alt_bundle_value })()?).values 这类 control-flow question-wrapped projected aggregate scrutinee 也已开放 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all。当前已锁定 match ((if branch { bundle_value } else { alt_bundle_value })()?).pair { (left, right) => ... }、match ((match branch { true => bundle_value, false => alt_bundle_value })()?).current { State { value } => ... } 与 match ((if branch { bundle_value } else { alt_bundle_value })()?).values { [first, _, last] => ... }，以及对应的 defer match ((match branch { true => bundle_value, false => alt_bundle_value })()?).pair / defer match ((if branch { bundle_value } else { alt_bundle_value })()?).current / defer match ((match branch { true => bundle_value, false => alt_bundle_value })()?).values 形态，都会沿同一条 control-flow-selected projected scrutinee lowering 继续复用 ? wrapper，而不会在 callee 选择与字段投影之间丢失 current-loadable root
- transparent ? wrapper 下的 same-file import-alias control-flow selected projected aggregate catch-all family；当前 ordinary / cleanup match ((if branch { bundle_alias } else { alt_bundle_alias })()?).pair / match ((match branch { true => bundle_alias, false => alt_bundle_alias })()?).current / match ((if branch { bundle_alias } else { alt_bundle_alias })()?).values，以及对应 cleanup match ((match branch { true => cleanup_bundle_alias, false => cleanup_alt_bundle_alias })()?).pair / match ((if branch { cleanup_bundle_alias } else { cleanup_alt_bundle_alias })()?).current / match ((match branch { true => cleanup_bundle_alias, false => cleanup_alt_bundle_alias })()?).values 这类 import-alias control-flow question-wrapped projected aggregate scrutinee 也已开放 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all。当前已锁定 match ((if branch { bundle_alias } else { alt_bundle_alias })()?).pair { (left, right) => ... }、match ((match branch { true => bundle_alias, false => alt_bundle_alias })()?).current { State { value } => ... }、match ((if branch { bundle_alias } else { alt_bundle_alias })()?).values { [first, _, last] => ... }，以及对应的 defer match ((match branch { true => cleanup_bundle_alias, false => cleanup_alt_bundle_alias })()?).pair / defer match ((if branch { cleanup_bundle_alias } else { cleanup_alt_bundle_alias })()?).current / defer match ((match branch { true => cleanup_bundle_alias, false => cleanup_alt_bundle_alias })()?).values 形态，都会沿同一条 alias-resolved control-flow-selected projected scrutinee lowering 继续复用 ? wrapper，而不会在 alias callee 选择与字段投影之间丢失 current-loadable root
- transparent ? wrapper 下的 nested projected aggregate catch-all family；当前 ordinary / cleanup match (tuple_env?).outer.payload.values / match (state_env?).outer.payload.current / match (array_env?).outer.payload.values 这类 question-wrapped nested projected aggregate scrutinee 也已开放 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all。当前已锁定 match (tuple_env?).outer.payload.values { (left, right) => ... }、match (state_env?).outer.payload.current { State { value } => ... } 与 match (array_env?).outer.payload.values { [first, _, last] => ... }，以及对应的 defer match (tuple_env?).outer.payload.values / defer match (state_env?).outer.payload.current / defer match (array_env?).outer.payload.values 形态，都会沿同一条 nested projected scrutinee lowering 继续复用 ? wrapper，而不会在多级字段投影链上丢失 current-loadable root
- transparent ? wrapper 下的 same-file import-alias nested projected aggregate catch-all family；当前 ordinary / cleanup match (tuple_alias?).outer.payload.values / match (state_alias?).outer.payload.current / match (array_alias?).outer.payload.values 与 match (cleanup_tuple_alias?).outer.payload.values / match (cleanup_state_alias?).outer.payload.current / match (cleanup_array_alias?).outer.payload.values 这类 import-alias question-wrapped nested projected aggregate scrutinee 也已开放 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all。当前已锁定 match (tuple_alias?).outer.payload.values { (left, right) => ... }、match (state_alias?).outer.payload.current { State { value } => ... } 与 match (array_alias?).outer.payload.values { [first, _, last] => ... }，以及对应的 defer match (cleanup_tuple_alias?).outer.payload.values / defer match (cleanup_state_alias?).outer.payload.current / defer match (cleanup_array_alias?).outer.payload.values 形态，都会沿同一条 alias-resolved nested projected scrutinee lowering 继续复用 ? wrapper，而不会在别名解析后的多级字段投影链上丢失 current-loadable root
- transparent ? wrapper 下的 control-flow selected nested projected aggregate catch-all family；当前 ordinary / cleanup match ((if branch { tuple_left } else { tuple_right })?).outer.payload.values / match ((match branch { true => state_left, false => state_right })?).outer.payload.current / match ((if branch { array_left } else { array_right })?).outer.payload.values 这类 control-flow question-wrapped nested projected aggregate scrutinee 也已开放 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all。当前已锁定 match ((if branch { tuple_left } else { tuple_right })?).outer.payload.values { (left, right) => ... }、match ((match branch { true => state_left, false => state_right })?).outer.payload.current { State { value } => ... } 与 match ((if branch { array_left } else { array_right })?).outer.payload.values { [first, _, last] => ... }，以及对应的 defer match ((match branch { true => tuple_left, false => tuple_right })?).outer.payload.values / defer match ((if branch { state_left } else { state_right })?).outer.payload.current / defer match ((match branch { true => array_left, false => array_right })?).outer.payload.values 形态，都会沿同一条 control-flow-selected nested projected scrutinee lowering 继续复用 ? wrapper，而不会在 control-flow 收敛后的多级字段投影链上丢失 current-loadable root
- transparent ? wrapper 下的 direct call-root aggregate catch-all family；当前 ordinary / cleanup match pair_value()? / match state_value()? / match values()? 这类 question-wrapped call-root aggregate scrutinee 也已开放 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all。当前已锁定 match pair_value()? { (left, right) => ... }、match state_value()? { State { value } => ... }、match values()? { [first, _, last] => ... }，以及对应的 defer match pair_value()? / defer match state_value()? / defer match values()? 形态，都会直接复用同一条 current-loadable scrutinee lowering，而不会再被 ? wrapper 单独拦截
- transparent ? wrapper 下的 same-file import-alias call-root aggregate catch-all family；当前 ordinary / cleanup match pair_alias()? / match state_alias()? / match values_alias()? 这类 import-alias question-wrapped call-root aggregate scrutinee 也已开放 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all。当前已锁定 match pair_alias()? { (left, right) => ... }、match state_alias()? { State { value } => ... }、match values_alias()? { [first, _, last] => ... }，以及对应的 defer match pair_alias()? / defer match state_alias()? / defer match values_alias()? 形态，都会沿同一条 alias-resolved current-loadable scrutinee lowering 继续复用 ? wrapper，而不会退回成 unresolved alias root
- transparent ? wrapper 下的 control-flow selected call-root aggregate catch-all family；当前 ordinary / cleanup match (if branch { pair_value } else { alt_pair_value })()? / match (match branch { true => state_value, false => alt_state_value })()? / match (if branch { values } else { alt_values })()? 这类 control-flow question-wrapped call-root aggregate scrutinee 也已开放 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all。当前已锁定 match (if branch { pair_value } else { alt_pair_value })()? { (left, right) => ... }、match (match branch { true => state_value, false => alt_state_value })()? { State { value } => ... }、match (if branch { values } else { alt_values })()? { [first, _, last] => ... }，以及对应的 defer match (match branch { true => pair_value, false => alt_pair_value })()? / defer match (if branch { state_value } else { alt_state_value })()? / defer match (match branch { true => values, false => alt_values })()? 形态，都会沿同一条 control-flow-selected current-loadable scrutinee lowering 继续复用 ? wrapper，而不会把 callable selection 与 ? lowering 分裂成两条不一致路径
- transparent ? wrapper 下的 same-file import-alias control-flow selected call-root aggregate catch-all family；当前 ordinary / cleanup match (if branch { pair_alias } else { alt_pair_alias })()? / match (match branch { true => state_alias, false => alt_state_alias })()? / match (if branch { values_alias } else { alt_values_alias })()? 这类 import-alias control-flow question-wrapped call-root aggregate scrutinee 也已开放 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all。当前已锁定 match (if branch { pair_alias } else { alt_pair_alias })()? { (left, right) => ... }、match (match branch { true => state_alias, false => alt_state_alias })()? { State { value } => ... }、match (if branch { values_alias } else { alt_values_alias })()? { [first, _, last] => ... }，以及对应的 defer match (match branch { true => pair_alias, false => alt_pair_alias })()? / defer match (if branch { state_alias } else { alt_state_alias })()? / defer match (match branch { true => values_alias, false => alt_values_alias })()? 形态，都会沿同一条 alias-resolved control-flow-selected current-loadable scrutinee lowering 继续复用 ? wrapper，而不会在 alias callable 选择后退回成未归一化 root
- transparent ? wrapper 下的 direct nested call-root projected aggregate catch-all family；当前 ordinary / cleanup match (tuple_env(1)?).payload.values / match (state_env(3)?).payload.current / match (array_env(4)?).payload.values / match (deep_env(6)?).outer.payload.values 这类 question-wrapped nested call-root aggregate scrutinee 也已开放 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all。当前已锁定 match (tuple_env(1)?).payload.values { (left, right) => ... }、match (state_env(3)?).payload.current { State { value } => ... }、match (array_env(4)?).payload.values { [first, _, last] => ... } 与 match (deep_env(6)?).outer.payload.values { [first, _, last] => ... }，以及对应的 defer match (tuple_env(1)?).payload.values / defer match (state_env(3)?).payload.current / defer match (array_env(4)?).payload.values / defer match (deep_env(6)?).outer.payload.values 形态，都会沿同一条 nested-call-root projected scrutinee lowering 继续复用 ? wrapper，而不会在投影前丢失 current-loadable root
- transparent ? wrapper 下的 same-file import-alias nested call-root projected aggregate catch-all family；当前 ordinary / cleanup match (tuples(1)?).payload.values / match (states(3)?).payload.current / match (arrays(4)?).payload.values / match (deep(6)?).outer.payload.values 这类 import-alias question-wrapped nested call-root aggregate scrutinee 也已开放 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all。当前已锁定 match (tuples(1)?).payload.values { (left, right) => ... }、match (states(3)?).payload.current { State { value } => ... }、match (arrays(4)?).payload.values { [first, _, last] => ... } 与 match (deep(6)?).outer.payload.values { [first, _, last] => ... }，以及对应的 defer match (tuples(1)?).payload.values / defer match (states(3)?).payload.current / defer match (arrays(4)?).payload.values / defer match (deep(6)?).outer.payload.values 形态，都会沿同一条 alias-resolved nested-call-root projected scrutinee lowering 继续复用 ? wrapper，而不会在别名解析后丢失 current-loadable root
- transparent ? wrapper 下的 control-flow selected nested call-root projected aggregate catch-all family；当前 ordinary / cleanup match ((if true { tuple_env } else { alt_tuple_env })(1)?).payload.values / match ((match true { true => state_env, false => alt_state_env })(3)?).payload.current / match ((if true { deep_env } else { alt_deep_env })(4)?).outer.payload.values 这类 control-flow question-wrapped nested call-root aggregate scrutinee 也已开放 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all。当前已锁定 match ((if true { tuple_env } else { alt_tuple_env })(1)?).payload.values { (left, right) => ... }、match ((match true { true => state_env, false => alt_state_env })(3)?).payload.current { State { value } => ... } 与 match ((if true { deep_env } else { alt_deep_env })(4)?).outer.payload.values { [first, _, last] => ... }，以及对应的 defer match ((match true { true => tuple_env, false => alt_tuple_env })(1)?).payload.values / defer match ((if true { state_env } else { alt_state_env })(3)?).payload.current / defer match ((match true { true => deep_env, false => alt_deep_env })(4)?).outer.payload.values 形态，都会沿同一条 control-flow-selected nested-call-root projected scrutinee lowering 继续复用 ? wrapper，而不会在 callable 选择后丢失投影 root
- transparent ? wrapper 下的 same-file import-alias control-flow selected nested call-root projected aggregate catch-all family；当前 ordinary / cleanup match ((if true { tuples } else { alt_tuples })(1)?).payload.values / match ((match true { true => states, false => alt_states })(3)?).payload.current / match ((if true { deep } else { alt_deep })(4)?).outer.payload.values 这类 import-alias control-flow question-wrapped nested call-root aggregate scrutinee 也已开放 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all。当前已锁定 match ((if true { tuples } else { alt_tuples })(1)?).payload.values { (left, right) => ... }、match ((match true { true => states, false => alt_states })(3)?).payload.current { State { value } => ... } 与 match ((if true { deep } else { alt_deep })(4)?).outer.payload.values { [first, _, last] => ... }，以及对应的 defer match ((match true { true => tuples, false => alt_tuples })(1)?).payload.values / defer match ((if true { states } else { alt_states })(3)?).payload.current / defer match ((match true { true => deep, false => alt_deep })(4)?).outer.payload.values 形态，都会沿同一条 alias-resolved control-flow-selected nested-call-root projected scrutinee lowering 继续复用 ? wrapper，而不会在 alias callable 选择与 control-flow 收敛后丢失投影 root
当前 bool/scalar-comparison guard 子集
bool guard path 现也接受同一批 ordinary local / param / self root 的 bool assignment expr value；当前已锁定 shipped cleanup if condition 公开回归
direct resolved sync guard call 子集
- guard-call arg value path 现也接受同一批 ordinary local / param / self root 的 assignment expr value，包括当前 loadable guard-call arg 子集
- guard-call arg value path 现也接受最小 runtime if value 子集：当前已锁定 loadable guard-call arg 的 if cond { ... } else { ... } 形态
- guard-call arg value path 现也接受最小 runtime match value 子集：当前已锁定 bool/int scrutinee + 既有 guard-match arm 子集上的 loadable guard-call arg 形态
- guard-call callee root 现也接受最小 runtime if / match callable value 子集：当前已锁定由 same-file function item / alias、function-item-backed callable const / static / alias，以及 closure-backed callable const / static / alias 选出的 indirect callee 形态
- callable-value positional indirect guard call 子集：当前已覆盖 callable local / callable const / static / same-file alias
- inline aggregate guard-call arg / inline projection-root 子集
- call-root / nested call-root guard 子集

async library build 子集

当前 async library build 已稳定开放：

staticlib
最小 async dylib
- 仍要求公开导出面保持同步 extern "c" C ABI

当前 library-mode async 子集已有真实 pass matrix 覆盖：

scalar / tuple / array / struct / nested aggregate await
Task[T] flow、payload、projection consume / submit
projected reinit、stable-dynamic path、guard-refined path
fixed-shape for await
- fixed-array
- homogeneous tuple
- task-array / task-tuple auto-await
- binding / _ / tuple destructuring / struct destructuring / fixed-array destructuring loop pattern
- same-file scalar const / static root、same-file scalar item alias，以及 scalar item-backed read-only projected root
- same-file task-producing const / static root，以及 same-file task item alias root
- projected / block-valued projected / assignment-valued projected / runtime if / match valued projected / call-root / awaited-aggregate / import-alias / inline / nested call-root
普通标量赋值表达式的当前可运行子集
- mutable local
- tuple literal index projection，以及 same-file const / static / use ... as ... alias、branch-selected const if / 最小 literal match item value、direct inline foldable if / match integer expression，和 immutable direct local alias 复用驱动的 foldable integer constant expression tuple index
- struct field
- fixed-array literal index projection
- projected-root / nested projected-root / call-root nested projected-root / import-alias call-root nested projected-root / inline nested projected-root tuple / struct-field / fixed-array literal-index chains
动态 Task[...] 数组索引赋值的当前可运行子集
- generic direct-root write-before-consume success path
- generic projected-root write-before-consume success path
async 普通标量动态数组索引赋值的当前可运行子集
- direct-root non-Task[...] arrays
- projected-root non-Task[...] arrays
- direct-root / projected-root / call-root nested projected-root / import-alias call-root nested projected-root / inline nested projected-root assignment-expression result form
- nested projected-root assignment-expression result form
最小 async match family
- direct-call guard
- projection guard
- aggregate guard-call arg
- inline aggregate / inline projection
- nested call-root families

async executable build 子集

当前 async executable 只开放：

BuildEmit::LlvmIr
BuildEmit::Object
BuildEmit::Executable
程序入口限定为最小 async fn main
async unsafe fn body 会沿当前最小 async fn main 子集一起 lowering

当前 program-mode async 子集真实覆盖：

Task[T] 类型面
direct async call / helper-returned task handle / spawn / await
- regular-size helper-returned / forwarded task-handle flow
- bound local task-handle spawn
- regular-size aggregate params on direct await / spawn
- zero-sized helper-returned / forwarded task-handle flow
- zero-sized aggregate params on direct await / spawn
- recursive aggregate params on direct await / spawn
scalar 与 fixed-shape aggregate payload
- tuple / fixed-array / non-generic struct
- regular-size direct / spawn aggregate result family
- zero-sized aggregate
- direct / spawn recursive fixed-shape aggregate result
- aggregate 内继续携带 Task[T]
- regular-size tuple / array / nested aggregate task-handle payload family
- nested task-handle payload
- regular-size returned / nested / struct-carried task-handle shapes
- zero-sized returned / nested / struct-carried task-handle shapes
projected task-handle consume
- tuple index
- fixed-array literal index
- struct field
- regular-size fixed-array projected reinit / conditional reinit
- zero-sized tuple / fixed-array / struct projection await / spawn
- zero-sized tuple / fixed-array / struct projection reinit
- direct call-root / awaited-aggregate / import-alias / inline / nested-call-root zero-sized consume
- direct call-root / nested call-root / awaited-aggregate / inline aggregate
conditional task-handle control flow
- regular-size branch-local spawn + reinit
- regular-size conditional async-call spawn
- regular-size conditional helper-task spawn
- guard-refined arithmetic static alias-sourced composed-dynamic forwarded helper await / direct queued spawn
- zero-sized branch-local spawn + reinit
- zero-sized conditional async-call spawn
- zero-sized conditional helper-task spawn
aliased projected-root aggregate repackage / submit
- tuple / struct / nested aggregate repackage before await
- fixed-array / nested fixed-array / helper-forwarded nested fixed-array repackage before spawn
- source-root reinit 后的 same-file arithmetic item / same-file use ... as ... alias 驱动 direct alias-root、projected-root、alias-sourced composed-dynamic 与 guard-refined alias-sourced composed-dynamic 形态，包括 bundle-alias-forwarded、bundle-alias-inline-forwarded、queued-root-forwarded、queued-root-inline-forwarded、queued-root-alias-forwarded、queued-root-alias-inline-forwarded、queued-root-chain-forwarded、queued-root-chain-inline-forwarded、queued-local-alias、queued-local-chain、queued-local-forwarded、queued-local-inline-forwarded、bundle-chain-forwarded 与 bundle-chain-inline-forwarded await/spawn
dynamic fixed-array Task[...] 的保守子集
- generic dynamic sibling-safe consume / spawn
- same immutable stable source path precise consume / reinit
- projected-root stable dynamic reinit / conditional reinit
- aliased / const-backed alias-root stable-dynamic reinit
- composed / alias-sourced composed dynamic reinit
- foldable integer arithmetic expression 回收到 concrete literal/projection path
- direct inline foldable if / 最小 literal match integer expression 回收到 concrete literal path consume / reinit
- direct / projected / aliased guard-refined dynamic reinit，包括 arithmetic-backed refined source 及其 same-file use ... as ... alias 包裹形态
- same-file static/import-alias-backed projected-root dynamic reinit
- same-file const / static / use ... as ... alias 回收到 literal/projection path，包括 computed/projected item value、branch-selected const if / 最小 literal match item value、foldable arithmetic item value，以及这些 item value 的 same-file use ... as ... alias 包裹形态
- equality-guard refinement
- projected-root / alias-root canonicalization
fixed-shape for await
- fixed-array
- homogeneous tuple
- task-array / task-tuple auto-await
- binding / _ / tuple destructuring / struct destructuring / fixed-array destructuring loop pattern
- same-file scalar const / static root、same-file scalar item alias，以及 scalar item-backed read-only projected root
- same-file task-producing const / static root、same-file task item alias root，以及 projected task item root
- projected / block-valued projected / assignment-valued projected / runtime if / match valued projected / call-root / awaited-aggregate / import-alias / inline / nested call-root
runtime task-backed item value flow
- same-file task-producing const / static item 与 same-file alias，当前也可经过 ordinary local binding、sync helper 参数/返回值，以及 runtime if / match 选值后，再进入 projected await / fixed-shape for await
普通表达式与 if / while 条件里的 same-file foldable const / static
- 包括 computed/projected item value
- 包括 foldable const if / 最小 literal match 选出的 branch-selected item value
awaited match guard 子集
- awaited scalar + direct-call guard
- guard scalar/value path 现也接受最小 runtime await value 子集：当前已锁定 ordinary match guard 里的 awaited scalar comparison 形态，其中 await operand 可来自 runtime if / match 选出的 same-file async function item / alias 与 async callable const / static / alias direct callee root
- awaited aggregate + projection guard；当前也已锁定 ordinary match guard 里的 awaited projected scalar comparison 形态，其中 aggregate-producing await operand 同样可来自 runtime if / match 选出的 same-file async function item / alias 与 async callable const / static / alias direct callee root
- aggregate guard-call arg / call-backed aggregate arg；当前也已锁定 ordinary match guard 里的 awaited aggregate guard-call arg 与 awaited call-backed aggregate guard arg 形态，其中 aggregate-producing await operand 可来自 runtime if / match 选出的 same-file async function item / alias 与 async callable const / static / alias direct callee root
- import-alias helper family；当前也已锁定 ordinary match guard 里的 awaited import-alias helper 形态，其中 helper arg 可直接承接 runtime if / match 选出的 same-file async function item / alias 与 async callable const / static / alias direct callee root 的 awaited aggregate value
- inline aggregate arg / inline projection-root；当前也已锁定 ordinary match guard 里的 awaited inline projection-root 与 awaited inline aggregate arg 形态，例如 State { value: (await ...).value }.value、matches((0, (await ...).value), ...) 与 contains([0, (await ...).value, 2], ...)
- nested call-root runtime projection family；当前也已锁定 ordinary match guard 里的 awaited nested call-root runtime projection 形态，其中 nested projected scalar 可来自 wrap(await ...) 这类 call-backed aggregate root，且 inner await operand 继续接受 runtime if / match 选出的 same-file async function item / alias 与 async callable const / static / alias direct callee root
- nested call-root deeper inline-combo family；当前也已锁定最小 awaited inline-combo 形态，例如 [wrap(await ...).slot.value, 0][offset(...)]
awaited match scrutinee 子集
- direct awaited scrutinee + control-flow-root family；当前也已锁定 ordinary match await ... 形态，其中 awaited direct scrutinee 的 callee root 可来自 runtime if / match 选出的 same-file async function item / alias 与 async callable const / static / alias
- awaited aggregate catch-all family；当前 ordinary match await ... 的 non-scalar current-loadable scrutinee 已不再只限单名 binding catch-all，而是开放 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all。当前已锁定 ordinary match await ... { current => ... }、match await ... { (left, right) => ... }、match await ... { State { slot: Slot { value } } => ... } 与 match await ... { [first, _, last] => ... } 这类形态，现已覆盖 awaited struct / tuple / fixed-array aggregate scrutinee，其中 awaited root 同样可来自 runtime if / match 选出的 same-file async function item / alias 与 async callable const / static / alias
- direct awaited projected scrutinee family；当前也已锁定 ordinary match (await ...).value 这类 direct projected scrutinee 形态，其中 awaited aggregate root 同样可来自 runtime if / match 选出的 same-file async function item / alias 与 async callable const / static / alias
- direct awaited call-root aggregate catch-all family；当前 ordinary / cleanup match await pair_value(1) / match await state_value(3) / match await values(4) 这类 direct awaited call-root aggregate scrutinee 也已开放 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all。当前已锁定 match await pair_value(1) { (left, right) => ... }、match await state_value(3) { State { value } => ... }、match await values(4) { [first, _, last] => ... }，以及对应的 defer match await pair_value(4) / defer match await state_value(6) / defer match await values(7) 形态，都会直接复用同一条 awaited call-root scrutinee lowering
- same-file import-alias direct awaited call-root aggregate catch-all family；当前 ordinary / cleanup match await pair_alias(1) / match await state_const_alias(3) / match await values_alias(4) 这类 import-alias awaited call-root aggregate scrutinee 也已开放 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all。当前已锁定 match await pair_alias(1) { (left, right) => ... }、match await state_const_alias(3) { State { value } => ... }、match await values_alias(4) { [first, _, last] => ... }，以及对应的 defer match await pair_const_alias(4) / defer match await state_alias(6) / defer match await values_const_alias(7) 形态，都会直接复用同一条 awaited call-root scrutinee lowering
- control-flow selected direct awaited call-root aggregate catch-all family；当前 ordinary / cleanup match await (if branch { pair_value } else { PAIR_VALUE })(1) / match await (match branch { true => STATE_VALUE, false => state_value })(3) / match await (if branch { values } else { VALUES })(4) 这类 control-flow selected awaited call-root aggregate scrutinee 也已开放 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all。当前已锁定 match await (if branch { pair_value } else { PAIR_VALUE })(1) { (left, right) => ... }、match await (match branch { true => STATE_VALUE, false => state_value })(3) { State { value } => ... }、match await (if branch { values } else { VALUES })(4) { [first, _, last] => ... }，以及对应的 defer match await (match branch { true => PAIR_VALUE, false => pair_value })(4) / defer match await (if branch { state_value } else { STATE_VALUE })(6) / defer match await (match branch { true => VALUES, false => values })(7) 形态，都会直接复用同一条 awaited call-root scrutinee lowering
- same-file import-alias control-flow selected direct awaited call-root aggregate catch-all family；当前 ordinary / cleanup match await (if branch { pair_alias } else { pair_const_alias })(1) / match await (match branch { true => state_const_alias, false => state_alias })(3) / match await (if branch { values_alias } else { values_const_alias })(4) 这类 import-alias control-flow selected awaited call-root aggregate scrutinee 也已开放 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all。当前已锁定 match await (if branch { pair_alias } else { pair_const_alias })(1) { (left, right) => ... }、match await (match branch { true => state_const_alias, false => state_alias })(3) { State { value } => ... }、match await (if branch { values_alias } else { values_const_alias })(4) { [first, _, last] => ... }，以及对应的 defer match await (match branch { true => pair_const_alias, false => pair_alias })(4) / defer match await (if branch { state_alias } else { state_const_alias })(6) / defer match await (match branch { true => values_const_alias, false => values_alias })(7) 形态，都会直接复用同一条 awaited call-root scrutinee lowering
- direct awaited projected aggregate catch-all family；当前 ordinary / cleanup match (await ...).payload.values / .payload.current 这类 direct projected aggregate scrutinee 也已开放 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all。当前已锁定 match (await tuple_env(1)).payload.values { (left, right) => ... }、match (await state_env(3)).payload.current { State { value } => ... }、match (await array_env(4)).payload.values { [first, _, last] => ... }，以及对应的 defer match (await ...).payload.values / .payload.current 形态，都会直接复用同一条 projected awaited scrutinee lowering
- same-file import-alias direct awaited projected aggregate catch-all family；当前 ordinary / cleanup match (await tuple_alias(1)).payload.values / match (await state_const_alias(3)).payload.current / match (await array_alias(4)).payload.values 这类 projected aggregate scrutinee 也已锁定 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all；对应的 defer match (await tuple_const_alias(1)).payload.values / defer match (await state_alias(3)).payload.current / defer match (await array_const_alias(4)).payload.values 形态同样会直接复用同一条 projected awaited scrutinee lowering
- control-flow selected direct awaited projected aggregate catch-all family；当前 ordinary / cleanup match (await (if ... { tuple_env } else { TUPLE_ENV })(1)).payload.values / match (await (match ... { true => STATE_ENV, false => state_env })(3)).payload.current / match (await (if ... { array_env } else { ARRAY_ENV })(4)).payload.values 这类 projected aggregate scrutinee 也已锁定 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all；对应的 defer match (await (match ... { true => TUPLE_ENV, false => tuple_env })(1)).payload.values / defer match (await (if ... { state_env } else { STATE_ENV })(3)).payload.current / defer match (await (match ... { true => ARRAY_ENV, false => array_env })(4)).payload.values 形态同样会直接复用同一条 projected awaited scrutinee lowering
- direct awaited nested projected aggregate catch-all family；当前 ordinary / cleanup match (await ...).outer.payload.values / .outer.payload.current 这类更深一级的 projected aggregate scrutinee 也已开放 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all。当前已锁定 match (await tuple_env(1)).outer.payload.values { (left, right) => ... }、match (await state_env(3)).outer.payload.current { State { value } => ... }、match (await array_env(4)).outer.payload.values { [first, _, last] => ... }，以及对应的 defer match (await ...).outer.payload.values / .outer.payload.current 形态，都会直接复用同一条 nested projected awaited scrutinee lowering
- same-file import-alias direct awaited nested projected aggregate catch-all family；当前 ordinary / cleanup match (await tuple_alias(1)).outer.payload.values / match (await state_const_alias(3)).outer.payload.current / match (await array_alias(4)).outer.payload.values 这类 nested projected aggregate scrutinee 也已锁定 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all；对应的 defer match (await tuple_const_alias(1)).outer.payload.values / defer match (await state_alias(3)).outer.payload.current / defer match (await array_const_alias(4)).outer.payload.values 形态同样会直接复用同一条 nested projected awaited scrutinee lowering
- control-flow selected direct awaited nested projected aggregate catch-all family；当前 ordinary / cleanup match (await (if ... { tuple_env } else { TUPLE_ENV })(1)).outer.payload.values / match (await (match ... { true => STATE_ENV, false => state_env })(3)).outer.payload.current / match (await (if ... { array_env } else { ARRAY_ENV })(4)).outer.payload.values 这类 nested projected aggregate scrutinee 也已锁定 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all；对应的 defer match (await (match ... { true => TUPLE_ENV, false => tuple_env })(1)).outer.payload.values / defer match (await (if ... { state_env } else { STATE_ENV })(3)).outer.payload.current / defer match (await (match ... { true => ARRAY_ENV, false => array_env })(4)).outer.payload.values 形态同样会直接复用同一条 nested projected awaited scrutinee lowering
- same-file import-alias control-flow selected direct awaited projected aggregate catch-all family；当前 ordinary / cleanup match (await (if ... { tuple_alias } else { tuple_const_alias })(1)).payload.values / match (await (match ... { true => state_const_alias, false => state_alias })(3)).payload.current / match (await (if ... { array_alias } else { array_const_alias })(4)).payload.values 这类 projected aggregate scrutinee 也已锁定 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all；对应的 defer match (await (match ... { true => tuple_const_alias, false => tuple_alias })(1)).payload.values / defer match (await (if ... { state_alias } else { state_const_alias })(3)).payload.current / defer match (await (match ... { true => array_const_alias, false => array_alias })(4)).payload.values 形态同样会直接复用同一条 projected awaited scrutinee lowering
- same-file import-alias control-flow selected direct awaited nested projected aggregate catch-all family；当前 ordinary / cleanup match (await (if ... { tuple_alias } else { tuple_const_alias })(1)).outer.payload.values / match (await (match ... { true => state_const_alias, false => state_alias })(3)).outer.payload.current / match (await (if ... { array_alias } else { array_const_alias })(4)).outer.payload.values 这类 nested projected aggregate scrutinee 也已锁定 _ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring catch-all；对应的 defer match (await (match ... { true => tuple_const_alias, false => tuple_alias })(1)).outer.payload.values / defer match (await (if ... { state_alias } else { state_const_alias })(3)).outer.payload.current / defer match (await (match ... { true => array_const_alias, false => array_alias })(4)).outer.payload.values 形态同样会直接复用同一条 nested projected awaited scrutinee lowering
- helper / inline scrutinee family；当前也已锁定 ordinary match 里的 awaited helper scrutinee 与 awaited inline projection-root scrutinee 形态，例如 match helper_alias(13, (await ...).slot.value) 与 match State { slot: Slot { value: (await ...).slot.value } }.slot.value
- nested call-root runtime projection / inline-combo scrutinee family；当前也已锁定 ordinary match 里的 match wrap(await ...).slot.value 与 match [wrap(await ...).slot.value, 0][offset(...)] 形态，其中 inner await operand 同样接受 runtime if / match 选出的 same-file async function item / alias 与 async callable const / static / alias direct callee root

cleanup lowering 子集

当前 cleanup lowering 只开放首个受控子集：

direct / call-backed defer
其中 call-backed defer 当前已覆盖 direct resolved callee，以及 callable local / callable const / static / same-file alias 驱动的 positional indirect callee；对 capturing sync closure，还额外开放了 local alias 未重绑定前提下的 cleanup callee 与 cleanup guard-call 最小子集，以及 cleanup block 内 let alias = run / let alias = check 这类局部 alias 的 direct call / guard-call；statement-sequenced cleanup block 现也已开放 var alias = run; alias = run; alias(...) / var alias = check; alias = check; if alias(...) { ... } 这类 same-target mutable reassign 形态，而 var alias = left; alias = right; alias(...) / var alias = left_check; alias = right_check; if alias(...) { ... } 这类无 branch-join 的 different-target mutable reassign 现也进入当前 cleanup block shipped surface；同一类 block-local different-target mutable alias 现也可直接作为 cleanup callee / guard-call root，即 defer ({ var alias = left; alias = right; alias })(...) / defer if ({ var alias = left_check; alias = right_check; alias })(...) { ... }；(alias = run)(...) / if (alias = check)(...) { ... } 这类 assignment-valued same-target mutable alias 现也可直接进入 cleanup callee / guard-call root；let chosen = alias = run / let chosen = alias = check 这类 cleanup block assignment-valued binding 现在也可继续把同一个 capturing closure 绑定给新局部，而 let chosen = if ... { alias = run } else { run } / let chosen = match ... { ... } 这类 control-flow 收敛到 same-target assignment-valued root 的 binding 也已接通；当前还进一步开放了 defer (if ... { let alias = run; alias } else { run })(...) 与 defer if (match ... { true => { var alias = check; alias = check; alias }, false => check })(...) { ... } 这类分支内 block-local alias tail 直接作为 cleanup callee / guard-call root 的形态；同一条 root 现在还可继续包进 cleanup if / match control-flow，只要各分支最终仍收敛到同一个 same-target assignment-valued capturing closure；runtime if / match typed-value path 当前也可选出 same-file function item / alias、function-item-backed callable const / static / alias，以及 closure-backed callable const / static / alias 作为 callable cleanup callee root，而 capturing closure 当前除 same-target cleanup control-flow 子集外，也已开放 different-closure cleanup control-flow 的首个 direct-root / block-local-alias-tail-root / block-binding / local-alias-chain-root 子集；同一条 local mutable alias 的 different-target reassign 现在也已沿 shared local path 打通 ordinary direct call、ordinary local binding root、cleanup direct root、cleanup local binding root、ordinary match guard-call，以及 runtime if / match branch-join 子集；在这条 shared-local 路径上，cleanup if assignment-valued binding 与 cleanup bool match assignment-valued binding 现在都已进一步开放后续 alias-chain，即 let chosen = ...; let rebound = chosen; rebound(...) 与对应 guard-call 形态已进入当前 build surface；其他 cleanup escape flow 与 broader cleanup control-flow 仍关闭
statement-sequenced block wrapper：当前接受 binding / _、tuple destructuring、struct destructuring、fixed-array destructuring（叶子仍限 binding / _）的最小 let statement、已支持 cleanup expr statement、statement-level assignment expr、statement-level while / loop / for，外加可选 tail；当前已覆盖 direct cleanup body、cleanup let binding / destructuring block、cleanup guard / scrutinee block、cleanup call-arg value block，以及 rooted in ordinary local / param / self place family 的 local/field/tuple-index/fixed-array-index assignment expr statement
cleanup value path 现也接受同一批 ordinary local / param / self place family root 的 assignment expr value，包括 direct cleanup call arg 与 valued cleanup block tail；当前仍限 local/field/tuple-index/fixed-array-index target path
cleanup value path 现也接受最小 runtime if value 子集：当前已锁定 direct cleanup call arg 的 if cond { ... } else { ... } 形态
cleanup value path 现也接受最小 runtime match value 子集：当前已锁定 direct cleanup call arg 的 bool/int scrutinee + 既有 cleanup-match arm 子集
cleanup value path 现也接受最小 runtime await value 子集：当前已锁定 async body 内 direct cleanup call arg 的 await task 形态
cleanup value path 现也接受最小 runtime spawn value 子集：当前已锁定 async body 内 direct cleanup call arg 的 spawn worker(...) / spawn task 形态
statement-level cleanup while：当前开放 bool 条件 + 已支持 cleanup block body 的最小 lowering 子集，可在 cleanup block 内重复执行 direct / callable-backed call 路径，并支持 body-local break / continue（包括经由当前已开放 cleanup if branch 进入的 loop-exit path）
statement-level cleanup loop：当前开放已支持 cleanup block body 的最小 lowering 子集，并支持 body-local break / continue（包括经由当前已开放 cleanup if branch 进入的 loop-exit path）
statement-level cleanup for：当前开放 fixed array / homogeneous tuple iterable + binding / _ / tuple destructuring / struct destructuring / fixed-array destructuring（叶子仍限 binding / _）pattern 的最小 lowering 子集，iterable 当前已覆盖 direct root、same-file const / static root 及其 same-file alias、item-backed read-only projected root、direct call-root、same-file import-alias call-root、nested call-root projected root，以及 transparent ? wrapper 下的 projected root 形态；body 内可读取当前 item，并支持 body-local break / continue（包括经由当前已开放 cleanup if branch 进入的 loop-exit path）
statement-level cleanup for await：当前在 async body 内开放 fixed array / homogeneous tuple iterable 的最小 lowering 子集；普通元素会直接逐项绑定，Task[...] 元素会复用既有 await + result-release 路径做逐项 auto-await，并支持 body-local break / continue；loop pattern 当前已覆盖 binding / _ / tuple destructuring / struct destructuring / fixed-array destructuring（叶子仍限 binding / _）；当前已锁定 direct local root、same-file scalar const / static root、same-file scalar item alias、same-file task-producing const / static root、same-file task item alias root、projected task item root、scalar item-backed read-only projected root、direct block-valued / assignment-valued / runtime if / match / awaited direct root、direct question-mark root、read-only projected root、assignment-valued projected root、block-valued projected root、direct call-root、same-file import-alias call-root、nested call-root projected root、awaited projected root、runtime if / match aggregate projected root、transparent ? wrapper 下的 projected root，以及 inline array/tuple task root
cleanup runtime task-backed item value flow
- same-file task-producing const / static item 与 same-file alias，当前也可经过 cleanup local binding、sync helper 参数/返回值，以及 runtime if / match 选值后，再进入 projected await / fixed-shape cleanup for await
cleanup aggregate value staging：cleanup let / valued block / projected-root materialization 现在会沿 tuple / array / struct literal 递归走 cleanup 自身的 value path；这意味着 awaited projected loadable value 现在可以先被装入 cleanup struct literal 字段，再继续被后续 cleanup for await / projected read 消费
bool-guard 驱动的 cleanup if branch；当前已不再只限 call-backed expr，branch body 也可承载当前已开放的 cleanup block 语句子集，包括 local binding、nested control-flow value path 与 async for await；对应 bool/int guard call 子路径也已覆盖 callable local / callable const / static / same-file alias 驱动的 positional indirect call，并接受 runtime if / match 选出的 same-file function item / alias、function-item-backed callable const / static / alias，以及 closure-backed callable const / static / alias callee root
cleanup bool guard path 现也接受最小 runtime await value 子集：当前已锁定 async body 内 defer if await ready()、cleanup match guard true if await check(...)、defer if await (if / match 选出的 same-file async function item / alias 与 async callable const / static / alias )(...)、defer if helper_alias(..., await ...) / defer if State { value: (await ...).value }.value == ... 这类 awaited helper / inline guard，以及 defer if wrap(await ...).slot.value == ... / cleanup match guard 里的 [wrap(await ...).slot.value, 0][offset(...)] 这类 awaited nested runtime projection / inline-combo guard 形态
cleanup match branch 当前开放两类 scrutinee 子集：其一是 bool / int scrutinee + literal-or-path / wildcard-or-single-binding catch-all arms + optional bool guard；其二是 loadable 非标量 scrutinee + catch-all pattern（_ / single binding / tuple destructuring / struct destructuring / fixed-array destructuring）+ optional bool guard。当前也不再只限 call-backed arm expr，arm body 可承载同一批已开放 cleanup block 语句子集，包括 binding arm body 与 async for await；cleanup scalar call-arg value 里的 call 子路径也已覆盖同一批 callable-value 间接调用，而 cleanup scrutinee path 现也接受最小 runtime await value 子集：当前已锁定 defer match await ...、defer match (await ...).value { ... }、defer match (await tuple_env(1)).payload.values { ... }、defer match (await state_env(3)).payload.current { ... }、defer match (await array_env(4)).payload.values { ... }、defer match (await tuple_const_alias(1)).payload.values { ... }、defer match (await state_alias(3)).payload.current { ... }、defer match (await array_const_alias(4)).payload.values { ... }、defer match (await (match ... { true => TUPLE_ENV, false => tuple_env })(1)).payload.values { ... }、defer match (await (if ... { state_env } else { STATE_ENV })(3)).payload.current { ... }、defer match (await (match ... { true => ARRAY_ENV, false => array_env })(4)).payload.values { ... }、defer match (await tuple_env(1)).outer.payload.values { ... }、defer match (await state_env(3)).outer.payload.current { ... }、defer match (await array_env(4)).outer.payload.values { ... }、defer match (await tuple_const_alias(1)).outer.payload.values { ... }、defer match (await state_alias(3)).outer.payload.current { ... }、defer match (await array_const_alias(4)).outer.payload.values { ... }、defer match (await (match ... { true => TUPLE_ENV, false => tuple_env })(1)).outer.payload.values { ... }、defer match (await (if ... { state_env } else { STATE_ENV })(3)).outer.payload.current { ... }、defer match (await (match ... { true => ARRAY_ENV, false => array_env })(4)).outer.payload.values { ... }、defer match (await (match ... { true => tuple_const_alias, false => tuple_alias })(1)).payload.values { ... }、defer match (await (if ... { state_alias } else { state_const_alias })(3)).payload.current { ... }、defer match (await (match ... { true => array_const_alias, false => array_alias })(4)).payload.values { ... }、defer match (await (match ... { true => tuple_const_alias, false => tuple_alias })(1)).outer.payload.values { ... }、defer match (await (if ... { state_alias } else { state_const_alias })(3)).outer.payload.current { ... }、defer match (await (match ... { true => array_const_alias, false => array_alias })(4)).outer.payload.values { ... }、defer match helper_alias(..., await ...)、defer match State { value: (await ...).value }.value { ... } 这类 awaited helper / inline scrutinee，以及 defer match wrap(await ...).slot.value { ... } / defer match [wrap(await ...).slot.value, 0][offset(...)] { ... } 这类 awaited nested runtime projection / inline-combo scrutinee 形态；此外，awaited struct / tuple / fixed-array aggregate scrutinee 现也可通过 single-binding catch-all 直接进入 cleanup body，例如 defer match await ... { current => ... }，而 awaited tuple / struct / fixed-array aggregate scrutinee 还可进一步直接在 catch-all arm 中解构，例如 defer match await ... { (left, right) => ... } / defer match await ... { State { slot: Slot { value } } => ... } / defer match await ... { [first, _, last] => ... }，其中 awaited callee root 同样可来自 runtime if / match 选出的 same-file async function item / alias 与 async callable const / static / alias
cleanup match branch 的 direct / projected / nested projected / same-file import-alias projected / same-file import-alias nested projected / control-flow selected projected / control-flow selected nested projected / same-file import-alias control-flow selected projected / same-file import-alias control-flow selected nested projected / call-root / same-file import-alias call-root / control-flow selected call-root / same-file import-alias control-flow selected call-root / nested call-root projected / same-file import-alias nested call-root projected / control-flow selected nested call-root projected / same-file import-alias control-flow selected nested call-root projected 非 awaited loadable scrutinee 当前也已锁定 tuple / struct / fixed-array catch-all 公开回归：defer match (4, 5) { (left, right) if left < right => ... }、defer match cleanup_current { State { value } if value == 6 => ... }、defer match [4, 5, 6] { [first, middle, last] if middle == 5 => ... }，以及 defer match bundle.pair { ... }、defer match bundle.current { ... }、defer match bundle.values { ... }、defer match tuple_env.outer.payload.values { ... }、defer match state_env.outer.payload.current { ... }、defer match array_env.outer.payload.values { ... }、defer match cleanup_bundle_alias.pair { ... }、defer match cleanup_bundle_alias.current { ... }、defer match cleanup_bundle_alias.values { ... }、defer match cleanup_tuple_alias.outer.payload.values { ... }、defer match cleanup_state_alias.outer.payload.current { ... }、defer match cleanup_array_alias.outer.payload.values { ... }、defer match (match branch { true => tuple_left, false => tuple_right }).outer.payload.values { ... }、defer match (if branch { state_left } else { state_right }).outer.payload.current { ... }、defer match (match branch { true => array_left, false => array_right }).outer.payload.values { ... }、defer match (match branch { true => cleanup_left_bundle_alias, false => cleanup_right_bundle_alias }).pair { ... }、defer match (if branch { cleanup_left_bundle_alias } else { cleanup_right_bundle_alias }).current { ... }、defer match (match branch { true => cleanup_left_bundle_alias, false => cleanup_right_bundle_alias }).values { ... }、defer match (match branch { true => cleanup_left_tuple_alias, false => cleanup_right_tuple_alias }).outer.payload.values { ... }、defer match (if branch { cleanup_left_state_alias } else { cleanup_right_state_alias }).outer.payload.current { ... }、defer match (match branch { true => cleanup_left_array_alias, false => cleanup_right_array_alias }).outer.payload.values { ... }、defer match (match branch { true => left, false => right }).pair { ... }、defer match (if branch { left } else { right }).current { ... }、defer match (match branch { true => left, false => right }).values { ... }、defer match pair_value() { ... }、defer match state_value() { ... }、defer match values() { ... }、defer match pair_alias() { ... }、defer match state_alias() { ... }、defer match values_alias() { ... }、defer match (match branch { true => pair_value, false => alt_pair_value })() { ... }、defer match (if branch { state_value } else { alt_state_value })() { ... }、defer match (match branch { true => values, false => alt_values })() { ... }、defer match (match branch { true => pair_alias, false => alt_pair_alias })() { ... }、defer match (if branch { state_alias } else { alt_state_alias })() { ... }、defer match (match branch { true => values_alias, false => alt_values_alias })() { ... }、defer match tuple_env(1).payload.values { ... }、defer match state_env(3).payload.current { ... }、defer match deep_env(6).outer.payload.values { ... }、defer match tuples(1).payload.values { ... }、defer match states(3).payload.current { ... }、defer match deep(6).outer.payload.values { ... }、defer match (if ... { state_env } else { alt_state_env })(3).payload.current { ... }、defer match (match ... { true => tuple_env, false => alt_tuple_env })(1).payload.values { ... }、defer match (match ... { true => deep_env, false => alt_deep_env })(4).outer.payload.values { ... }、defer match (if ... { states } else { alt_states })(3).payload.current { ... }、defer match (match ... { true => tuples, false => alt_tuples })(1).payload.values { ... } 与 defer match (match ... { true => deep, false => alt_deep })(4).outer.payload.values { ... } 这类 projected / nested-projected / same-file-import-alias-projected / same-file-import-alias-nested-projected / control-flow-selected-projected / control-flow-selected-nested-projected / same-file-import-alias-control-flow-selected-projected / same-file-import-alias-control-flow-selected-nested-projected / call-root / import-alias-call-root / control-flow-selected-call-root / same-file-import-alias-control-flow-selected-call-root / nested-call-root-projected / import-alias-nested-call-root-projected / control-flow-selected-nested-call-root-projected / import-alias-control-flow-selected-nested-call-root-projected aggregate scrutinee，都会直接复用同一条 cleanup catch-all lowering，而不再只由通用“非标量可加载 scrutinee”描述隐式覆盖
透明 ? wrapper，可包裹当前 shipped cleanup expr / guard / scrutinee 子路径
cleanup value path 现也会复用既有 literal-source folding：cleanup let value、cleanup for iterable、cleanup if bool condition，以及 cleanup call-arg scalar/value path 当前都接受可折叠回既有 literal / aggregate root 的 if / 最小 literal match 根表达式
当前已锁定的用户面包括 direct cleanup obj build、callable-const-alias cleanup obj build、closure-backed callable global cleanup + guard obj build、local non-capturing closure cleanup + guard obj build、ordinary extended capturing-closure call-root obj build、local alias capturing closure cleanup + cleanup if/match guard + ordinary guard obj build、cleanup assignment-valued capturing-closure callee / guard root obj build、cleanup control-flow local-alias capturing-closure direct callee / guard root obj build、cleanup different-closure capturing-closure call-root obj build、cleanup block local capturing-closure alias obj build、cleanup block local mutable capturing-closure same-target reassign obj build、cleanup block assignment-valued capturing-closure binding obj build、cleanup block control-flow assignment-valued capturing-closure binding obj build、cleanup if shared-local control-flow capturing-closure alias-chain obj build、cleanup bool match shared-local control-flow capturing-closure alias-chain obj build、cleanup guarded match shared-local control-flow capturing-closure alias-chain obj build、cleanup let binding / destructuring block obj build、callable-guard-alias cleanup match obj build、binding-catch-all cleanup match obj build、statement-sequenced cleanup block obj build、statement-sequenced cleanup guard / scrutinee / call-arg value block（现含 runtime await / spawn task value，以及 awaited async callable control-flow callee root / awaited cleanup scrutinee / awaited helper guard / awaited inline guard root / awaited nested runtime projection guard / awaited helper-inline scrutinee / awaited nested runtime projection scrutinee / awaited aggregate single-binding scrutinee / awaited aggregate tuple-struct-fixed-array destructuring scrutinee）obj build、带 body-local break / continue 的 statement-level cleanup while / loop obj build、包含 tuple/struct/fixed-array 解构 pattern、const/static root、projected/call-root、alias call-root、nested call-root projected 与 transparent ? wrapper projected root 形态在内的 fixed-shape statement-level cleanup for obj build、async body 内 fixed array / homogeneous tuple + task-element auto-await 子集的 cleanup for await obj build（现含 same-file scalar const / static root、same-file scalar item alias、same-file task-producing const / static root、same-file task item alias root、projected task item root、scalar item-backed read-only projected root、direct block-valued / assignment-valued / runtime if / match / awaited direct root、direct question-mark root、read-only projected root、assignment-valued projected root、block-valued projected root、direct call-root、same-file import-alias call-root、nested call-root projected root、awaited projected root、runtime if / match aggregate projected root、transparent ? wrapper 下的 projected root 与 inline array/tuple task root）、guarded dynamic task-handle cleanup staticlib build、cleanup match obj build，以及 cleanup-internal question-mark obj build

透明 `?` lowering

当前透明 ? 表达式会沿 inner operand 直接进入既有 codegen 路径：

match + ? 不再因为 question-mark 本身被 backend 拦截
cleanup-adjacent 的 return helper()? / 普通 return path 也不再单独报 ? lowering unsupported
cleanup-internal 的 defer helper()? 也不再单独报 cleanup / ? lowering unsupported

当前回归规模

截至当前代码：

crates/ql-cli/tests/executable_examples.rs 当前编码了 executable smoke contract
其中 sync local executable cases：60
其中 async local executable cases：222
这些 case 默认指向本地忽略的 ramdon_tests/... 目录；当前 checkout 不提交该目录

注意：

async 本地样例的历史命名编号从 04 编到 225，但编号最大值不等于当前注册 case 数
crates/ql-cli/tests/executable_examples.rs 当前注册了 222 个 async local executable case 和 60 个 sync local executable case

当前明确未开放

更广义的 async executable / program bootstrap，除最小 async fn main 以外
更广义的 async dylib surface，尤其是公开 async ABI
generalized for await，超出 fixed-array / homogeneous tuple 之外的 iterable
更广义的 runtime const/static/item-backed aggregate lowering，超出当前 async ordinary/cleanup value path 已锁定的 same-file task-backed item root、projected item-root，以及 local/helper/control-flow 传递子集之外仍未开放；当前 const item lowering 仍不会把 worker(...) 这类 runtime task-producing initializer 普遍提升为通用常量值
broader cleanup lowering / cleanup codegen，超出当前 direct / call-backed defer + if / match + 透明 ? wrapper cleanup 子集之外
broader callable value lowering，超出当前 same-file sync function item / same-file alias / function-item-backed callable const / static 子集、closure-backed callable const / static 的 ordinary positional indirect-call 最小子集与 direct cleanup/guard item 子集、non-capturing sync closure value 的 ordinary positional indirect-call 最小子集与 direct local cleanup/guard 子集（zero-arg + explicit typed-parameter shape + statement-level local callable type-annotation shape + call-site positional-arg-inferred parameterized local/immutable-alias shape）、capturing sync closure value 的首个受控子集（non-move + immutable same-function scalar / String binding capture + ordinary local/same-target call roots、ordinary local binding root 及其后续 local alias chain 调用、ordinary control-flow assignment-valued direct/binding/alias-chain root、cleanup direct/guard/binding root 与 ordinary match guard-call root；其中 mutable alias 当前已开放 same-target reassign、ordinary/cleanup/ordinary-match-guard 路径上的 local different-target reassign、runtime if / match branch-join 子集，以及 statement-sequenced cleanup block 内局部 mutable alias 的 different-target reassign，而 different-closure control-flow 当前只开放 ordinary direct call、ordinary local binding root 及其后续 local alias chain 调用（含后续未重写块）、ordinary match guard-call，与 cleanup callee / cleanup guard-call 的 direct root / block-local alias tail / block binding / local alias chain root 子集），以及 same-file async function item / alias / callable const / static / same-file alias 的 ordinary local indirect-call + await 子集之外；capturing closure 的其他 cleanup escape flow，以及 cleanup 内更广义的 async control-flow 仍未开放
cancellation / polling / drop semantics
generic async ABI / layout substitution
arbitrary dynamic overlap precision
更广义的 projection-sensitive partial move / partial-place ownership
超出当前 minimal subset 的 match lowering、guard shape 与 pattern discrimination

当前支持基线 ​

真相源 ​

一页结论 ​

当前已开放的构建表面 ​

CLI 与产物 ​

最小 manifest / workspace 子集 ​

sync build 子集 ​

async library build 子集 ​

async executable build 子集 ​

cleanup lowering 子集 ​

透明 ? lowering ​

当前回归规模 ​

当前明确未开放 ​

推荐阅读顺序 ​