feat(lang): M2 遮蔽语法 [描述](实现) — 描述不执行,payload 是唯一执行体

新增 Expr::Occluded { label, payload: Option<Box<Expr>> }:
- [] 描述:自由文本,永不执行(仅用于检索/统计/过期校验)
- () 实现:唯一执行体;为空时值为 None(空载荷桩)
- 支持嵌套遮蔽、描述含空格与中文标点、\] 转义

关键决策:**模式开关,暂不切换语义**
[键](集合) 与 [描述](实现) 外形完全相同;M2 若直接改语义,全仓 506 处取元会
静默变成"遮蔽整个集合"(同形换义,文档点名的最坏一类)。
故 M2 只实现能力:
- 默认 Classic:MARQDO_MARKUP 未设 → [a](b) 仍是取元
- 纯度 Occlusion:MARQDO_MARKUP=occlusion/purity/1/on → 遮蔽
M7 才迁移语料、翻转默认、对旧形报 syntax.legacy_index 硬错误。

实现:
- ast.rs 新节点
- parse/expr.rs:Markup 枚举 + set_markup_default + parse_expr_markup(显式模式,
  避免测试依赖全局) + parse_occluded(描述扫描到 ]、\] 转义、必须紧跟 (、
  空载荷 → None)+ Parser.markup 字段
- interp.rs:有 payload 求值 payload,否则 None;collect_decl_reads 递归 payload
- bytecode/compile.rs:编译 payload(空则 Op::None_),双后端一致
- view/render.rs:expr_prec 渲染 [描述](payload) / [描述]()
- parse/mod.rs:pub mod expr
- main.rs:MARQDO_MARKUP 环境变量(init_markup_from_env)

测试:
- 8 个单元(值直通/空载荷/描述空格标点/转义/嵌套/classic 仍取元/缺括号报错)
- 3 个集成 tests/occlusion.rs + tests/occlusion/*.mq.md
- 全量 cargo test --release:575 passed / 0 failed(M1 后 565 + 10)
- tree 与 bytecode 双后端一致

文档:doc/design/change-m2-occlusion.md
This commit is contained in:
cflmy committed 2026-10-22 15:11:59 +08:00
1 parent 13012cac0e
commit 11417c42e0
11 files changed
+424 -1

No files matched your search

+178
View File
@@ -8,6 +8,38 @@ pub fn parse_expr(input: &str) -> Result<Expr> {
parse_expr_mode(input, false)
}
/// Markup mode for `[描述](实现)` vs the legacy `[键](集合)` index. `<TAB>` M2
///
/// `Classic` keeps today's index semantics; `Occlusion` reads the same shape as
/// an occlusion. The default is `Classic` until M7 migrates the corpus and flips
/// the gate (otherwise every legacy index would silently change meaning).
#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
pub enum Markup {
#[default]
Classic,
Occlusion,
}
static MARKUP: std::sync::atomic::AtomicU8 = std::sync::atomic::AtomicU8::new(0);
/// Set the process-wide default markup mode (CLI / tests).
pub fn set_markup_default(m: Markup) {
MARKUP.store(
match m {
Markup::Classic => 0,
Markup::Occlusion => 1,
},
std::sync::atomic::Ordering::Relaxed,
);
}
pub fn markup_default() -> Markup {
match MARKUP.load(std::sync::atomic::Ordering::Relaxed) {
1 => Markup::Occlusion,
_ => Markup::Classic,
}
}
/// Italic / bold value syntax: bare words are variables; text needs `"…"` / `'…'`.
pub fn parse_expr_prefer_var(input: &str) -> Result<Expr> {
parse_expr_mode(input, true)
@@ -17,6 +49,17 @@ fn parse_expr_mode(input: &str, prefer_var: bool) -> Result<Expr> {
parse_expr_opts(input, prefer_var, true)
}
/// Parse a full expression under an explicit markup mode (tests / migration).
pub fn parse_expr_markup(input: &str, prefer_var: bool, markup: Markup) -> Result<Expr> {
let mut p = Parser::new(input.trim(), prefer_var, true).with_markup(markup);
let e = p.parse_or()?;
p.skip_ws();
if !p.rest().is_empty() {
bail!("trailing input in expression: {:?}", p.rest());
}
Ok(e)
}
/// Parse a full expression; `allow_paren_call` controls `name(args)` postfix calls.
fn parse_expr_opts(input: &str, prefer_var: bool, allow_paren_call: bool) -> Result<Expr> {
let mut p = Parser::new(input.trim(), prefer_var, allow_paren_call);
@@ -232,6 +275,8 @@ struct Parser<'a> {
i: usize,
/// When true (italic/bold), bare words are variables, not text literals.
prefer_var: bool,
/// `<TAB>` M2: how to read `[…] (...)`.
markup: Markup,
/// `<TAB>` M1: allow `name(args)` postfix calls inside this expression.
/// Classic (space-separated) call *values* stay text-like, so they turn
/// this off to keep `source=print(2+2)` as text.
@@ -244,10 +289,16 @@ impl<'a> Parser<'a> {
src,
i: 0,
prefer_var,
markup: markup_default(),
allow_paren_call,
}
}
fn with_markup(mut self, markup: Markup) -> Self {
self.markup = markup;
self
}
fn rest(&self) -> &str {
&self.src[self.i..]
}
@@ -466,6 +517,9 @@ impl<'a> Parser<'a> {
// Link-shaped index `[key](collection)` vs bracket-marked call `[callee] …`
// vs JSON-ish `[…]` (arg text fallback when expr parse fails).
if self.starts_with("[") && !self.starts_with("[^") {
if self.markup == Markup::Occlusion {
return self.parse_occluded();
}
if link_index_shape_ahead(self.rest()) {
return self.parse_link_index();
}
@@ -622,6 +676,63 @@ impl<'a> Parser<'a> {
bail!("unexpected expression input: {:?}", self.rest());
}
/// `[描述](实现)` — occlusion. `<TAB>` M2
///
/// - label: raw prose up to `]` (`\]` escapes a literal bracket)
/// - payload: expression, or empty → `None` (empty-payload stub)
fn parse_occluded(&mut self) -> Result<Expr> {
if !self.eat("[") {
bail!("expected '[' for occlusion");
}
let mut label = String::new();
loop {
let Some(c) = self.peek_char() else {
bail!("unterminated occlusion label `[…]`");
};
match c {
']' => {
self.bump_char();
break;
}
'\\' => {
self.bump_char();
match self.peek_char() {
Some(n) => {
label.push(n);
self.bump_char();
}
None => bail!("unterminated escape in occlusion label"),
}
}
'\n' | '\r' => bail!("unterminated occlusion label `[…]`"),
_ => {
label.push(c);
self.bump_char();
}
}
}
self.skip_ws();
if !self.eat("(") {
bail!("occlusion `[描述]` must be followed by `(实现)`");
}
self.skip_ws();
if self.eat(")") {
return Ok(Expr::Occluded {
label: label.trim().to_string(),
payload: None,
});
}
let inner = self.parse_or()?;
self.skip_ws();
if !self.eat(")") {
bail!("expected ')' to close occlusion payload");
}
Ok(Expr::Occluded {
label: label.trim().to_string(),
payload: Some(Box::new(inner)),
})
}
/// `` `xs`[^1] `` / `m[^key]` / chained `m[^k][^1]` (base already parsed).
fn parse_index_chain(&mut self, mut expr: Expr) -> Result<Expr> {
loop {
@@ -1951,6 +2062,73 @@ mod bracket_call_tests {
assert_eq!(c.callee, "加一 号");
}
// ---- M2: 遮蔽语法 `[描述](实现)` ----
fn occl(e: Expr) -> (String, Option<Expr>) {
match e {
Expr::Occluded { label, payload } => (label, payload.map(|b| *b)),
other => panic!("expected Occluded, got {other:?}"),
}
}
#[test]
fn occlusion_basic_value_passthrough() {
let e = parse_expr_markup("[加一之后的值](加(1))", false, Markup::Occlusion).unwrap();
let (label, payload) = occl(e);
assert_eq!(label, "加一之后的值");
assert!(matches!(payload, Some(Expr::Call(_))));
}
#[test]
fn occlusion_empty_payload_is_none() {
let e = parse_expr_markup("[某某功能开发中]()", false, Markup::Occlusion).unwrap();
let (label, payload) = occl(e);
assert_eq!(label, "某某功能开发中");
assert!(payload.is_none());
}
#[test]
fn occlusion_label_allows_spaces_and_punctuation() {
let e = parse_expr_markup(
"[按 `税率` 与档位计算,注意四舍五入](1 + 2)",
true,
Markup::Occlusion,
)
.unwrap();
let (label, payload) = occl(e);
assert!(label.contains("税率"));
assert!(payload.is_some());
}
#[test]
fn occlusion_label_escaped_bracket() {
let e = parse_expr_markup("[数组 a\\]b 的长度](1)", false, Markup::Occlusion).unwrap();
let (label, _) = occl(e);
assert_eq!(label, "数组 a]b 的长度");
}
#[test]
fn occlusion_nested() {
let e = parse_expr_markup("[外层]([内层](1))", false, Markup::Occlusion).unwrap();
let (label, payload) = occl(e);
assert_eq!(label, "外层");
let (inner_label, inner_payload) = occl(payload.unwrap());
assert_eq!(inner_label, "内层");
assert!(matches!(inner_payload, Some(Expr::Literal(Literal::Int(1)))));
}
#[test]
fn occlusion_classic_mode_keeps_index() {
let e = parse_expr_markup("[键](表)", false, Markup::Classic).unwrap();
assert!(matches!(e, Expr::Index { .. }), "classic must stay an index");
}
#[test]
fn occlusion_requires_paren() {
let err = parse_expr_markup("[只有描述]", false, Markup::Occlusion).unwrap_err();
assert!(err.to_string().contains("followed by"), "{err}");
}
#[test]
fn modifier_conflict_expands() {
let (c, _) = parse_call_tail("礼貌 [问候] 礼貌=False", false).unwrap();