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:
1 parent
13012cac0e
commit
11417c42e0
11 files changed
+424
-1
No files matched your search
@@ -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();
|
||||
|
||||
+6
-1
@@ -1,6 +1,6 @@
|
||||
//! Line-oriented recursive descent → AST (no Bison).
|
||||
|
||||
mod expr;
|
||||
pub mod expr;
|
||||
mod prose;
|
||||
|
||||
pub use expr::{
|
||||
@@ -2091,6 +2091,11 @@ fn collect_reads_call(call: &crate::ast::CallExpr, reads: &mut std::collections:
|
||||
|
||||
fn collect_reads_expr(expr: &Expr, reads: &mut std::collections::HashSet<String>) {
|
||||
match expr {
|
||||
Expr::Occluded { payload, .. } => {
|
||||
if let Some(inner) = payload {
|
||||
collect_reads_expr(inner, reads);
|
||||
}
|
||||
}
|
||||
Expr::Var(n) => {
|
||||
reads.insert(n.clone());
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user