Qlang

Appearance

P1-P8 阶段总览 ​

最后同步：2026-04-10

这页只保留阶段级结论、当前已核对的数量和继续推进的方向。 逐轮切片记录、旧版长文和本轮入口整理记录已归档到 路线图归档。

总体结论 ​

  • 这轮把 ordinary / cleanup control-flow selected transparent question-wrapped nested projected aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match ((if branch { tuple_left } else { tuple_right })?).outer.payload.values { (left, right) if left < right => ... }、match ((match branch { true => state_left, false => state_right })?).outer.payload.current { State { value } if value == 3 => ... } 与 match ((if branch { array_left } else { array_right })?).outer.payload.values { [first, middle, last] if middle == 5 => ... }，以及对应的 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 { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct question-wrapped nested projected aggregate、control-flow nested projected aggregate 与 control-flow question-wrapped nested call-root aggregate 三侧文案各自存在、但没有把 control-flow question-wrapped nested projected aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 control-flow question-wrapped nested projected tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup same-file import-alias transparent question-wrapped nested projected aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match (tuple_alias?).outer.payload.values { (left, right) if left < right => ... }、match (state_alias?).outer.payload.current { State { value } if value == 3 => ... } 与 match (array_alias?).outer.payload.values { [first, middle, last] if middle == 5 => ... }，以及对应的 defer match (cleanup_tuple_alias?).outer.payload.values { ... }、defer match (cleanup_state_alias?).outer.payload.current { ... } 与 defer match (cleanup_array_alias?).outer.payload.values { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct question-wrapped nested projected aggregate、same-file import-alias nested projected aggregate 与 import-alias question-wrapped nested call-root aggregate 三侧文案各自存在、但没有把 import-alias question-wrapped nested projected aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 import-alias question-wrapped nested projected tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup transparent question-wrapped nested projected aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match (tuple_env?).outer.payload.values { (left, right) if left < right => ... }、match (state_env?).outer.payload.current { State { value } if value == 3 => ... } 与 match (array_env?).outer.payload.values { [first, middle, last] if middle == 5 => ... }，以及对应的 defer match (tuple_env?).outer.payload.values { ... }、defer match (state_env?).outer.payload.current { ... } 与 defer match (array_env?).outer.payload.values { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct nested projected aggregate、question-wrapped projected aggregate 与 question-wrapped nested call-root aggregate 三侧文案各自存在、但没有把 question-wrapped nested projected aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 question-wrapped nested projected tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup same-file import-alias control-flow selected transparent question-wrapped projected aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match ((if branch { bundle_alias } else { alt_bundle_alias })()?).pair { (left, right) if left < right => ... }、match ((match branch { true => bundle_alias, false => alt_bundle_alias })()?).current { State { value } if value == 3 => ... } 与 match ((if branch { bundle_alias } else { alt_bundle_alias })()?).values { [first, middle, last] if middle == 5 => ... }，以及对应的 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 { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 import-alias question-wrapped projected aggregate、control-flow question-wrapped projected aggregate 与 import-alias control-flow projected aggregate 三侧文案各自存在、但没有把 import-alias control-flow question-wrapped projected aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 import-alias control-flow question-wrapped projected tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup control-flow selected transparent question-wrapped projected aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match ((if branch { bundle_value } else { alt_bundle_value })()?).pair { (left, right) if left < right => ... }、match ((match branch { true => bundle_value, false => alt_bundle_value })()?).current { State { value } if value == 3 => ... } 与 match ((if branch { bundle_value } else { alt_bundle_value })()?).values { [first, middle, last] if middle == 5 => ... }，以及对应的 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 { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct question-wrapped projected aggregate、control-flow projected aggregate 与 question-wrapped call-root aggregate 三侧文案各自存在、但没有把 control-flow question-wrapped projected aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 control-flow question-wrapped projected tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup same-file import-alias transparent question-wrapped projected aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match (bundle_alias()?).pair { (left, right) if left < right => ... }、match (bundle_alias()?).current { State { value } if value == 3 => ... }、match (bundle_alias()?).values { [first, middle, last] if middle == 5 => ... }，以及对应的 defer match (cleanup_bundle_alias()?).pair { ... }、defer match (cleanup_bundle_alias()?).current { ... } 与 defer match (cleanup_bundle_alias()?).values { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct question-wrapped projected aggregate、import-alias projected aggregate 与 cleanup for projected question-root 局部样例各自存在、但没有把 import-alias question-wrapped projected aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 import-alias question-wrapped projected tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup transparent question-wrapped projected aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match (bundle_value()?).pair { (left, right) if left < right => ... }、match (bundle_value()?).current { State { value } if value == 3 => ... } 与 match (bundle_value()?).values { [first, middle, last] if middle == 5 => ... }，以及对应的 defer match (bundle_value()?).pair { ... }、defer match (bundle_value()?).current { ... } 与 defer match (bundle_value()?).values { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 projected aggregate catch-all、match + ? 最小样例与 cleanup for projected question-root 局部样例各自存在、但没有把 question-wrapped projected aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 question-wrapped projected tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup same-file import-alias control-flow selected transparent question-wrapped nested call-root aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match ((if true { tuples } else { alt_tuples })(1)?).payload.values { (left, right) if left < right => ... }、match ((match true { true => states, false => alt_states })(3)?).payload.current { State { value } if value == 3 => ... } 与 match ((if true { deep } else { alt_deep })(4)?).outer.payload.values { [first, middle, last] if middle == 5 => ... }，以及对应的 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 { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 import-alias question-wrapped nested call-root aggregate 与既有 import-alias control-flow nested call-root aggregate 两侧文案各自存在、但没有把 import-alias control-flow question-wrapped nested call-root aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 import-alias control-flow question-wrapped nested call-root tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup control-flow selected transparent question-wrapped nested call-root aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match ((if true { tuple_env } else { alt_tuple_env })(1)?).payload.values { (left, right) if left < right => ... }、match ((match true { true => state_env, false => alt_state_env })(3)?).payload.current { State { value } if value == 3 => ... } 与 match ((if true { deep_env } else { alt_deep_env })(4)?).outer.payload.values { [first, middle, last] if middle == 5 => ... }，以及对应的 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 { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct question-wrapped nested call-root aggregate 与既有 control-flow nested call-root aggregate 两侧文案各自存在、但没有把 control-flow question-wrapped nested call-root aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 control-flow question-wrapped nested call-root tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup same-file import-alias transparent question-wrapped nested call-root aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match (tuples(1)?).payload.values { (left, right) if left < right => ... }、match (states(3)?).payload.current { State { value } if value == 3 => ... }、match (arrays(4)?).payload.values { [first, middle, last] if middle == 5 => ... } 与 match (deep(6)?).outer.payload.values { [first, middle, last] if middle == 7 => ... }，以及对应的 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 { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct question-wrapped nested call-root aggregate 与既有 import-alias nested call-root aggregate 两侧文案各自存在、但没有把 import-alias question-wrapped nested call-root aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 import-alias question-wrapped nested call-root tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup transparent question-wrapped nested call-root aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match (tuple_env(1)?).payload.values { (left, right) if left < right => ... }、match (state_env(3)?).payload.current { State { value } if value == 3 => ... }、match (array_env(4)?).payload.values { [first, middle, last] if middle == 5 => ... } 与 match (deep_env(6)?).outer.payload.values { [first, middle, last] if middle == 7 => ... }，以及对应的 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 { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct question-wrapped call-root aggregate、既有 nested call-root aggregate 与 projected question-root 局部样例各自存在、但没有把 question-wrapped nested call-root aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 question-wrapped nested call-root tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup same-file import-alias control-flow selected transparent question-wrapped call-root aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match (if branch { pair_alias } else { alt_pair_alias })()? { (left, right) if left < right => ... }、match (match branch { true => state_alias, false => alt_state_alias })()? { State { value } if value == 3 => ... }、match (if branch { values_alias } else { alt_values_alias })()? { [first, middle, last] if middle == 5 => ... }，以及对应的 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 })()? { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 import-alias question-wrapped call-root aggregate 与既有 import-alias control-flow call-root aggregate 两侧文案各自存在、但没有把 import-alias control-flow question-wrapped call-root aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 import-alias control-flow question-wrapped call-root tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup control-flow selected transparent question-wrapped call-root aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match (if branch { pair_value } else { alt_pair_value })()? { (left, right) if left < right => ... }、match (match branch { true => state_value, false => alt_state_value })()? { State { value } if value == 3 => ... }、match (if branch { values } else { alt_values })()? { [first, middle, last] if middle == 5 => ... }，以及对应的 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 })()? { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct question-wrapped call-root aggregate 与既有 control-flow call-root aggregate 两侧文案各自存在、但没有把 control-flow question-wrapped call-root aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 control-flow question-wrapped call-root tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup same-file import-alias transparent question-wrapped call-root aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match pair_alias()? { (left, right) if left < right => ... }、match state_alias()? { State { value } if value == 3 => ... }、match values_alias()? { [first, middle, last] if middle == 5 => ... }，以及对应的 defer match pair_alias()? { ... }、defer match state_alias()? { ... } 与 defer match values_alias()? { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct question-wrapped call-root aggregate 与既有 import-alias call-root aggregate 两侧文案各自存在、但没有把 import-alias question-wrapped call-root aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 import-alias question-wrapped call-root tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup transparent question-wrapped call-root aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match pair_value()? { (left, right) if left < right => ... }、match state_value()? { State { value } if value == 3 => ... }、match values()? { [first, middle, last] if middle == 5 => ... }，以及对应的 defer match pair_value()? { ... }、defer match state_value()? { ... } 与 defer match values()? { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 match + ? 最小标量样例与既有 call-root aggregate catch-all 文案各自存在、但没有把 question-wrapped call-root aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 question-wrapped call-root tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup same-file import-alias control-flow selected awaited call-root aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match await (if branch { pair_alias } else { pair_const_alias })(1) { (left, right) if left < right => ... }、match await (match branch { true => state_const_alias, false => state_alias })(3) { State { value } if value == 3 => ... }、match await (if branch { values_alias } else { values_const_alias })(4) { [first, middle, last] if middle == 5 => ... }，以及对应的 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) { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 import-alias awaited call-root aggregate catch-all 与 control-flow awaited call-root aggregate 文案各自存在、但没有把 same-file import-alias control-flow selected awaited call-root aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 same-file import-alias control-flow selected awaited call-root tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup control-flow selected awaited call-root aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match await (if branch { pair_value } else { PAIR_VALUE })(1) { (left, right) if left < right => ... }、match await (match branch { true => STATE_VALUE, false => state_value })(3) { State { value } if value == 3 => ... }、match await (if branch { values } else { VALUES })(4) { [first, middle, last] if middle == 5 => ... }，以及对应的 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) { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct awaited call-root aggregate catch-all 与 control-flow awaited projected aggregate 文案各自存在、但没有把 control-flow selected awaited call-root aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 control-flow selected awaited call-root tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup same-file import-alias awaited call-root aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match await pair_alias(1) { (left, right) if left < right => ... }、match await state_const_alias(3) { State { value } if value == 3 => ... }、match await values_alias(4) { [first, middle, last] if middle == 5 => ... }，以及对应的 defer match await pair_const_alias(4) { ... }、defer match await state_alias(6) { ... } 与 defer match await values_const_alias(7) { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct awaited call-root aggregate catch-all 与 import-alias awaited projected aggregate 文案各自存在、但没有把 same-file import-alias awaited call-root aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 same-file import-alias awaited call-root tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup direct awaited call-root aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match await pair_value(1) { (left, right) if left < right => ... }、match await state_value(3) { State { value } if value == 3 => ... }、match await values(4) { [first, middle, last] if middle == 5 => ... }，以及对应的 defer match await pair_value(4) { ... }、defer match await state_value(6) { ... } 与 defer match await values(7) { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 “match await ... aggregate catch-all” 这类泛化描述已经覆盖、但没有把 direct awaited call-root aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 direct awaited call-root tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup same-file import-alias control-flow selected call-root aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match (if branch { pair_alias } else { alt_pair_alias })() { (left, right) if left < right => ... }、match (match branch { true => state_alias, false => alt_state_alias })() { State { value } if value == 3 => ... }、match (if branch { values_alias } else { alt_values_alias })() { [first, middle, last] if middle == 5 => ... }，以及对应的 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 })() { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 same-file import-alias call-root aggregate catch-all 与 generic callable control-flow root 文案各自存在、但没有把 same-file import-alias control-flow selected call-root aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 same-file import-alias control-flow selected call-root tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup control-flow selected call-root aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match (if branch { pair_value } else { alt_pair_value })() { (left, right) if left < right => ... }、match (match branch { true => state_value, false => alt_state_value })() { State { value } if value == 3 => ... }、match (if branch { values } else { alt_values })() { [first, middle, last] if middle == 5 => ... }，以及对应的 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 })() { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct call-root aggregate catch-all 与更一般的 callable control-flow root 文案各自存在、但没有把 control-flow selected call-root aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 control-flow selected call-root tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup same-file import-alias control-flow selected nested projected aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match (if branch { left_tuple_alias } else { right_tuple_alias }).outer.payload.values { (left, right) if left < right => ... }、match (match branch { true => left_state_alias, false => right_state_alias }).outer.payload.current { State { value } if value == 3 => ... }、match (if branch { left_array_alias } else { right_array_alias }).outer.payload.values { [first, middle, last] if middle == 5 => ... }，以及对应的 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 { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 same-file import-alias nested projected aggregate catch-all 与 same-file import-alias control-flow selected projected root 文案各自存在、但没有把 same-file import-alias control-flow selected nested projected aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 same-file import-alias control-flow selected nested projected tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup control-flow selected nested projected aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match (if branch { tuple_left } else { tuple_right }).outer.payload.values { (left, right) if left < right => ... }、match (match branch { true => state_left, false => state_right }).outer.payload.current { State { value } if value == 3 => ... }、match (if branch { array_left } else { array_right }).outer.payload.values { [first, middle, last] if middle == 5 => ... }，以及对应的 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 { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct nested projected aggregate catch-all 与更一般的 control-flow selected nested projected root 文案各自存在、但没有把 control-flow selected nested projected aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 control-flow selected nested projected tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup same-file import-alias nested projected aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match tuple_alias.outer.payload.values { (left, right) if left < right => ... }、match state_alias.outer.payload.current { State { value } if value == 3 => ... }、match array_alias.outer.payload.values { [first, middle, last] if middle == 5 => ... }，以及对应的 defer match cleanup_tuple_alias.outer.payload.values { ... }、defer match cleanup_state_alias.outer.payload.current { ... } 与 defer match cleanup_array_alias.outer.payload.values { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 same-file import-alias projected aggregate catch-all 与更一般的 nested projected root 文案各自存在、但没有把 same-file import-alias nested projected aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 same-file import-alias nested projected tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup direct nested projected aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match tuple_env.outer.payload.values { (left, right) if left < right => ... }、match state_env.outer.payload.current { State { value } if value == 3 => ... }、match array_env.outer.payload.values { [first, middle, last] if middle == 5 => ... }，以及对应的 defer match tuple_env.outer.payload.values { ... }、defer match state_env.outer.payload.current { ... } 与 defer match array_env.outer.payload.values { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct projected aggregate catch-all 与更一般的 nested projected root 文案各自存在、但没有把 local nested projected aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 direct nested projected tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup same-file import-alias control-flow selected projected aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match (if branch { left_bundle_alias } else { right_bundle_alias }).pair { (left, right) if left < right => ... }、match (match branch { true => left_bundle_alias, false => right_bundle_alias }).current { State { value } if value == 3 => ... }、match (if branch { left_bundle_alias } else { right_bundle_alias }).values { [first, middle, last] if middle == 5 => ... }，以及对应的 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 { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 same-file import-alias projected aggregate catch-all 与 control-flow selected projected root 各自为政的隐式组合能力；对应路线图也已同步明确写出 same-file import-alias control-flow selected projected tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup same-file import-alias projected aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match bundle_alias.pair { (left, right) if left < right => ... }、match bundle_alias.current { State { value } if value == 3 => ... }、match bundle_alias.values { [first, middle, last] if middle == 5 => ... }，以及对应的 defer match cleanup_bundle_alias.pair { ... }、defer match cleanup_bundle_alias.current { ... } 与 defer match cleanup_bundle_alias.values { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct projected aggregate catch-all 与 same-file aggregate item alias root 各自为政的隐式组合能力；对应路线图也已同步明确写出 same-file import-alias projected tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup control-flow selected projected aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match (if branch { left } else { right }).pair { (left, right) if left < right => ... }、match (match branch { true => left, false => right }).current { State { value } if value == 3 => ... }、match (if branch { left } else { right }).values { [first, middle, last] if middle == 5 => ... }，以及对应的 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 { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct projected aggregate catch-all 与 generic control-flow selected projected root 各自为政的隐式组合能力；对应路线图也已同步明确写出 control-flow selected projected tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup same-file import-alias awaited nested projected aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match (await tuple_alias(1)).outer.payload.values { (left, right) if left < right => ... }、match (await state_const_alias(3)).outer.payload.current { State { value } if value == 3 => ... }、match (await array_alias(4)).outer.payload.values { [first, middle, last] if middle == 5 => ... }，以及对应的 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 { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct awaited nested projected aggregate catch-all 与 generic awaited alias root 各自为政的隐式组合能力；对应路线图也已同步明确写出 same-file import-alias awaited nested projected tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup same-file import-alias awaited projected aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match (await tuple_alias(1)).payload.values { (left, right) if left < right => ... }、match (await state_const_alias(3)).payload.current { State { value } if value == 3 => ... }、match (await array_alias(4)).payload.values { [first, middle, last] if middle == 5 => ... }，以及对应的 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 { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct awaited projected aggregate catch-all 与 generic awaited alias root 各自为政的隐式组合能力；对应路线图也已同步明确写出 same-file import-alias awaited projected tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup control-flow selected awaited projected aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match (await (if ... { tuple_env } else { TUPLE_ENV })(1)).payload.values { (left, right) if left < right => ... }、match (await (match ... { true => STATE_ENV, false => state_env })(3)).payload.current { State { value } if value == 3 => ... }、match (await (if ... { array_env } else { ARRAY_ENV })(4)).payload.values { [first, middle, last] if middle == 5 => ... }，以及对应的 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 { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct awaited projected aggregate catch-all 与 awaited control-flow root 各自为政的隐式组合能力；对应路线图也已同步明确写出 control-flow selected awaited projected tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup control-flow selected awaited nested projected aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match (await (if ... { tuple_env } else { TUPLE_ENV })(1)).outer.payload.values { (left, right) if left < right => ... }、match (await (match ... { true => STATE_ENV, false => state_env })(3)).outer.payload.current { State { value } if value == 3 => ... }、match (await (if ... { array_env } else { ARRAY_ENV })(4)).outer.payload.values { [first, middle, last] if middle == 5 => ... }，以及对应的 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 { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct awaited nested projected aggregate catch-all 与 awaited control-flow root 各自为政的隐式组合能力；对应路线图也已同步明确写出 control-flow selected awaited nested projected tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup same-file import-alias control-flow selected awaited nested projected aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match (await (if ... { tuple_alias } else { tuple_const_alias })(1)).outer.payload.values { (left, right) if left < right => ... }、match (await (match ... { true => state_const_alias, false => state_alias })(3)).outer.payload.current { State { value } if value == 3 => ... }、match (await (if ... { array_alias } else { array_const_alias })(4)).outer.payload.values { [first, middle, last] if middle == 5 => ... }，以及对应的 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 { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct awaited nested projected aggregate catch-all 与 awaited control-flow root 各自为政的隐式组合能力；对应路线图也已同步明确写出 same-file import-alias control-flow selected awaited nested projected tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup direct awaited nested projected aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match (await tuple_env(1)).outer.payload.values { (left, right) if left < right => ... }、match (await state_env(3)).outer.payload.current { State { value } if value == 3 => ... }、match (await array_env(4)).outer.payload.values { [first, middle, last] if middle == 5 => ... }，以及对应的 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 { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct awaited projected aggregate catch-all 与 generic awaited nested projection 各自存在、但没有把 nested projected aggregate catch-all 当作独立用户面承诺的隐式能力；对应路线图也已同步明确写出 direct awaited nested projected tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup same-file import-alias control-flow selected awaited projected aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match (await (if ... { tuple_alias } else { tuple_const_alias })(1)).payload.values { (left, right) if left < right => ... }、match (await (match ... { true => state_const_alias, false => state_alias })(3)).payload.current { State { value } if value == 3 => ... }、match (await (if ... { array_alias } else { array_const_alias })(4)).payload.values { [first, middle, last] if middle == 5 => ... }，以及对应的 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 { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 direct awaited projected aggregate catch-all 与 awaited control-flow root 各自为政的隐式组合能力；对应路线图也已同步明确写出 same-file import-alias control-flow selected awaited projected tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup direct awaited projected aggregate match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match (await tuple_env(1)).payload.values { (left, right) if left < right => ... }、match (await state_env(3)).payload.current { State { value } if value == 3 => ... }、match (await array_env(4)).payload.values { [first, middle, last] if middle == 5 => ... }，以及对应的 defer match (await tuple_env(1)).payload.values { ... }、defer match (await state_env(3)).payload.current { ... } 与 defer match (await array_env(4)).payload.values { ... } 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是文档里分散写着 “match (await ...).value projected scrutinee” 与 “match await ... aggregate catch-all” 两段泛化描述、但没有把 projected aggregate catch-all 作为单独用户面承诺的隐式能力；对应路线图也已同步明确写出 direct awaited projected tuple / struct / fixed-array aggregate catch-all 示例。
  • 这轮把 ordinary / cleanup direct / projected / call-root / same-file import-alias 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 loadable match catch-all public surface 正式对齐到 tuple / struct / fixed-array destructuring：match (1, 2) { (left, right) if left < right => ... }、match current { State { value } if value == 3 => ... }、match [1, 2, 3] { [first, _, last] if first < last => ... }，以及 match bundle.pair / bundle.current / bundle.values、match pair_value() / state_value() / values()、match pair_alias() / state_alias() / values_alias()、match tuple_env(1).payload.values / state_env(3).payload.current / deep_env(6).outer.payload.values、match tuples(1).payload.values / states(3).payload.current / deep(6).outer.payload.values、match (if ... { tuple_env } else { alt_tuple_env })(1).payload.values / match (match ... { true => state_env, false => alt_state_env })(3).payload.current / match (if ... { deep_env } else { alt_deep_env })(4).outer.payload.values 与 match (if ... { tuples } else { alt_tuples })(1).payload.values / match (match ... { true => states, false => alt_states })(3).payload.current / match (if ... { deep } else { alt_deep })(4).outer.payload.values 这类 projected-root / call-root / import-alias-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 版本，连同对应的 defer match 版本，现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 backend 已支持、文档仍用“loadable scrutinee catch-all”泛化描述的隐式能力；对应路线图也已同步明确写出 direct / projected / call-root / import-alias-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 catch-all 示例。
  • 这轮把 cleanup block public surface 也正式对齐到 fixed-array destructuring：defer { let [first, _, third] = [1, 2, 3]; ... }、defer { for [left, right] in ([4, 5], [6, 7]) { ... } } 与 defer { for await [left, right] in [worker(8), worker(10)] { ... } } 现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 cleanup lowering 内部已经打通、但公开文档仍停留在 tuple / struct 的隐式能力；对应 cleanup 路线图描述也已同步改成 tuple / struct / fixed-array destructuring 的真实支持面。
  • 这轮把 ordinary bind-pattern public surface 正式对齐到 fixed-array destructuring：ordinary let [first, _, third] = [1, 2, 3]、ordinary for [left, right] in ([4, 5], [6, 7]) 与 fixed-shape for await [left, right] in [worker(8), worker(10)] 现在都已由独立的 driver LLVM IR 回归与 ql build --emit obj fixture 锁住，不再只是 backend 内部已打通但文档未承诺的隐式能力；对应路线图也已同步改成 tuple / struct / fixed-array destructuring 的真实支持面。
  • 这轮继续把 ordinary awaited aggregate catch-all path 推到 fixed-array destructuring scrutinees：ordinary build surface 现在不再只限 ordinary match await ... 的 _ / single binding / tuple / struct destructuring catch-all，而是已继续接受首个 fixed-array destructuring scrutinee 子集，即 match await (if ... { values_alias } else { values_const_alias })(30) { [first, _, last] => ... } 与 match await (match ... { true => values_const_alias, false => values_alias })(13) { [first, middle, last] if first == 13 => ... } 这类 ordinary awaited fixed-array catch-all scrutinee 也可直接进入 shared scrutinee lowering。对应的 driver LLVM IR 回归、ql build --emit obj fixture，以及 ordinary bind-pattern fixed-array lowering 缺口都已单独锁住，因此 ordinary awaited aggregate catch-all family 已从 tuple/struct destructuring 继续推进到 fixed-array destructuring。
  • 这轮继续把 TaskHandle capturing closure transport 推到 cleanup awaited fixed-array destructuring scrutinees：capturing sync closure 现在不再只限 cleanup 的 tuple / struct aggregate destructuring scrutinee，而是已继续接受首个 fixed-array destructuring scrutinee 子集，即 defer { sink(match await (if ... { left } else { right })() { [first, _, last] => ... }) } 与 defer match await (match ... { true => left, false => right })() { [first, middle, last] if first == 30 => ... } 这类 fixed-array catch-all scrutinee 也可直接消费 closure 返回的 handle。对应的 driver LLVM IR 回归、ql build --emit obj fixture，以及 fixed-array pattern 的最小 parser/typeck/codegen 支撑都已单独锁住，因此这条 task-handle cleanup-awaited transport 已从 tuple/struct destructuring 继续推进到 fixed-array destructuring。
  • P1 到 P6 已完成，并且已经形成可持续扩展的工程主干。
  • P7 正在进行，但主线不是“重新设计 async”，而是在既有 compiler/runtime/build 真相源上保守扩面。
  • 这轮继续把 TaskHandle capturing closure transport 推到 cleanup awaited aggregate destructuring scrutinees：capturing sync closure 现在不再只限 cleanup 的 awaited aggregate current binding 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 => ... } 这类 tuple / struct catch-all scrutinee 也可直接消费 closure 返回的 handle。对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此这条 task-handle cleanup-awaited transport 已从 aggregate binding 继续推进到 aggregate destructuring。
  • 这轮继续把 TaskHandle capturing closure transport 推到 cleanup awaited aggregate binding scrutinees：capturing sync closure 现在不再只限 cleanup 的 projected awaited scalar 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 也可直接消费 closure 返回的 handle。对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此这条 task-handle cleanup-awaited transport 已开始进入 awaited aggregate scrutinee 面，而不再只停留在 scalar/projected value。
  • 这轮继续把 TaskHandle capturing closure transport 推到 cleanup awaited nested runtime projection values：capturing sync closure 现在不再只限 cleanup 的 direct awaited comparison 或 helper/inline awaited-value，而是已继续接受首个 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 也可直接消费 closure 返回的 handle。对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此这条 task-handle cleanup-awaited transport 已继续进入更广义的 cleanup control-flow projected-value 面。
  • 这轮继续把 TaskHandle capturing closure transport 推到 cleanup awaited helper/inline values：capturing sync closure 现在不再只限 cleanup defer if await ... / defer match await ... 这条最小 awaited guard/scrutinee 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 也可直接消费 closure 返回的 handle。对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此这条 task-handle cleanup-awaited transport 已开始真正进入更广义的 cleanup control-flow，而不再只停留在 direct awaited comparison。
  • 这轮继续把 TaskHandle capturing closure transport 推到 cleanup awaited tagged guarded-match different-closure alias roots：在上一轮 first tagged guarded-match different-closure root 基础上，cleanup defer if await ... 与 defer match await ... 现在都已继续接受首个 block-binding / local-alias-chain 版本，即先把 tagged/binding-pattern guarded match 选出的不同 closure 绑定给局部，再经 let rebound = chosen; rebound 这一层局部链继续调用并 await 返回的 handle。对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此 cleanup awaited tagged guarded-match path 已不再只限 direct root / block-local alias tail root。
  • 这轮继续把 TaskHandle capturing closure transport 推到 cleanup awaited tagged guarded-match different-closure roots：cleanup defer if await ... 与 defer match await ... 现在都已支持首个 tagged/binding-pattern guarded match 版本的 different-closure control-flow root，前者可直接 await match key { current if current == 42 => left, _ => right } 选出的 closure，后者可 await tagged guarded match 里 block-local alias tail 选出的 closure，并继续把返回的 handle 交给 cleanup guard / scrutinee。对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此 tagged guarded-match path 已不再只限 shared-local alias-chain 形态。
  • 这轮继续把 TaskHandle capturing closure transport 推到 cleanup awaited tagged guarded-match shared-local alias chains：cleanup defer if await ... 与 defer match await ... 现在都已支持首个 tagged/binding-pattern guarded match 版本的 shared-local control-flow assignment-valued binding alias-chain，即先通过 let chosen = match key { current if current == 42 => alias = right, _ => left } 收敛到同一条局部共享链，再经 let rebound = chosen; rebound 调用并 await 返回的 handle。对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此 task-handle guarded-match path 已不再只限 bool-scrutinee 形态。
  • 这轮继续把 TaskHandle capturing closure transport 推到 cleanup awaited guarded-match different-closure alias roots：在上一轮 first guarded-match different-closure root 基础上，cleanup defer if await ... 与 defer match await ... 现在都已继续接受首个 block-binding / local-alias-chain 版本，即先把 guarded match 选出的不同 closure 绑定给局部，再经 let rebound = chosen; rebound 这一层局部链继续调用并 await 返回的 handle。对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此 cleanup awaited guarded-match path 已不再只限 direct root / block-local alias tail root。
  • 这轮继续把 TaskHandle capturing closure transport 推到 cleanup awaited guarded-match different-closure roots：cleanup defer if await ... 与 defer match await ... 现在都已支持首个 guarded match 版本的 different-closure control-flow root，前者可直接 await match branch { true if guard() => left, false => right, _ => right } 选出的 closure，后者可 await guarded match 里 block-local alias tail 选出的 closure，并继续把返回的 handle 交给 cleanup guard / scrutinee。对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此 cleanup awaited guarded-match path 已不再只限 shared-local alias-chain 形态。
  • 这轮继续把 TaskHandle capturing closure transport 推到 cleanup awaited guarded-match shared-local alias chains：cleanup defer if await ... 与 defer match await ... 现在都已支持首个 guarded match 版本的 shared-local control-flow assignment-valued binding alias-chain，即先通过 let chosen = match branch { true if guard() => alias = right, false => left, _ => left } 收敛到同一条局部共享链，再经 let rebound = chosen; rebound 调用并 await 返回的 handle。对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此 cleanup awaited shared-local path 已不再只限无 guard 的 if / bool-match 形态。
  • 这轮继续把 TaskHandle capturing closure transport 推到 cleanup awaited shared-local alias chains：cleanup defer if await ... 与 defer match await ... 现在已支持首个 shared-local control-flow assignment-valued binding alias-chain 子集，即通过 let chosen = if branch { alias = right } else { left } 或 let chosen = match branch { true => alias = right, false => left } 先收敛到同一条局部共享链，再经 let rebound = chosen; rebound 调用并 await 返回的 handle。对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此 cleanup awaited path 已不再只停留在 direct / alias-tail root。
  • 这轮继续把 TaskHandle capturing closure transport 推到 cleanup awaited different-closure alias roots：在上一轮 first different-closure cleanup-awaited root 基础上，cleanup defer if await ... 与 defer match await ... 现在已继续接受首个 block-binding / local-alias-chain 版本，即先把 runtime-if 或 runtime-match 选出的不同 closure 绑定给局部，再经 let rebound = chosen; rebound 这一层局部链继续调用并 await 返回的 handle。对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此 cleanup awaited different-closure path 已不再只限 direct root / block-local alias tail root。
  • 这轮继续把 TaskHandle capturing closure transport 推到 cleanup awaited different-closure roots：cleanup defer if await ... 与 defer match await ... 现在都已开放首个 different-closure control-flow 子集，前者可直接 await runtime-if 选出的不同 closure root，后者可 await runtime-match 选出的 block-local alias tail closure root，并继续把各自返回的 captured TaskHandle 交给 cleanup guard / scrutinee。对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此 cleanup awaited path 现在不再只停留在 same-root/same-binding transport。
  • 这轮继续把 TaskHandle capturing closure transport 推到 cleanup awaited alias roots：cleanup defer if await ... 与 defer match await ... 现在已支持首个 block-local alias tail / local alias chain 子集，即先在 cleanup block 内把 runtime-if 或 integer-match 选出的 closure 绑定给局部，再经局部 alias 尾值继续调用并 await 返回的 handle。对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此 cleanup awaited path 已不再只限 direct/local-binding matrix。
  • 这轮继续把 TaskHandle capturing closure transport 推到 cleanup awaited root matrix：cleanup defer if await ... 与 defer match await ... 现在都已同时接受两类最小 root，即 runtime-if 选出的 direct closure root 与 ordinary integer-match 绑定出来的 local closure root，并把各自捕获的 immutable same-function TaskHandle binding 继续交给 cleanup guard / scrutinee。对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此这条 cleanup awaited callable transport 已不再只是“一边 direct、一边 binding”的半矩阵。
  • 这轮继续把 TaskHandle capturing closure transport 推到 cleanup awaited roots：sync closure 现在已支持在 cleanup defer if await <direct-root>() 与 defer match await <local-binding-root>() 里，分别 await runtime-if 选出的 direct closure root 和 ordinary integer-match 绑定出来的 local closure root，并把各自捕获的 immutable same-function TaskHandle binding 继续交给 cleanup guard / scrutinee。对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此任务句柄现在不再只停留在 ordinary path，而是正式进入最小 cleanup awaited callable transport surface。
  • 这轮继续把 TaskHandle capturing closure transport 推到 ordinary control-flow roots：sync closure 现在已支持在 ordinary if direct root 与 integer-match binding root 下选出不同的 non-move capturing closure，并把各自捕获的 immutable same-function TaskHandle binding 继续返回给外层 await。对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此任务句柄现在不再只停留在 direct local / local alias call，而是正式进入最小 ordinary control-flow callable transport surface。
  • 这轮继续把 capturing closure 推到 async value transport：sync closure 现在已支持 non-move 形态去捕获 immutable same-function TaskHandle binding，并经 ordinary direct local / local alias call 把 handle 返回给外层 await。对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此任务句柄现在不再只停留在 async item / const / static / root-level await value path，而是正式进入 capturing closure value flow。
  • 这轮继续把 String 推进到 capturing closure 本身：sync backend 现在已支持 non-move capturing sync closure 去捕获 immutable same-function String binding，并继续沿既有 by-value { ptr, i64 } ABI 传入 closure body。对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此这轮不是只扩比较或分派表面，而是把 String 真正推进到了 capturing closure value flow。
  • 这轮继续把 String 推到 guarded ordinary capturing-closure match call roots：sync backend 现在已支持 string match 选出的 direct call root 与 local binding root 去调用不同 capturing closure，并继续复用现有 bool guard 子集；LLVM lowering 会把这些 guarded closure-selection string-arm compare 统一接到已有的 memcmp-based string compare primitive。对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此 String 现在不再只停留在 unguarded ordinary closure-selection，而是进入最小 guarded closure-selection surface。
  • 这轮继续把 String 推到 ordinary capturing-closure match call roots：sync backend 现在已支持 string match 选出的 direct call root 与 local binding root 去调用不同 capturing closure，并继续限制在 same-file const / static path pattern + _ catch-all 的 unguarded 子集；LLVM lowering 会把这些 closure-selection string-arm compare 统一接到已有的 memcmp-based string compare primitive。对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此 String 现在不再只停留在普通值分派，而是正式进入最小 ordinary closure-selection surface。
  • 这轮继续把 String 推到 cleanup match：sync backend 现在已支持 defer match value { ... } 与 defer (match value { ... })(...) 里的 direct string literal arm、same-file const / static path pattern，以及 _ / binding catch-all，并继续复用现有 bool guard 子集；LLVM lowering 会把这些 cleanup string-arm compare 统一接到已有的 memcmp-based string compare primitive。对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此 String 现在不再只停留在 ordinary match，而是正式进入最小 cleanup pattern-dispatch surface。
  • 这轮把 sync build 里的 String ordered compare 也补进了真实可用 surface：left < right、left <= right、left > right 与 left >= right 现在都已在 ql-typeck 里放开为合法的 string lexicographic comparison，并在 LLVM lowering 里统一走 memcmp + prefix-length tiebreak；对应的 codegen 单测与 ql build object fixture 也已单独锁住，因此这条 String build 子集现在不再只停留在 == / !=。
  • 这轮继续把 String 的交付面补到 C header：ql ffi header 与 build-side header sidecar 现在都已支持把 extern "c" 函数里的 String 参数/返回值投影成 typedef struct ql_string { const uint8_t* ptr; int64_t len; } ql_string;，并在生成的 header 里稳定输出对应 declaration；driver 单测和 CLI 集成测试也已单独锁住，因此这条 String surface 现在不再只停留在 LLVM/object build 内部。
  • 这轮继续把 String 推进到 ordinary match：sync backend 现在已支持 direct string literal arm、same-file const / static path pattern，以及 _ / binding catch-all 的最小 match lowering，并继续复用现有 bool guard 子集；LLVM lowering 会把这些 string-arm compare 统一接到已有的 memcmp-based string compare primitive。对应的 driver LLVM IR 回归与 ql build --emit obj fixture 也已单独锁住，因此 String 现在不再只停留在 compare / FFI header，而是正式进入最小 ordinary pattern-dispatch surface。
  • P8 已进入前三条工程入口切片：最小 qlang.toml manifest graph、ql project graph、.qi V1 emit、ql build --emit-interface、ql check --sync-interfaces、package-aware dependency .qi syntax-load、dependency public symbol index，以及 imported dependency symbol 的最小 cross-file hover / definition / declaration / references、use ... 导入路径和平铺 / grouped import 位置里的 package path segment / public symbol completion、dependency enum variant completion、dependency struct explicit field-label completion、dependency struct member-field / member-method completion、completion item 上的 declaration/type markdown documentation、显式 type use 上的最小 textDocument/typeDefinition，以及 dependency enum variant token 到 dependency public enum declaration、dependency struct field token 到 dependency public field type、dependency method token 到 dependency public return type 的最小 textDocument/typeDefinition 子集；这条 receiver truth surface 现已覆盖 dependency method-call result local 及其 direct alias、direct dependency field-projection result local 及其 direct alias、struct destructuring / match destructuring 派生的 dependency local、typed closure param、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，而 dependency member-field / member-method completion 现在也会额外带出解析后的字段类型 / 返回类型；field/method token 若直接接 ?，对应的 typeDefinition 现在也会优先落到 Option[T] / Result[T, E] 解包后的 dependency public type。broken-source / semantic-error 场景下的 import-root / variant / struct-field / struct-member-field token / struct-member-method token 最小 hover / definition / declaration / references fallback 已落地，dependency value root 现也已补上最小 hover / definition / declaration / references fallback，并继续只收敛到 dependency public struct declaration 与当前文件内仍解析到同一 root binding 的引入/使用位置；对应的 dependency import/type-root / dependency enum variant token / dependency value root / dependency struct field token / dependency method token typeDefinition fallback 也都已接通；其中 inline tuple/array for loop binding、typed closure param，以及 value-position 的 imported dependency function / const / static root token 现在也已进入 field/method query 或 value-root query 与 broken-source fallback 合同。ql project emit-interface 现在也已支持从 workspace-only 根 manifest 批量写出成员包默认 .qi，并新增 --changed-only 只跳过 valid 的 package/member 接口，以及 --check 用于只校验这些默认接口是否都处于 valid 状态；其中 workspace --check 现会在一次执行中汇总全部无效 member interface 并输出摘要，ql project graph 现也已在 package/workspace 两条路径上展示默认 .qi 的路径/状态与引用 interface 状态，并把 manifest/源文件更新后的接口标记为 stale，而 package-aware ql check 现在也会把 stale dependency interface 视为显式失败，ql check --sync-interfaces 则只重发非 valid 的依赖 .qi；同一条保守 workspace/symbol 搜索现也已从“当前包源码 modules + 已加载 dependency .qi”扩到“当前 workspace 其它 member package 的源码 modules”，并在当前包因 source diagnostics 失败时保留 dependency/sibling-member 搜索；这几条入口现都已覆盖 package dir / manifest / package source file / workspace-only root manifest；更完整的 cross-file editor semantics 仍未开始实现。
  • 同一条 P8 receiver truth surface 本轮又继续前推了一小步：dependency for loop receiver 现在已从 direct tuple/array root 扩到 structured iterable root，只要 block / unsafe / if / match 的 tail/arm 仍稳定收敛到同一个 dependency tuple/array element binding，就会继续复用同一 receiver identity；因此 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 completion / query / broken-source value-root references 合同。
  • 这轮再把 structured iterable root 的 standalone member typeDefinition 也抽出来：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 } 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住到 dependency public Leaf declaration；连同前两轮已单独锁住的 member completion 与 member query，这条 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 也不再只散落在 value-root / member 专项回归里。
  • 这轮继续沿同一条 structured iterable root 往 root-token 级别收口：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 上由独立 regression 锁住 hover / definition / declaration / references，并继续分别固定到 dependency public Config / Child declaration；同一位置的 textDocument/typeDefinition 现在也已由独立 regression 锁住，并分别稳定跳到 dependency public Config / Child declaration。至此这条 structured iterable receiver 的 root-token query / typeDefinition 合同已闭合。
  • 这轮继续把同一条 receiver identity 里的 block 包裹 iterable root 的 standalone member typeDefinition 也抽出来：在前两轮已独立锁住 for current in { (config, config) } { current.va } 与 for current in { [config.child(), config.child()] } { current.ge } 这两条 member completion，以及 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 query 之后，for current in { (config, config) } { current.leaf.value } 与 for current in { [config.child(), config.child()] } { current.leaf().value } 这两条 member token 的 typeDefinition，现在也都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住到 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 往 root-token 级别收口：for current in { (config, config) } { current.value } 与 for current in { [config.child(), config.child()] } { current.value } 这两条路径上的 current token，现都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references，并继续分别固定到 dependency public Config / Child declaration。这让这条 block iterable root 的 value-root query 不再只靠大矩阵或泛化逻辑兜底。
  • 这轮再把同一条 block-wrapped iterable root 的 textDocument/typeDefinition 也单独抽出来：for current in { (config, config) } { current.value } 与 for current in { [config.child(), config.child()] } { current.value } 这两条路径上的 current token，现都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住到 dependency public Config / Child declaration；连同上一轮刚独立锁住的 value-root query，这条 block iterable root 的 root-token query / typeDefinition 合同现已闭合。
  • 这轮再把同一条 receiver identity 里的 unsafe 包裹 iterable root 的 standalone member typeDefinition 也抽出来：在前两轮已独立锁住 for current in unsafe { (config, config) } { current.va } 与 for current in unsafe { [config.child(), config.child()] } { current.ge } 这两条 member completion，以及 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 query 之后，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 路径与 broken-source fallback 上由独立 regression 锁住到 dependency public Leaf declaration；至此这条 unsafe-wrapped iterable root 的 standalone completion / query / member typeDefinition 合同已闭合。
  • 这轮继续沿同一条 unsafe-wrapped iterable root 往 root-token 级别收口：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 上由独立 regression 锁住 hover / definition / declaration / references，并继续固定到 dependency public struct declaration；同一位置的 textDocument/typeDefinition 现在也已由独立 regression 锁住，分别稳定跳到 dependency public Config / Child declaration。这让这条 unsafe iterable root 的 value-root query / typeDefinition 不再只靠大矩阵或泛化逻辑兜底。
  • 这轮再把 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 receiver truth surface 现在还继续扩到了 named iterable alias：let items = (config, config)、let items = if flag { (config, config) } else { (config, config) }、let items = match flag { ... } 这类局部 iterable alias 只要仍稳定收敛到同一个 dependency element binding，后续 for current in items { ... } 也会直接复用同一条 completion / query / broken-source fallback path，而不是再要求用户把 iterable 强行写回内联形式。
  • 这轮把 named iterable alias receiver 的 standalone regression 继续收口到最后一块：在前两轮已经独立锁住 let items = (config, config); for current in items { current.va } / { current.ge } 这两条 completion，以及 let items = (config, config); for current in items { current.value } / { current.get() } 这两条 member query 之后，let items = (config, config); for current in items { current.leaf.value } 与 let items = (config, config); for current in items { current.leaf().value } 这两条 member token 的 typeDefinition 现在也已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住到 dependency public Leaf declaration；至此 named iterable alias receiver 的 standalone completion / query / member typeDefinition 合同已闭合。
  • 这轮继续沿同一条 named iterable alias receiver 往 root-token 级别收口：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 上由独立 regression 锁住 hover / definition / declaration / references，并继续分别固定到 dependency public Config / Child declaration；同一位置的 textDocument/typeDefinition 现在也已由独立 regression 锁住，分别稳定跳到 dependency public Config / Child declaration。这让这条 named iterable alias root-token query / typeDefinition 不再只靠大矩阵或泛化逻辑兜底。
  • 这轮再把 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 truth surface 这一轮也继续扩到了同文件 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 completion / query path；其中 helper-array receiver 在 broken-source / semantic-error 条件下也继续保留 dependency method definition fallback。
  • 这轮把 helper-return iterable root 的 standalone regression 继续收口到最后一块：在前两轮已经独立锁住 for current in configs(config) { current.va } / for current in children(config) { current.ge } 这两条 member completion，以及 for current in configs(config) { current.value } / for current in children(config) { current.get() } 这两条 member query 之后，for current in configs(config) { current.leaf.value } 与 for current in children(config) { current.leaf().value } 这两条 member token 的 typeDefinition 现在也已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住到 dependency public Leaf declaration；至此 helper-return iterable receiver 的 standalone completion / query / member typeDefinition 合同已闭合。
  • 这轮继续沿同一条 helper-return iterable root 往 root-token 级别收口：for current in configs(config) { current.value } 与 for current in children(config) { current.value } 这两条路径上的 current token，现都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references，并继续分别固定到 dependency public Config / Child declaration；同一位置的 textDocument/typeDefinition 现在也已由独立 regression 锁住，分别稳定跳到 dependency public Config / Child declaration。这让这条 helper-return iterable root-token query / typeDefinition 不再只靠大矩阵或泛化逻辑兜底。
  • 这轮也把 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 也不再只散落在更大的 member/root 矩阵里。
  • 同一条 identity truth surface 现在还继续扩到了 dependency method-return iterable root：当 dependency method 显式返回 [Child; 2] 或 (Child, Child) 这类 tuple/array 时，for current in config.children() { current.value } 与 for current in config.pair() { current.get() } 也会继续落到同一条 dependency completion / query path，broken-source 条件下的 method definition fallback 也继续可用。
  • 这轮把 dependency method-return iterable root 的 standalone regression 继续收口到最后一块：在前两轮已经独立锁住 for current in config.children() { current.va } / for current in config.pair() { current.ge } 这两条 member completion，以及 for current in config.children() { current.value } / for current in config.pair() { current.get() } 这两条 member query 之后，for current in config.children() { current.leaf.value } 与 for current in config.pair() { current.leaf().value } 这两条 member token 的 typeDefinition 现在也已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住到 dependency public Leaf declaration；至此 method-return iterable receiver 的 standalone completion / query / member typeDefinition 合同已闭合。
  • 这轮继续沿同一条 dependency method-return iterable root 往 root-token 级别收口：for current in config.children() { current.value } 与 for current in config.pair() { current.get() } 这两条路径上的 current token，现都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references，并继续固定到 dependency public Child declaration；同一位置的 textDocument/typeDefinition 现在也已由独立 regression 锁住，并稳定跳到 dependency public Child declaration。这让这条 method-return iterable root-token query / typeDefinition 不再只靠大矩阵或泛化逻辑兜底。
  • 这轮再把 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 也不再只散落在更大的 member/root 矩阵里。
  • 同一条 identity truth surface 现在也已扩到 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 completion / query path。
  • 这轮把 dependency field iterable root 的 standalone regression 继续收口到最后一块：在前两轮已经独立锁住 for current in config.children { current.va } / for current in config.pair { current.ge } 这两条 member completion，以及 for current in config.children { current.value } / for current in config.pair { current.get() } 这两条 member query 之后，for current in config.children { current.leaf.value } 与 for current in config.pair { current.leaf().value } 这两条 member token 的 typeDefinition 现在也已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住到 dependency public Leaf declaration；至此 field iterable receiver 的 standalone completion / query / member typeDefinition 合同已闭合。
  • 这轮继续沿同一条 dependency field iterable root 往 root-token 级别收口：for current in config.children { current.value } 与 for current in config.pair { current.get() } 这两条路径上的 current token，现都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references，并继续固定到 dependency public Child declaration；同一位置的 textDocument/typeDefinition 现在也已由独立 regression 锁住，并稳定跳到 dependency public Child declaration。这让这条 field iterable root-token query / typeDefinition 不再只靠大矩阵或泛化逻辑兜底。
  • 这轮再把 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 也不再只散落在更大的 member/root 矩阵里。
  • 同一条 identity truth surface 现在也已扩到 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 completion / query path，broken-source 条件下的 method definition fallback 仍可复用；此前已把 for current in config.children? { current.va } 与 for current in config.pair()? { current.ge } 这两条 direct question iterable member completion，以及 for current in config.children? { current.value } 与 for current in config.pair()? { current.get() } 这两条 direct question iterable member query，都在成功 package analysis 路径与 broken-source fallback 上用独立 regression 锁住；这轮再把 for current in config.children? { current.leaf.value } 与 for current in config.pair()? { current.leaf().value } 这两条 member token 的 typeDefinition，也在成功 package analysis 路径与 broken-source fallback 上都用独立 regression 锁住到 dependency public Leaf declaration，因此 question-wrapped iterable root 的 standalone completion / query / member typeDefinition 已闭合。
  • 这轮继续沿同一条 question-wrapped iterable root 往 receiver binding 的 root-token 级别收口：for current in config.children? { current.value } 与 for current in config.pair()? { current.get() } 这两条路径上的 current token，现都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references，并继续固定到 dependency public Child declaration。这让这条 question-wrapped iterable receiver root-token query 不再只靠已有 member/query 矩阵隐式兜底。
  • 这轮再把同一组 question-wrapped iterable receiver binding root token 的 textDocument/typeDefinition 单独抽成独立 regression：for current in config.children? { current.value } 与 for current in config.pair()? { current.get() } 这两条路径上的 current token，现都已在成功 package analysis 路径与 broken-source fallback 上稳定跳到 dependency public Child declaration；连同上一轮已单独锁住的同组 hover / definition / declaration / references，这条 question-wrapped iterable receiver root-token query / typeDefinition 合同现已闭合。
  • 同一条 identity truth surface 现在也已扩到同文件本地 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 completion / query path。
  • 这轮再把同文件本地 receiver method iterable root 的 standalone member typeDefinition 也抽出来：for current in config.children() { current.leaf.value } 与 for current in self.pair() { current.leaf().value } 这两条 member token，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住到 dependency public Leaf declaration；连同前两轮已单独锁住的 member completion 与 member query，这条 receiver 的 standalone completion / query / member typeDefinition 合同现已闭合。
  • 这轮继续沿同一条同文件本地 receiver method iterable root 往 root-token 级别收口：for current in config.children() { current.value } 与 for current in self.pair() { current.get() } 这两条路径上的 current token，现都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references，并继续固定到 dependency public Child declaration；同一位置的 textDocument/typeDefinition 现在也已由独立 regression 锁住，并稳定跳到 dependency public Child declaration。至此这条 local-method iterable receiver 的 root-token query / typeDefinition 合同已闭合。
  • 这轮再把同文件本地 receiver method iterable 的最小 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 也不再只散落在更大的 member/root 矩阵里。
  • 同一条 identity truth surface 现在也已扩到 structured question-wrapped iterable root：当 if / match 的各分支最终都解包到同一个 dependency iterable element 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() } 也会继续落到同一条 dependency completion / query path；此前已把 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 completion，以及 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 iterable member query，都在成功 package analysis 路径与 broken-source fallback 上用独立 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 路径与 broken-source fallback 上都用独立 regression 锁住到 dependency public Leaf declaration，因此 structured question-wrapped iterable root 的 standalone completion / query / member typeDefinition 已闭合。
  • 这轮继续沿同一条 structured question-wrapped iterable root 往 receiver 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() } 这两条路径上的 current token，现都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references，并继续固定到 dependency public Child declaration。这让这条 structured question-wrapped iterable receiver root-token query 不再只靠已有 structured member/query 矩阵隐式兜底。
  • 这轮再把同一组 structured question-wrapped iterable receiver binding root token 的 textDocument/typeDefinition 单独抽成独立 regression：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() } 这两条路径上的 current token，现都已在成功 package analysis 路径与 broken-source fallback 上稳定跳到 dependency public Child declaration；连同上一轮已单独锁住的同组 hover / definition / declaration / references，这条 structured question-wrapped iterable receiver root-token query / typeDefinition 合同现已闭合。
  • 这轮把 imported dependency public function return 也并进了同一条 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 completion / query path；其中 function-return iterable receiver 在 broken-source / semantic-error 条件下也会继续保留 dependency method definition fallback。
  • 这轮也把 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 completion / query path；其中 const/static iterable receiver 在 broken-source / semantic-error 条件下也会继续保留 dependency method definition fallback。
  • 这轮再把 direct question-wrapped non-iterable imported receiver 的 member completion 也单独抽成独立 regression：当 use demo.dep.maybe_load / use demo.dep.MAYBE as child 唯一映射到 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 fallback 上由独立 regression 锁住 dependency field / method completion；连同此前已单独锁住的 maybe_load()?.value / maybe_load()?.get() 与 child?.value / child?.get() 这四条 direct member token 的 hover / definition / declaration / references，以及 maybe_load()?.leaf.value / maybe_load()?.leaf().value 与 child?.leaf.value / child?.leaf().value 这四条 direct member token 的 typeDefinition，这条 direct question-wrapped non-iterable receiver 的 standalone 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 回归里。
  • 这轮再把 structured direct question-wrapped non-iterable imported receiver 的 member typeDefinition 单独抽成独立 regression：在前一轮已锁住 (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 的 dependency field / method completion，以及 (...).value / (...).get() 这八条 structured direct member token 在成功 package analysis 路径与 broken-source fallback 上的 hover / definition / declaration / references 之后，这一轮又把 (...).leaf.value / (...).leaf().value 这八条 structured direct member token 的 typeDefinition 在成功 package analysis 路径与 broken-source fallback 上单独锁住；连同更早已单独锁住的同组 structured root token query / typeDefinition，这条 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 path，而在 broken-source / semantic-error 条件下，load_cfg()?.va / load_cfg()?.ge 与 maybe_cfg?.va / maybe_cfg?.ge 现在也都会继续保留 dependency field / method completion fallback；这轮再把 load_cfg()?.value / load_cfg()?.get() 与 maybe_cfg?.value / maybe_cfg?.get() 这四条 direct member token 的 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 fallback 上都用独立 regression 锁住，因此这条 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 member typeDefinition 补齐了：在前一轮已锁住 va / ge 这八条 direct member prefix 的 dependency field / method completion，以及 value / get() 这八条 direct member token 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，现在也都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 typeDefinition；因此这条 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 回归里。
  • 这轮继续把同一条 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 }，现都已在成功路径与 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 往 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 锁住，并稳定跳到 dependency public Child declaration。至此这条 grouped question iterable receiver root-token query / typeDefinition 合同现已闭合，不再只靠既有 member/query 矩阵隐式兜底。
  • 这轮把同一条 grouped alias + question-wrapped iterable receiver 的 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 往 receiver binding 的 root-token 级别拆成 standalone regression：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 锁住，并稳定跳到 dependency public Child declaration。至此这条 structured grouped question iterable receiver root-token query / typeDefinition 合同现已闭合，不再只靠既有 structured member/query 矩阵隐式兜底。
  • 这轮把同一条 structured grouped alias + question-wrapped iterable receiver 的 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 合同现已闭合。
  • 这轮把同一条 structured grouped alias + question-wrapped iterable receiver 的 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 的 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 的 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 合同现已闭合。
  • 这轮再把 structured direct question-wrapped iterable 的 member typeDefinition 单独抽成独立 regression：在前两轮已锁住 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 的 dependency field / method completion，以及同一组 structured receiver 上 current.value / current.get() 八个 member token 的 hover / definition / declaration / references 之后，这一轮又把 current.leaf.value / current.leaf().value 这八条 structured direct iterable member token 的 typeDefinition，在成功 package analysis 路径与 broken-source fallback 上都由独立 regression 锁住；连同更早已单独锁住的 structured root token query / typeDefinition，这条 structured direct question-wrapped iterable receiver 的 member completion + query + typeDefinition 合同现已闭合。
  • 这轮再把 direct question-wrapped iterable member completion 单独抽成独立 regression：for current in maybe_children()? { current.va }、for current in maybe_children()? { current.ge }、for current in items? { current.va } 与 for current in items? { current.ge } 这四条 direct member prefix，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 dependency field / method completion；连同前两轮已单独锁住的 direct question-wrapped iterable root query + typeDefinition，这条 imported iterable root truth surface 现在只剩 direct question-wrapped iterable member 的 query / typeDefinition 仍待后续独立切片。
  • 这轮再把 direct question-wrapped iterable member query 单独抽成独立 regression：for current in maybe_children()? { current.value }、for current in maybe_children()? { current.get() }、for current in items? { current.value } 与 for current in items? { current.get() } 这四条 direct member token，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references；连同此前已单独锁住的 direct question-wrapped iterable member completion，以及 direct / structured question-wrapped iterable root query + typeDefinition，这条 imported iterable root truth surface 现在只剩 direct question-wrapped iterable member 的 typeDefinition 仍待后续独立切片。
  • 这轮再把 direct question-wrapped iterable member typeDefinition 单独抽成独立 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 } 这四条 direct member token，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住到 dependency public Leaf declaration 的跳转；连同此前已单独锁住的 direct question-wrapped iterable member completion / query，以及 direct / structured question-wrapped iterable root query + typeDefinition，这条 imported iterable root truth surface 的 direct question-wrapped iterable member 合同现已闭合。
  • 这轮再把同一条 direct question-wrapped iterable receiver 的最小 local-binding contract 单独抽成 standalone regression：for current in maybe_children()? { current.va } 现已在成功 package analysis 路径与 broken-source fallback 上由独立 bindings regression 锁住 dependency field completion，而 for current in items? { current.get() } 这条绑定后的 direct member definition 也已在 broken-source fallback 上由独立 regression 锁住到 dependency public method declaration；这让 direct question iterable receiver 的 standalone bindings 不再只散落在 member/root 专项切片里。
  • 这轮再把同一条 structured direct question-wrapped iterable receiver 的最小 local-binding contract 单独抽成 standalone regression：for current in (if flag { maybe_children()? } else { maybe_children()? }) { current.va } 现已在成功 package analysis 路径与 broken-source fallback 上由独立 bindings regression 锁住 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 的 standalone bindings 不再只散落在 member/root 专项切片里。
  • imported dependency public function / const / static 的 value / iterable root token 这轮也补上了完整 query：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 上的 alias token，再加上 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? 上的 alias token，以及 grouped alias + question-wrapped iterable 形态下 use demo.dep.{maybe_children as kids} / use demo.dep.{MAYBE_ITEMS as maybe_items} 后续 kids()? / maybe_items? 上的 alias token，当前已在成功 package analysis 路径与 dependency-only fallback 上接通 hover / definition / declaration / references，并继续共享同一条 typeDefinition truth source；其中 hover / definition / declaration 现在都会落到解析后的 dependency public struct，references 则返回该 struct declaration 加当前文件内仍解析到同一 root binding 的 import local name 引入/使用位置，而 typeDefinition 现在也已显式锁定了 value/iterable-root 这组例子，并在这轮把 question-wrapped imported value/iterable root、grouped alias 下的 kids() / items，以及 grouped alias + question-wrapped 下成功路径与 broken-source fallback 都已单独回归锁定的 load_cfg()? / maybe_cfg? / kids()? / maybe_items?，连同成功路径与 broken-source fallback 都已单独回归锁定的 direct maybe_load()? / child? / maybe_children()? / items? 一并锁进同一条 struct 跳转合同；此前已补齐的是 direct function iterable fallback 里的 maybe_children()? query / typeDefinition，随后又把 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 锁住，随后又把 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()? } 这十条 structured root 的成功路径与 broken-source fallback query / typeDefinition 一并锁进同一合同；前一轮再把 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 合同现也已闭合；上一轮进一步把 grouped alias + question-wrapped iterable 形态下的 direct 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 的跳转；此前已单独抽出的则是 grouped alias + question-wrapped non-iterable 形态下的 direct root query / typeDefinition，以及 structured grouped alias + question-wrapped non-iterable root query 与 typeDefinition。use demo.dep.load / use demo.dep.DEFAULT as cfg 这类 import binding token 本身仍继续保留 imported symbol contract，不和 value / iterable root token 混用。
  • 这轮再把 direct question-unwrapped dependency receiver 的 completion 半矩阵补齐：config.child?.va 上的 field completion 与 config.child()?.ge 上的 method completion，现在也已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住；连同前一轮已补齐的 field / method hover / declaration / references / definition 与 typeDefinition，这条 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；这让这条 direct question-unwrapped receiver 的 completion 也不再只散落在 question_dependency_bindings 这类早期混合文件里。
  • 这轮再把同一条 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；这让这条 direct question-unwrapped receiver 的 query 也不再继续散落在 question_dependency_bindings 这类早期混合文件里。
  • 这轮再把 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；这让这条 direct question-unwrapped receiver 的 typeDefinition 也不再继续散落在 question_dependency_bindings 这类早期混合文件里。
  • 这轮再把 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；这让这条 direct question-unwrapped receiver 的 local-binding contract 也不再继续散落在 question_dependency_bindings 这类早期混合文件里。
  • 这轮也把 structured question-unwrapped dependency receiver 的 member typeDefinition 半矩阵补齐了：(if flag { config.child? } else { config.child? }).leaf.value、(match flag { true => config.child?, false => config.child? }).leaf.value、(if flag { config.child()? } else { config.child()? }).leaf().value 与 (match flag { true => config.child()?, false => config.child()? }).leaf().value 这四条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 member typeDefinition；连同前一轮已锁住的 field / method completion，以及更早已锁住的 hover / definition / declaration / references，这条 structured question-unwrapped receiver 的 member completion / query / definition / typeDefinition 合同现已闭合。
  • 这轮再把 structured question-unwrapped dependency receiver 的 member query 也单独抽成独立 regression：(if flag { config.child? } else { config.child? }).value、(match flag { true => config.child?, false => config.child? }).value、(if flag { config.child()? } else { config.child()? }).get() 与 (match flag { true => config.child()?, false => config.child()? }).get() 这四条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references；连同此前已单独锁住的 va / ge completion 与 (...).leaf.value / (...).leaf().value member typeDefinition，这条 structured question-unwrapped receiver 的 standalone member contract 现已闭合。
  • 这轮又把同一条 value-root slice 上的 structured 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 上由独立 regression 锁住 hover / definition / declaration / references；连同此前已存在的 typeDefinition，这条 direct + structured question-unwrapped root 合同现已闭合。
  • 这轮也把同一条 structured question-unwrapped receiver root 上的 typeDefinition 半矩阵单独锁住了：(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 上由独立 regression 锁到同一个解包后 dependency public struct declaration；至此，这条 direct + structured question-unwrapped root 的 query + typeDefinition 合同已真正全部闭合。
  • 这轮再把 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；这让这条 structured question-unwrapped receiver 的 local-binding contract 也不再继续散落在 question_structured_dependency_bindings 这类早期混合文件里。
  • 这轮再把 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，并继续固定到同一个解包后 dependency public Child declaration；这让这条 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 的 query + typeDefinition 合同不再继续依赖早期的泛化 root type matrix。
  • 这轮再把同一条 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 不再只散落在更大的 question-unwrapped root / receiver truth surface 里。
  • 这轮再把同一条 question-unwrapped local receiver 的 field-question completion success-path 也单独抽成独立 regression：let current = config.child?; return current.va 这条路径上的 va 前缀，现已在成功 package analysis 路径上由独立 regression 锁住到 dependency field value completion；这让这条 field-question completion 不再只继续混在旧的 question_unwrapped_local_completion 半矩阵里。
  • 这轮再把同一条 question-unwrapped local receiver 的 field-question completion fallback 也单独抽成独立 regression：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 半矩阵里。
  • 这轮再把同一条 question-unwrapped local receiver 的 method-return completion success-path 也单独抽成独立 regression：let current = config.child()?; return current.ge 这条路径上的 ge 前缀，现已在成功 package analysis 路径上由独立 regression 锁住到 dependency method get completion；这让这条 method-return completion 也不再只继续混在旧的 question_unwrapped_local_completion 半矩阵里。
  • 这轮再把同一条 question-unwrapped local receiver 的 method-return completion fallback 也单独抽成独立 regression：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 也已可以退场，不再继续承担半矩阵兜底职责。
  • 这轮再把同一条 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 也不再只散落在更大的 question-unwrapped root / receiver truth surface 里。
  • 这轮再把同一条 question-unwrapped local receiver 的 field-question member query success-path 也单独抽成独立 regression：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 半矩阵里。
  • 这轮再把同一条 question-unwrapped local receiver 的 field-question member query fallback 也单独抽成独立 regression：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 半矩阵里。
  • 这轮再把同一条 question-unwrapped local receiver 的 method-return member query success-path 也单独抽成独立 regression：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 半矩阵里。
  • 这轮再把同一条 question-unwrapped local receiver 的 method-return member query fallback 也单独抽成独立 regression：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 也已可以退场，不再继续承担半矩阵兜底职责。
  • 这轮再把同一条 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 现已闭合。
  • 这轮再把同一条 question-unwrapped local receiver 的 field-question member typeDefinition success-path 也单独抽成独立 regression：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 半矩阵里。
  • 这轮再把同一条 question-unwrapped local receiver 的 field-question member typeDefinition fallback 也单独抽成独立 regression：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 半矩阵里。
  • 这轮再把同一条 question-unwrapped local receiver 的 method-return member typeDefinition success-path 也单独抽成独立 regression：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 半矩阵里。
  • 这轮再把同一条 question-unwrapped local receiver 的 method-return member typeDefinition fallback 也单独抽成独立 regression：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 也已可以退场，不再继续承担半矩阵兜底职责。
  • 这轮再把同一条 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 专项回归里。
  • 这轮再把同一条 question-unwrapped local receiver 的 field-question bindings success-path 也单独抽成独立 regression：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 半矩阵里。
  • 这轮再把同一条 question-unwrapped local receiver 的 field-question bindings fallback 也单独抽成独立 regression：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 半矩阵里。
  • 这轮再把同一条 question-unwrapped local receiver 的 method-return bindings success-path 也单独抽成独立 regression：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 半矩阵里。
  • 这轮再把同一条 question-unwrapped local receiver 的 method-return bindings fallback 也单独抽成独立 regression：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 value root slice 这轮继续收口独立 success-path regression：对能从语法局部唯一恢复为 dependency struct 的 typed closure param、普通 named local、destructured local、inline tuple/array for loop binding、question-unwrapped local、direct field-projection / method-call / structured receiver 派生值，以及 impl / extend 方法体 self receiver，value root token 本身现在都会在成功分析路径下接通 hover / definition / declaration / references，而不是只在 broken-source fallback 里生效；当前结果仍固定为 dependency public struct declaration 与当前文件内的同 binding 局部引用。此前独立 regression 先锁定了 let project = (current: Cfg) => current.value 这类 closure parameter 形态，随后再把 let current = config; current.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 的同一组 query 单独抽成独立 regression；这轮又把这两条 direct root token 的 broken-source fallback 也分别锁住，因此 inline tuple/array for loop binding root query 合同现已闭合；与此同时，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 这轮也已单独锁住，因此这条 alias root query 合同现在也已闭合；而 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 这轮也已单独锁住，因此这条 alias root query 合同现在也已闭合；这轮再把 extend Cfg { pub fn read(self) -> Int { let first = self.value; let second = self.value; return "oops" } } 这条 self receiver root token 的 broken-source fallback 也单独锁住，因此这条 self root query 合同现在也已闭合；这轮再把 let project = (current: Cfg) => { let first = current.value; let second = current.value; return "oops" } 这条 typed closure param root token 的 broken-source fallback 也单独锁住，因此这条 typed closure root query 合同现在也已闭合；这轮再把 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 也单独锁住，因此这条 alias root query 合同现在也已闭合。接着再把 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 hover / definition / declaration / references 也单独锁住；与此同时，let current = if flag { config.child() } else { config.child() }; let alias = current; alias.value、let current = match flag { ... }; let alias = current; alias.value 与 let current = { config.child() }; let alias = current; alias.value 这组 direct alias value-root query 这轮也补齐到成功 package analysis 路径与 broken-source fallback，继续避免 package bridge 退回普通 local query 语义。
  • 这轮再把 structured result local 的 direct value-root fallback 也单独补齐了：let current = if flag { config.child() } else { config.child() }; let first = current.value; let second = current.value; return "oops" 与 let current = match flag { true => config.child(), false => config.child() }; let first = current.value; let second = current.value; return "oops" 这两条路径上的 current token，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references，并继续固定到 dependency public Child declaration；同一位置的 textDocument/typeDefinition 这轮也已在成功 package analysis 路径与 broken-source fallback 上单独锁住到 dependency public Child declaration。连同此前已单独锁住的 success-path regression，这条 structured result local direct root token 的 query / typeDefinition 合同现已闭合；而这轮继续把 let current = { config.child() }; let first = current.value; let second = current.value; return "oops" 这条 block-tail direct local root token 也补齐到同一条 success-path + broken-source fallback query / typeDefinition 合同，因此 block-tail direct local root 这条剩余切片现在也已闭合。
  • 这轮再把同一条 syntax-local dependency value root slice 里的普通 named local direct root fallback 也单独补齐了：let current = config; let first = current.value; let second = current.value; return "oops" 这条路径上的 current token，现在也已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references，并继续固定到 dependency public Config declaration；连同此前已单独锁住的 success-path regression，这条 named local direct root token query 合同现也已闭合。
  • 这轮再把同一条 syntax-local dependency value root slice 里的 destructured local direct root fallback 也单独补齐了：let Cfg { child } = config; let first = child.value; let second = child.value; return "oops" 这条路径上的 child token，现在也已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references，并继续固定到 dependency public Child declaration；连同此前已单独锁住的 success-path regression，这条 destructured local direct root token query 合同现也已闭合。
  • 这轮再把同一条 syntax-local dependency value root slice 里的 direct field-projection result local fallback 也单独补齐了：let current = config.child; let first = current.value; let second = current.value; return "oops" 这条路径上的 current token，现在也已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references，并继续固定到 dependency public Child declaration；连同此前已单独锁住的 success-path regression，这条 projected-field result local direct root token query 合同现也已闭合。
  • 这轮再把同一条 syntax-local dependency value root slice 里的 direct method-call result local fallback 也单独补齐了：let current = config.child(); let first = current.value; let second = current.value; return "oops" 这条路径上的 current token，现在也已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references，并继续固定到 dependency public Child declaration；连同此前已单独锁住的 success-path regression，这条 method-result local direct root token query 合同现也已闭合。
  • 这轮再把同一条 question-unwrapped local receiver 的 field-question root query fallback 也单独抽成独立 regression：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 里。
  • 这轮再把同一条 question-unwrapped local receiver 的 field-question root typeDefinition fallback 也单独抽成独立 regression：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 里。
  • 这轮再把同一条 question-unwrapped local receiver 的 method-return root query 也单独抽成独立 regression：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 形态上。
  • 这轮再把同一条 question-unwrapped local receiver 的 method-return root typeDefinition 也单独抽成独立 regression：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 里。
  • 这轮再把 structured result local 的 direct alias member query 也单独抽成独立 regression：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 = 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() 这四条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references；这轮又把 let current = if flag { config.child() } else { config.child() }; let alias = current; alias.va / .ge 与 let current = match flag { true => config.child(), false => config.child() }; let alias = current; alias.va / .ge 这四条 direct alias member prefix completion 也单独抽成独立 regression，覆盖成功 package analysis 路径与 broken-source fallback；连同此前已单独锁住、并在这轮把 broken-source fallback 也补齐的 structured alias value-root query / typeDefinition、member definition 与 member typeDefinition，这条 structured alias receiver 的 standalone completion / query / definition / typeDefinition 合同现已闭合。
  • 这轮再把 block tail result local 的 direct alias member prefix completion 也单独抽成独立 regression：let current = { config.child() }; let alias = current; alias.va 与 let current = { config.child() }; let alias = current; alias.ge 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 completion；连同此前已单独锁住的 block-tail alias value-root query / typeDefinition、member definition 与 member typeDefinition，这条 block-tail alias receiver 现在也补上了独立 completion 这一角。
  • 这轮再把 block tail result local 的 direct alias member query 也单独抽成独立 regression：let current = { config.child() }; let alias = current; alias.value 与 let current = { config.child() }; let alias = current; alias.get() 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references；连同此前已单独锁住的 block-tail alias value-root query / typeDefinition、member definition、member typeDefinition 与独立 completion，这条 block-tail alias receiver 的 standalone completion / query / definition / typeDefinition 合同现已闭合。
  • 这轮再把 impl / extend 方法体里的 dependency self receiver member query 也单独抽成独立 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(); ... } } 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references；这让文档里已经承诺的 self.value / self.get() member query 不再只靠大矩阵或混合测试兜底，但 self receiver 上的 completion / member typeDefinition 仍待继续拆出 standalone regression。
  • 这轮再把 dependency self receiver member prefix completion 也单独抽成独立 regression：extend Cfg { pub fn read(self) -> Int { return self.va } } 与 extend Cfg { pub fn read(self) -> Int { return self.ge } } 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 completion；至此 self receiver 上还没拆成 standalone regression 的只剩 member typeDefinition。
  • 这轮再把 dependency self receiver member typeDefinition 也单独抽成独立 regression：extend Cfg { pub fn read(self) -> Int { return self.leaf.value } } 与 extend Cfg { pub fn read(self) -> Int { return self.leaf().value } } 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住到 dependency public Leaf declaration；连同此前已单独锁住的 self receiver value-root query / typeDefinition、member query、member definition 与 completion，这条 self receiver 的 standalone completion / query / definition / typeDefinition 合同现已闭合。
  • 这轮再把 typed closure parameter receiver 的 member prefix completion 也单独抽成独立 regression：let project = (current: Cfg) => current.va 与 let project = (current: Cfg) => current.ge 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 completion；这让文档里已承诺的 typed closure receiver completion 不再只靠大矩阵兜底，后续只需继续把 member query / member typeDefinition 也拆出来。
  • 这轮再把 typed closure parameter receiver 的 member query 也单独抽成独立 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(); ... } 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references；至此 typed closure receiver 上还没拆成 standalone regression 的只剩 member typeDefinition。
  • 这轮再把 typed closure parameter receiver 的 member typeDefinition 也单独抽成独立 regression：let project = (current: Cfg) => current.leaf.value 与 let project = (current: Cfg) => current.leaf().value 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住到 dependency public Leaf declaration；连同此前已单独锁住的 typed closure receiver value-root query / typeDefinition、member query、member definition 与 completion，这条 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 专项回归里。
  • 这轮再把 dependency field-projection result local 的 direct alias member definition 也单独抽成独立 regression：let current = config.child; let alias = current; return alias.value 与 let current = config.child; let alias = current; let value = alias.get(); ... 这两条路径，现在已分别在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 definition；这让文档里已经承诺的 projected-field alias receiver definition 不再只靠大矩阵或混合测试兜底，后续只需继续把 completion / query / member typeDefinition 拆出来。
  • 这轮再把 dependency field-projection result local 的 direct alias member prefix completion 也单独抽成独立 regression：let current = config.child; let alias = current; return alias.va 与 let current = config.child; let alias = current; return alias.ge 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 completion。
  • 这轮再把 dependency field-projection result local 的 direct alias member query 也单独抽成独立 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(); ... 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references。
  • 这轮再把 dependency field-projection result local 的 direct alias member typeDefinition 也单独抽成独立 regression：let current = config.child; let alias = current; return alias.leaf.value 与 let current = config.child; let alias = current; return alias.leaf().value 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住到 dependency public Leaf declaration；连同此前已单独锁住的 projected-field alias receiver value-root query / typeDefinition、member definition、completion 与 member query，这条 receiver 的 standalone completion / query / definition / typeDefinition 合同现已闭合。
  • 这轮开始转到下一条最邻近的 dependency method-call result local alias receiver，并先把 standalone member definition 抽出来：let current = config.child(); let alias = current; return alias.value 与 let current = config.child(); let alias = current; let value = alias.get(); ... 这两条路径，现在已分别在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 definition；这让文档里已经承诺的 method-result alias receiver definition 不再只靠大矩阵或混合测试兜底，后续继续补 completion / query / member typeDefinition 即可。
  • 这轮再把 dependency method-call result local alias receiver 的 standalone member prefix completion 也抽出来：let current = config.child(); let alias = current; return alias.va 与 let current = config.child(); let alias = current; return alias.ge 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 completion；至此 method-result alias receiver 上还没拆成 standalone regression 的只剩 member query 与 member typeDefinition。
  • 这轮再把 dependency method-call result local alias receiver 的 standalone member query 也抽出来：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(); ... 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references。
  • 这轮再把 dependency method-call result local alias receiver 的 standalone member typeDefinition 也抽出来：let current = config.child(); let alias = current; return alias.leaf.value 与 let current = config.child(); let alias = current; return alias.leaf().value 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住到 dependency public Leaf declaration；连同此前已单独锁住的 method-result alias receiver value-root query / typeDefinition、member definition、completion 与 member query，这条 receiver 的 standalone completion / query / definition / typeDefinition 合同现已闭合。
  • 当前最重要的治理要求仍然是三者一致：
    • 代码里的真实实现
    • 测试里的真实合同
    • 文档里的当前结论

阶段状态 ​

阶段状态已形成的稳定边界
P1已完成Rust workspace、lexer、parser、formatter、CLI 前端闭环
P2已完成HIR、resolve、first-pass typeck、统一 diagnostics、最小 query / LSP
P3已完成结构化 MIR、ownership facts、cleanup-aware 分析、closure groundwork
P4已完成ql build、LLVM IR、obj / exe / dylib / staticlib、driver/codegen 边界
P5已完成最小 C ABI 闭环、header projection、C/Rust host examples、FFI 集成回归
P6已完成same-file hover / definition / references / rename / completion / semantic tokens / document symbols / package-rooted conservative workspace symbols / LSP parity
P7进行中受控 async/runtime/task-handle lowering、library/program build 子集、Rust interop 扩展
P8启动中最小 qlang.toml manifest graph、ql project graph、.qi V1 emit、package-aware dependency .qi load、后续 cross-file LSP 入口

各阶段一句话总结 ​

P1 前端闭环 ​

  • 解决了“仓库能不能作为真实编译器工程演进”的问题。

P2 语义与查询地基 ​

  • HIR、resolve、typeck、diagnostics、analysis 与最小 LSP 已接到同一条语义流水线。

P3 MIR 与所有权地基 ​

  • MIR、ownership facts、cleanup-aware analysis 与 closure groundwork 已成立，但不应误读为完整 borrow/drop 系统已经完成。

P4 后端与产物 ​

  • ql build 已能真实产出 llvm-ir、obj、exe、dylib、staticlib，toolchain discovery 和 codegen golden test 边界已稳定。

P5 FFI 与 C ABI ​

  • 最小 C ABI、header projection、C/Rust host 示例和集成回归都已经进入真实工程工作流。

P6 编辑器与语义一致性 ​

  • same-file LSP/query 的共享 truth surface 已形成，hover / definition / references / rename / completion / semantic tokens 之外，当前同一份真相源也已接出 document symbol outline 与保守的 package-rooted workspace/symbol 搜索；该搜索现会从已打开 package 扩到同包源码 modules、同 workspace 的其它 member package 源码 modules，并带上已加载 dependency .qi public symbols；当前包如果因 source diagnostics 暂时无法完整装载，也会保留 dependency / sibling-member 搜索，而不是立刻退化成 open-document-only；后续 editor work 默认应继续复用 analysis。

P7 async / runtime / Rust interop ​

当前已形成的 P7 事实面可以压缩成下面几条：

  • Task[T]、最小 runtime hook ABI skeleton、ql runtime truth surface 已成立。
  • async library build 已开放 staticlib 和最小 async dylib 子集；稳定外部边界仍是同步 extern "c" C ABI。
  • async executable build 已开放 BuildEmit::LlvmIr / Object / Executable 下的最小 async fn main 子集。
  • 当前受控子集已经覆盖主要 await / spawn payload family、projected task-handle consume/reinit、stable-dynamic 与 guard-refined dynamic path、fixed-shape for await、awaited match guard，以及 sync/async assignment-expression executable surface。
  • sync ordinary executable surface 已覆盖 fixed-shape for、assignment-expression、dynamic non-Task[...] array assignment、same-file foldable const / static item value materialization，以及当前受控 match guard family。
  • 更广义的 async ABI、cleanup codegen、generalized iterable、broader dylib / program bootstrap，以及更广 projection-sensitive ownership precision 仍然刻意关闭。

P8 项目级工具链与 cross-file editor 入口 ​

  • ql-project 现已提供最小 qlang.toml manifest loader。
  • 当前真实 contract 已锁定在 [package].name、[workspace].members、[references].packages。
  • ql project graph [file-or-dir] 已可向上发现 manifest 并输出当前 package/workspace/reference graph；package manifest 当前会额外显示默认 .qi 路径/状态与引用 interface 状态，workspace-only 根 manifest 则会进一步展开 member package 的 manifest、包名、默认 .qi 路径/状态、references 与引用 interface 状态；当 manifest 或任一 src/**/*.ql 比 .qi 更新时，状态会标记为 stale。
  • ql project emit-interface [file-or-dir] [-o <output>] [--changed-only] [--check] 已可对 package manifest 的 src/**/*.ql 做逐文件分析，并输出 text-based .qi public interface artifact；新增 --changed-only 后，若目标接口已是 valid 状态则会跳过并报告 up-to-date interface: ...；新增 --check 后，则会只验证默认 .qi 是否处于 valid 状态；workspace-only 根 manifest 现在会把同轮内全部无效 member interface 汇总报告
  • ql build <file> --emit-interface 现也可在构建成功后顺手写出当前包默认 <package>.qi，让声明文件生成不再只挂在单独的 project 子命令上。
  • ql check 现也会在 package-aware 路径上把 stale dependency interface 视为显式失败，并给出 --sync-interfaces / ql project emit-interface 的修复指引。
  • ql check --sync-interfaces 现会在 package-aware check 前递归同步写出本地引用包默认 <package>.qi，减少依赖接口需要手工预生成的摩擦；当前该开关已支持 package directory、qlang.toml 路径、包内源码文件路径，以及 workspace-only 根 manifest，并会对重复 dependency 写出做去重；同时现在只会对非 valid 的依赖 interface 执行重发。
  • ql-analysis::analyze_package 与 package-aware ql check 现已开始加载 [references].packages 指向的 dependency .qi artifact，并在 interface 缺失时显式失败；当前 package-aware ql check 入口已覆盖 package directory、qlang.toml、包内源码文件路径，以及 workspace-only 根 manifest，后者会顺序检查每个 workspace member package。
  • 当前 dependency .qi load 已推进到 syntax-aware section parse：每个 // source: ... module section 都会进入 interface-mode AST，支持 bodyless fn / impl / extend 声明以及无值 const / static 接口声明；ql-analysis::analyze_package 现也已把公开 dependency symbols 收进 package 级 truth surface，并接通 imported dependency symbol 的 cross-file hover / definition / declaration / references 到 .qi declaration；这条查询链当前也已显式覆盖 grouped import alias 形态。与此同时，use ... 导入路径和平铺 / grouped import 位置里的 dependency package path segment / public symbol completion 也已打通，且 grouped import 的空补全位会过滤已写过的 dependency item，减少重复提示；rename、更广义 completion 与真实 dependency build graph 仍未开放。
  • 同一条 completion bridge 现在也会把已有的 CompletionItem.detail / ty 直接映射成 LSP markdown documentation，让 same-file 与 dependency-backed completion 都能显示 declaration snippet 与类型提示，而不是只保留 label/detail；其中 dependency member-field / member-method completion 现在也已补齐 ty，不再只显示 declaration 文本。
  • dependency-only 回退现在还带有最小编辑期容错：当当前文档自身暂时分析失败时，真实 ql-lsp backend 仍会走 dependency-only package load 回退，继续提供 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；dependency enum variant token、struct-field token（含 explicit / shorthand）与 syntax-local 可恢复 receiver 上的首个 dependency struct member-field token / member-method token 现在也已在同一路径下补齐最小 hover / definition / declaration / references 回退，而 dependency enum variant token 的最小 textDocument/typeDefinition 回退也已接上；与此同时，parse-only 可恢复的 dependency value root 现在也已补上最小 hover / definition / declaration / references 回退，除了 named local、typed closure param、inline tuple/array for loop binding 与 impl / extend 方法体 self receiver 之外，这轮也把 value-position 的 imported dependency function / const / static root token，以及 for iterable 头部的 imported dependency function / const root token（例如 maybe_load()?.value 上的 maybe_load、child?.value 上的 child、load_cfg()?.value 上的 load_cfg、maybe_cfg?.value 上的 maybe_cfg、children() 上的 children、ITEMS 上的 ITEMS、maybe_children()? 上的 maybe_children、items? 上的 items、grouped import alias 形态下 kids() / items 上的 alias token，以及 grouped alias + question-wrapped 形态下 load_cfg()? / maybe_cfg? / kids()? / maybe_items? 上的 alias token）并进了同一条 fallback path；同一批 imported value/iterable root token 的 typeDefinition 也已显式回归锁定，这轮则进一步把 question-wrapped imported value/iterable root token、grouped alias 下的 root token，以及 grouped alias + question-wrapped root token 一并锁进同一条 fallback struct 跳转合同，而不是退回 imported symbol 语义，其中 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 单独锁定；这轮又补齐了 direct static fallback 下 (if flag { child? } else { child? }) / match flag { true => child?, false => child? } 与 (if flag { items? } else { items? }) / match flag { true => items?, false => items? } 这四条 structured root token query / typeDefinition，并把 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 也单独锁到 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 }。同一 receiver slice 上的 dependency field / method completion 也已继续可用，并新增 inline tuple/array for loop binding 与 typed closure param；该路径当前仍不扩大到 broader member query、任意表达式 receiver 或其它同文件补全。
  • dependency enum import-local root 的首个 non-import-path query contract 这轮正式从 alias 形态扩成完整导入局部名合同：当 use demo.dep.Command as Cmd、use demo.dep.Command 或 use demo.dep.{Command} 这类导入形态能唯一映射到 dependency public enum 时，Cmd.Re / Command.Re 现都可通过 .qi public surface 继续补全到 Retry 等 variants，而 Cmd.Retry / Command.Retry 这类 variant token 也都已接通 dependency hover / definition / declaration / references，并可通过 textDocument/typeDefinition 跳到 dependency enum declaration；与此同时，当当前文档仅有 same-file 语义错误时，真实 ql-lsp backend 现在也会继续从该 variant token 提供 dependency hover / definition / declaration / references 与 typeDefinition 回退；更广义 dependency member completion 仍未开放。
  • dependency struct import-local root 的首个 field contract 这轮也从 alias 形态扩成完整导入局部名合同：当 use demo.dep.Config as Cfg、use demo.dep.Config 或 use demo.dep.{Config} 这类导入形态能唯一映射到 dependency 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-field token 查询当前已覆盖 explicit 与 shorthand 两种写法，并继续支持 dependency hover / definition / declaration / references；与此同时，对能从语法局部恢复为 dependency struct 的 named local value，config.value / built.value / current.value / config.child.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 这类 member field token 现在也已接通同一条 dependency hover / definition / declaration / references，而 config.va / built.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 这类 syntax-local member prefix 也已接通 dependency field completion；当前 receiver slice 也已扩到 let current = config.child、let current = config.child()、let Cfg { child } = config、let current = if flag { config.child() } else { config.child() }、let current = match flag { ... }、let current = { config.child() } 及其 direct alias、以及 for current in (config, config) { current.value } 这类 inline tuple/array for loop binding；named local receiver 的 standalone bindings / completion / query / member typeDefinition 已全部收口后，这轮继续把 destructured local receiver 的 return child.va / return child.ge 这组 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" 这组 member query，以及 let Cfg { child } = config; return child.leaf.value / let Cfg { child } = config; return child.leaf().value 连同 broken-source 下 let Cfg { child } = config; let value = child.leaf.value; return "oops" / let Cfg { child } = config; let value = child.leaf().value; return "oops" 这组 member typeDefinition 单独抽成独立 regression；至此 destructured local receiver 的 standalone bindings / completion / query / member typeDefinition 也已全部收口。
  • 这轮再把 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；这让这条 destructured local receiver 的 local-binding contract 也不再继续散落在 destructured_dependency_bindings 这类早期混合文件里。
  • 同一条 direct structured receiver slice 这轮开始拆 standalone member regression：return (if flag { config.child() } else { config.child() }).va / .ge 与 return (match flag { true => config.child(), false => config.child() }).va / .ge 这四条 direct structured receiver member completion，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住；direct structured receiver 的 standalone member query 与 member typeDefinition 仍待继续拆分。
  • 同一条 direct structured receiver slice 这轮继续拆 standalone member regression：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() 这四组 direct structured receiver member query，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references；direct structured receiver 剩余待继续拆分的只剩 member typeDefinition。
  • 同一条 direct structured receiver slice 这轮再把 standalone member regression 收口到 typeDefinition：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 这四条 direct structured receiver member typeDefinition，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住到 dependency public Leaf declaration；至此 direct structured receiver 的 standalone bindings / completion / query / member typeDefinition 也已全部收口。
  • 这轮再把 direct structured receiver 的最小 standalone bindings regression 也抽出来：return (if flag { config.child() } else { config.child() }).value 现已在成功 package analysis 路径上单独锁住 dependency field definition，而 let value = (match flag { true => config.child(), false => config.child() }).get(); return "oops" 这条绑定后的 direct member definition 也已在 broken-source fallback 上由独立 regression 锁住到 dependency public method declaration；这让 direct structured receiver 的最小 local-binding contract 也不再只散落在 member 专项切片里。
  • 这轮开始转到下一条最邻近的 direct dependency method-call result receiver，并先把 standalone member completion 抽出来：return config.child().va 与 return config.child().ge 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 completion；至此这条 direct method-result receiver 上还没拆成 standalone regression 的只剩 member query 与 member typeDefinition。
  • 这轮继续把同一条 direct dependency method-call result receiver 的 standalone member query 也抽出来：let first = config.child().value; let second = config.child().value; ... 与 let first = config.child().get(); let second = config.child().get(); ... 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references。
  • 这轮再把同一条 direct dependency method-call result receiver 的 standalone member typeDefinition 也抽出来：return config.child().leaf.value 与 return config.child().leaf().value 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住到 dependency public Leaf declaration；至此这条 direct method-result 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 专项切片里。
  • 这轮开始转到下一条最邻近的 direct dependency field-projection result receiver，并先把 standalone member completion 抽出来：return config.child.va 与 return config.child.ge 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 completion；至此这条 direct projected-field receiver 上还没拆成 standalone regression 的只剩 member query 与 member typeDefinition。
  • 这轮继续把同一条 direct dependency field-projection result receiver 的 standalone member query 也抽出来：let first = config.child.value; let second = config.child.value; ... 与 let first = config.child.get(); let second = config.child.get(); ... 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references；至此这条 direct projected-field receiver 上还没拆成 standalone regression 的只剩 member typeDefinition。
  • 这轮再把同一条 direct dependency field-projection result receiver 的 standalone member typeDefinition 也抽出来：return config.child.leaf.value 与 return config.child.leaf().value 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住到 dependency public Leaf declaration；至此这条 direct projected-field receiver 的 standalone completion / query / typeDefinition 合同也已收口。
  • 这轮开始转到下一条最邻近的 direct dependency block-tail result receiver，并先把 standalone member completion 抽出来：return ({ config.child() }).va 与 return ({ config.child() }).ge 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 completion；至此这条 direct block-tail receiver 上还没拆成 standalone regression 的只剩 member query 与 member typeDefinition。
  • 这轮继续把同一条 direct dependency block-tail result receiver 的 standalone member query 也抽出来：let first = ({ config.child() }).value; let second = ({ config.child() }).value; ... 与 let first = ({ config.child() }).get(); let second = ({ config.child() }).get(); ... 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references；至此这条 direct block-tail receiver 上还没拆成 standalone regression 的只剩 member typeDefinition。
  • 这轮再把同一条 direct dependency block-tail result receiver 的 standalone member typeDefinition 也抽出来：return ({ config.child() }).leaf.value 与 return ({ config.child() }).leaf().value 这两条路径，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住到 dependency public Leaf declaration；至此这条 direct block-tail receiver 的 standalone completion / query / typeDefinition 合同也已收口。
  • 这轮再把同一条 direct dependency block-tail 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 block-tail receiver 的最小 local-binding contract 也不再只散落在 member 专项切片里。
  • dependency struct local-value member path 的首个 method contract 也已落地并补齐到 completion 与 broken-source fallback：当 use demo.dep.Config as Cfg 这类 alias 能唯一映射到 dependency public struct，并且 .qi 中该 nominal struct 的 public method 仍可唯一解析（当前继续遵守 impl 优先、再看 extend 的保守规则）时，config.get() / built.get() / 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() 这类 member method token 现在已在成功分析路径与 same-file semantic-error fallback 上接通 dependency hover / definition / declaration / references，而 config.ge / built.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 这类 syntax-local member prefix 也已接通 dependency method completion；当前 receiver slice 也已扩到 dependency method-call result local、block tail result及其 direct alias、inline tuple/array for loop binding，以及结果稳定收敛到同一个 dependency struct 的 if / match structured result local 及其 direct alias；这条能力当前仍只覆盖语法局部可恢复出的 named local receiver，不扩展到任意表达式 receiver。
  • 上述 for loop receiver 切片本轮还明确补上了 structured iterable root 这条相邻真实用法：for current in { (config, config) } { current.value }、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 receiver identity，而不是再单独分叉出新的 ad-hoc query path。
  • 这条 for receiver identity 现在也已验证可以跨过同文件 helper 的显式返回类型，而不是只识别字面量 / alias root：fn configs(config: Cfg) -> (Cfg, Cfg) 与 fn children(config: Cfg) -> [Child; 2] 这类 helper 现在都已能把 element binding 传给后续 for current in ... 的 dependency field/method completion 与 method definition query。
  • 这条 for receiver identity 现在也已验证可以跨过 dependency method 的显式 iterable 返回类型，而不是只识别 local helper：config.children() 与 config.pair() 这类 dependency method-call root 现在也已能把 element binding 传给后续 for current in ... 的 dependency field/method completion 与 method definition query。
  • 这条 for receiver identity 现在也已验证可以直接落在 dependency field iterable root 上，而不是只识别 helper/call：config.children 与 config.pair 这类 dependency field root 现在也已能把 element binding 传给后续 for current in ... 的 dependency field/method completion 与 method definition query。
  • 这条 for receiver identity 现在也已验证可以穿过 ? 继续保留 iterable element binding：config.children? 与 config.pair()? 这类 question-wrapped field/method iterable root 现在也已能把解包后的 element binding 传给后续 for current in ... 的 dependency field/method completion 与 method definition query。
  • 这条 for receiver identity 现在也已验证可以跨过同文件本地 receiver method，而不是只认 dependency interface / free function：config.children() 与 self.pair() 这类 local method iterable root 现在也已能把返回类型里的 element binding 传给后续 for current in ... 的 dependency field/method completion 与 method definition query。
  • 这条 for receiver identity 现在也已验证可以让 ? 与 structured root 叠加，而不是只能各自单独工作：(if flag { config.children? } else { config.children? }) 与 match flag { true => config.pair()?, false => config.pair()? } 这类 root 现在也已能把解包后的 element binding 传给后续 for current in ... 的 dependency field/method completion 与 method definition query。
  • 这轮继续沿 imported dependency value root 这条 cross-file completion / identity contract 往前拆 standalone regression：return load().va / return load().ge 这组 imported dependency function-result root member completion，以及 return current.va / return current.ge 这组 imported dependency static root member completion，现在都已在成功 package analysis 路径与 broken-source fallback 上由独立 regression 锁住；这让 value-position 的 imported dependency function / static root token member completion 不再只散落在既有混合 bindings 回归里。
  • 这轮继续沿同一条 imported dependency value root 线前推 standalone 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 路径与 broken-source fallback 上由独立 regression 锁住 hover / definition / declaration / references；这让 value-position 的 imported dependency function / static root member query 也不再只散落在既有混合 bindings 回归里。
  • 这轮继续沿同一条 imported dependency value root 线把 standalone 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 路径与 broken-source 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 .qi 的 rename 消费这轮继续把第一条真实编辑链路从 alias 形态扩到完整 import-local name：除了 use demo.dep.Config as Cfg 与 grouped import alias 之外，use demo.dep.Config 与 use demo.dep.{Config} 这类 direct import local name 现在也都已支持最小 prepareRename / rename，并直接产出当前文件内的 rename edits；其中 direct import 定义位不会误改 dependency path，而是会自动重写成 Config as Settings 这类合法 alias 形式，再同步更新当前文件里的 type/value 使用位。同一条 bridge 现在继续复用 package analysis 成功路径与 dependency-only broken-source fallback，因此当前文件即使暂时存在 same-file semantic errors，只要语法仍可恢复、dependency package 仍可装载，这条 dependency import-local rename 也不会整体失效。当前仍刻意不开放 dependency member token rename 与跨文件 workspace rename。
  • 显式 type-namespace 位置上的最小 textDocument/typeDefinition 现也已接到同一份 analysis identity truth surface，并开始小步扩到 value-position 的受控子集：same-file type use 当前覆盖 struct / enum / trait / type alias / generic 定义，same-file local import type alias use 会优先跳到底层本地类型定义，而 package-aware 成功分析路径下的 dependency import/type root（例如 Buf[Int]）也已可跳到 dependency .qi artifact 内的 public type declaration；与此同时，dependency enum variant token 现在也可跳到 dependency public enum declaration，对能从语法局部恢复出 dependency struct 类型的 named local value，value token 本身现在也可跳到 dependency public struct declaration，而 dependency struct field token 本身现在也可在字段声明类型唯一映射到 dependency public type 时跳到对应 .qi public type declaration，dependency method token 本身现在也可在返回类型唯一映射到 dependency public type 时跳到对应 .qi public type declaration；当 field/method token 后面直接接 ? 时，这条跳转还会优先落到 Option[T] / Result[T, E] 解包后的 dependency public type；当当前文档存在 same-file semantic errors、但语法仍可恢复且 dependency package 仍可加载时，这几条 dependency typeDefinition 都已补上 broken-source fallback；这轮继续把 value-root typeDefinition 的 success-path 局部绑定形态从大矩阵里拆出来：除了前两轮已单独锁住的 let current = config.child?; current.value 这类 question-unwrapped local root token，以及 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、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；这轮又把这两条 inline tuple/array for loop binding direct root token 的 broken-source fallback struct 跳转也分别锁住，因此它们的 value-root typeDefinition 合同现已闭合；与此同时，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 跳转这轮也已单独锁住，因此这条 alias root typeDefinition 合同现在也已闭合，而 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 跳转这轮也已单独锁住，因此这条 alias root typeDefinition 合同现在也已闭合；这轮再把 extend Cfg { pub fn read(self) -> Int { let value = self.value; return "oops" } } 这条 self receiver root token 的 broken-source fallback struct 跳转也单独锁住，因此这条 self root typeDefinition 合同现在也已闭合；这轮再把 let project = (current: Cfg) => { let value = current.value; return "oops" } 这条 typed closure param root token 的 broken-source fallback struct 跳转也单独锁住，因此这条 typed closure root typeDefinition 合同现在也已闭合；这轮再把 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 跳转也单独锁住，因此这条 alias root typeDefinition 合同现在也已闭合。与此同时，let current = if flag { config.child() } else { config.child() }; let alias = current; alias.value、let current = match flag { ... }; let alias = current; alias.value 与 let current = { config.child() }; let alias = current; alias.value 这组 structured/block-tail direct alias value-root typeDefinition，现在也都已在成功 package analysis 路径与 broken-source fallback 上单独锁住到 dependency public struct declaration；而 let current = if flag { config.child() } else { config.child() }; let alias = current; alias.leaf.value、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 与 let current = { config.child() }; let alias = current; alias.leaf().value 这类 structured/block-tail alias receiver 上的 dependency field/method token，也已在成功 package analysis 路径与 broken-source fallback 上单独锁住到 dependency public Leaf declaration 的 typeDefinition；当前仍不做更广义值位推断 type jump，也不扩到任意表达式 receiver 或更广义 non-type-context fallback。
  • 这轮再把最直接的 named local direct root typeDefinition fallback 也单独抽成独立 regression：let current = config; let value = current.value; return "oops" 这条路径上的 current token，现已在成功 package analysis 路径与 broken-source fallback 上都锁到 dependency public Config declaration；连同此前已单独锁住的 success-path regression，这条 named local direct root typeDefinition 合同现也已闭合。
  • 这轮再把最直接的 destructured local direct root typeDefinition fallback 也单独抽成独立 regression：let Cfg { child } = config; let value = child.value; return "oops" 这条路径上的 child token，现已在成功 package analysis 路径与 broken-source fallback 上都锁到 dependency public Child declaration；连同此前已单独锁住的 success-path regression，这条 destructured local direct root typeDefinition 合同现也已闭合。
  • 这轮再把最直接的 direct field-projection result local root typeDefinition fallback 也单独抽成独立 regression：let current = config.child; let value = current.value; return "oops" 这条路径上的 current token，现已在成功 package analysis 路径与 broken-source fallback 上都锁到 dependency public Child declaration；连同此前已单独锁住的 success-path regression，这条 projected-field result local direct root typeDefinition 合同现也已闭合。
  • 这轮再把最直接的 direct method-call result local root typeDefinition fallback 也单独抽成独立 regression：let current = config.child(); let value = current.value; return "oops" 这条路径上的 current token，现已在成功 package analysis 路径与 broken-source fallback 上都锁到 dependency public Child declaration；连同此前已单独锁住的 success-path regression，这条 method-result local direct root typeDefinition 合同现也已闭合。

当前进度对账 ​

本轮已按代码和测试重新核对当前入口文档，结果如下：

  • crates/ql-cli/tests/executable_examples.rs 当前编码了 60 个 sync local executable case。
  • crates/ql-cli/tests/executable_examples.rs 当前编码了 222 个 async local executable case。
  • 这些 case 默认指向本地忽略的 ramdon_tests/... smoke 目录；当前 checkout 不提交该目录。
  • async 本地样例的历史命名编号曾走到 225，但编号最大值不等于当前注册 case 数；入口文档已经统一按测试矩阵表述。

当前最值得继续推进的方向 ​

  1. 继续沿已开放的 async executable / library 子集扩真实用户可写 surface，而不是另开 ABI 或 runtime 设计。
  2. 继续让 task-handle、dynamic path、for await、awaited match 这几条线共享同一份 truth source。
  3. 按已固定顺序继续推进 Phase 8：dependency .qi 的 syntax-aware load、public symbol index、hover / definition / declaration / references、第一段 imported local-name rename（现已覆盖 alias 与 direct import），以及 use ... 导入路径 completion、import-root/enum-variant/struct-field-token 的最小 broken-source query fallback 已落地；下一步应继续扩真正需要的 cross-file completion/identity contract 与更广义 rename truth surface，但暂时仍不直接跳到 full workspace rename。

归档入口 ​

如果你需要追溯更细的历史记录，请看：

Qlang research repository

Copyright 2026