From 05b8edc186d38698e25c36a41e27cae482cfc127 Mon Sep 17 00:00:00 2001 From: cflmy Date: Thu, 22 Oct 2026 15:08:02 +0800 Subject: [PATCH] =?UTF-8?q?feat(parse):=20M1=20()=E5=86=85=E8=B0=83?= =?UTF-8?q?=E7=94=A8=E8=AF=AD=E6=B3=95=20=E2=80=94=20)=20=E7=BB=88?= =?UTF-8?q?=E6=AD=A2=20/=20=E9=80=97=E5=8F=B7=20/=20=E5=B5=8C=E5=A5=97=20/?= =?UTF-8?q?=20=E5=B8=A6=E7=A9=BA=E6=A0=BC=20callee?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 实现 M1(occlusion-syntax.md §13):把 `(…)` 变成一等调用外形。 四件事: 1. `)` 是参数终止符(历史缺陷:末个位置实参吞掉 `)`,导致 `加(31)` 报 unknown function `加(31`) 2. 可选逗号分隔:`加(1, 2)` / `加(1 2)` 等价 3. 嵌套调用:`加(加(1 2), 10)` → 13 4. **callee 可含空格**:`加一 号(31)` → 32 —— 这是缺陷 D8 的结构性解法 (`(` 是明确分隔符,空格不再参与切词) 实现要点: - split_first_token / find_next_arg_boundary 重写为深度感知扫描器: 跟踪 ()[]{} 嵌套 + 字符串 + 反引号;顶层 )/空白(括号形还含逗号)终止 token 且不吞终止符;字符串内逗号不受影响。 - 新增 try_paren_call:callee = 第一个 '(' 之前的全部文本。 护栏:callee 含 = [ ] ( ) " ' 即拒绝(避免把 `text=a(b)` 具名实参与 `trim [stdout](…)` 方括号实参误判为调用);反引号允许(保留 `obj`.方法 写法)。 - 表达式级 postfix 调用(parse_primary 裸词分支,要求 `(` 紧跟)。 - is_bracket_callee_inner 允许空格:[加一 号] 31 亦可用。 关键决策(回归测试逼出来的):括号形与空格形的**参数值语义不同**—— 括号形是表达式(允许嵌套调用),空格形仍是文本(`source=print(2+2)` 必须保持文本, 否则 foreign.run_lang 报 source must be text)。用 Parser.allow_paren_call + parse_call_arg_value_mode(input, prefer_var, allow_call) 区分。 测试:新增 11 个单测(TDD:先 10 红后全绿);全量 cargo test --release 565 passed / 0 failed(基线 554 + 11);tree 与 bytecode 双后端输出一致; 端到端 marqdo run 六用例符合预期。 顺带:删除变成死代码的 end_of_quoted_string(编译警告清零)。 文档:doc/design/change-m1-paren-call.md(含决策依据、护栏表、边界)。 --- doc/design/change-m1-paren-call.md | 134 +++++++++ src/parse/expr.rs | 440 ++++++++++++++++++++++------- 2 files changed, 469 insertions(+), 105 deletions(-) create mode 100644 doc/design/change-m1-paren-call.md diff --git a/doc/design/change-m1-paren-call.md b/doc/design/change-m1-paren-call.md new file mode 100644 index 0000000..a1f060e --- /dev/null +++ b/doc/design/change-m1-paren-call.md @@ -0,0 +1,134 @@ +# 变更记录:M1 `()` 内调用语法(`)` 终止 / 逗号 / 嵌套 / 空格 callee) + +| | | +|---|---| +| 状态 | **Implemented** | +| 日期 | 2026-10-22 | +| 里程碑 | M1([occlusion-syntax.md](occlusion-syntax.md) §13) | +| 改动文件 | `src/parse/expr.rs` | +| 影响面 | **共享参数分词器**(所有调用都会经过) | + +--- + +## 1. 修了什么 + +四件事,一句概括:**`(…)` 现在是一等调用外形**。 + +| # | 前 | 后 | +|---|----|----| +| 1 | `加(31)` 报 `unknown function 加(31` | ✅ 调用,返回 32 | +| 2 | 末个位置实参会吞掉 `)` | `)` 是**参数终止符** | +| 3 | 只支持空白分隔 | 支持 `,` / `,` 可选分隔 | +| 4 | 嵌套 `加(加(1 2), 3)` 不可用 | ✅ 递归解析 | +| 5 | `加一 号(31)` 不可用(D8) | ✅ **callee 可含空格** | + +实测(1.5.2 本地构建,tree 与 bytecode 双后端结果一致): + +``` +空格参=3 加(1 2) +逗号=3 加(1, 2) +嵌套=13 加(加(1 2), 10) +带空格callee=32 加一 号(31) ← 缺陷 D8 的结构性解法 +库函数=x txt.str_trim(" x ") +具名=3 加(a=1, b=2) +``` + +--- + +## 2. 实现要点 + +### 2.1 参数扫描:深度感知 + `)` 终止 + +`split_first_token` 与 `find_next_arg_boundary` 改为**通用扫描器**: + +- 跟踪 `()` `[]` `{}` 嵌套、`"…"` 字符串、`` `…` `` 反引号 +- **顶层** `)` / 空白(以及括号形里的 `,`)终止当前 token,且**不吞掉终止符** +- 字符串内的逗号不受影响(`拼接("a,b", "c")` 仍是 2 个参数) + +### 2.2 `try_paren_call`:callee = 第一个 `(` 之前的全部文本 + +```rust +let Some(open) = s.find('(') else { return Ok(None) }; +let callee_tok = s[..open].trim(); // 允许空格 +``` + +**安全护栏**(否则会误判): + +| callee 里出现 | 判定 | +|--------------|------| +| `=` | 不是括号调用(那是 `text=a(b)` 具名实参) | +| `[` `]` `(` `)` `"` `'` | 不是括号调用(那是 `trim [stdout](…)` 方括号实参) | +| 以 `[` `]` `"` `'` 开头 | 不是括号调用 | +| 反引号 | **允许**(保留 `` `obj`.方法(…) `` 接收者写法) | + +### 2.3 表达式级 postfix 调用 + +`parse_primary` 的裸词分支:**紧跟** `(` 时按调用解析。 + +```rust +if self.allow_paren_call && self.rest().starts_with('(') { … } +``` + +要求"紧跟"(不隔空格),使 `加 (1)` 仍是原来的"文本 + 括号"行为。 + +### 2.4 方括号形也允许空格 callee + +`is_bracket_callee_inner` 不再拒绝空白:`[加一 号] 31` 可用。 +(仓库内可执行的方括号调用用量为 0,风险极低。) + +--- + +## 3. 关键设计决策:括号形 vs 空格形的参数**值**语义不同 + +这是本里程碑唯一有争议的点,必须写清。 + +| 形态 | 参数值 | 例子 | +|------|--------|------| +| **括号形** `f(…)` | 表达式(**允许** `name(args)` 调用) | `加(加(1 2), 3)` | +| **空格形** `> f k=v` | 文本(**不允许**裸 `name(args)` 变成调用) | `source=print(2+2)` 仍是文本 | + +**为什么必须区分**:`source=print(2+2)` 在 Marqdo 里历来是**文本**(未加引号的实参按文本处理)。 +若不区分,它会变成对 `print` 的调用,`foreign.run_lang` 直接报 `source must be text` +—— 这正是本次回归测试抓到的 3 个失败。 + +实现:`Parser` 增加 `allow_paren_call` 字段;`parse_call_arg_value_mode(input, prefer_var, allow_call)` +统一两种值解析(`allow_call=false` 即旧行为)。 + +--- + +## 4. 测试 + +| 层 | 内容 | 结果 | +|----|------|------| +| 单元 | 新增 11 个(单参/多参/逗号/具名/空格 callee/零参/库路径/嵌套/引号内逗号/旧写法不回归/方括号形) | ✅ | +| 全量 | `cargo test --release` | **565 passed / 0 failed**(基线 554 + 11) | +| 双后端 | tree 与 `--backend bytecode` 跑同一文档 | 输出一致 | +| 端到端 | `marqdo run` 六个用例 | 输出符合预期 | + +**TDD 过程**:先写 11 个测试 → 10 个失败(红灯确认)→ 实现 → 全绿。 + +--- + +## 5. 顺带移除的死代码 + +`end_of_quoted_string`:新扫描器取代其唯一用途后变成 `never used`,删除(编译器警告清零)。 + +--- + +## 6. 边界(本里程碑不做) + +| 项 | 说明 | +|----|------| +| 逗号仅在括号形生效 | 空格形 `text=a,b` 的逗号仍是文本(兼容) | +| `加 (1)`(空格后跟括号) | 不视为调用,保持旧行为 | +| 遮蔽语法 `[描述](…)` | M2 才引入,本里程碑不解析 | +| 位置实参顺序脆弱性 | 与叙述顺序绑定,M7/M8 再处理(诊断) | + +--- + +## 7. 变更清单 + +| 文件 | 变更 | +|------|------| +| `src/parse/expr.rs` | 参数扫描器重写(`)`/逗号/嵌套);新增 `try_paren_call` + `split_callee` 抽取;表达式级 postfix 调用;`Parser.allow_paren_call`;`parse_call_arg_value_mode` 统一两种值语义;方括号 callee 允许空格;删除 `end_of_quoted_string` | +| `doc/design/change-m1-paren-call.md` | 本文件 | diff --git a/src/parse/expr.rs b/src/parse/expr.rs index 57442e2..a31480b 100644 --- a/src/parse/expr.rs +++ b/src/parse/expr.rs @@ -14,7 +14,12 @@ pub fn parse_expr_prefer_var(input: &str) -> Result { } fn parse_expr_mode(input: &str, prefer_var: bool) -> Result { - let mut p = Parser::new(input.trim(), prefer_var); + parse_expr_opts(input, prefer_var, true) +} + +/// 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 { + let mut p = Parser::new_plain(input.trim(), prefer_var, allow_paren_call); let e = p.parse_or()?; p.skip_ws(); if !p.rest().is_empty() { @@ -50,12 +55,21 @@ pub fn parse_value_or_interp(input: &str) -> Result { /// unspaced `Text / Text` divisions as a single path string (`a/b`, `.marqdo/agent-kb`). /// Real math (`1/2`, `` `n` / 2 ``) is unchanged. pub fn parse_call_arg_value(input: &str) -> Result { + parse_call_arg_value_mode(input, false, false) +} + +/// Shared call-argument value parsing. +/// +/// `allow_call` is true only inside `callee(args)` (paren form), where arguments +/// are expression-like; classic space-separated values stay text-like so that +/// `source=print(2+2)` remains the text `print(2+2)`. `` M1 +fn parse_call_arg_value_mode(input: &str, prefer_var: bool, allow_call: bool) -> Result { let s = input.trim(); if s.is_empty() { return Ok(Expr::Literal(Literal::Text(String::new()))); } if s.starts_with('"') || s.starts_with('\'') { - return match parse_expr(s) { + return match parse_expr_opts(s, prefer_var, allow_call) { Ok(e) => Ok(e), Err(_) => Ok(parse_interp(s)), }; @@ -63,12 +77,22 @@ pub fn parse_call_arg_value(input: &str) -> Result { if has_hyphenated_prose(s) { return Ok(parse_interp(s)); } - match parse_expr(s) { - Ok(e) => Ok(collapse_text_div_path(e, s)), + match parse_expr_opts(s, prefer_var, allow_call) { + Ok(e) => Ok(if prefer_var { + e + } else { + collapse_text_div_path(e, s) + }), Err(_) => { // ext/web paths: `nav.`nav``, `articles.`articles`.title` — ticks are path - // punctuation, not interpolation. - if s.contains(".`") { + // punctuation, not interpolation. Plain `/about` is prose too. + if prefer_var { + if s.starts_with('/') || s.contains(".`") { + Ok(Expr::Literal(Literal::Text(s.to_string()))) + } else { + Ok(parse_interp(s)) + } + } else if s.contains(".`") { Ok(Expr::Literal(Literal::Text(s.to_string()))) } else { Ok(parse_interp(s)) @@ -81,30 +105,7 @@ pub fn parse_call_arg_value(input: &str) -> Result { /// value-expression segments: a bare word is a **variable** (not a text literal). /// Quoted strings, hyphenated prose, and `/path` prose stay text; `` `x` `` still works. pub fn parse_call_arg_value_prefer_var(input: &str) -> Result { - let s = input.trim(); - if s.is_empty() { - return Ok(Expr::Literal(Literal::Text(String::new()))); - } - if s.starts_with('"') || s.starts_with('\'') { - return match parse_expr(s) { - Ok(e) => Ok(e), - Err(_) => Ok(parse_interp(s)), - }; - } - if has_hyphenated_prose(s) { - return Ok(parse_interp(s)); - } - match parse_expr_prefer_var(s) { - Ok(e) => Ok(e), - Err(_) => { - // `/about`, `.marqdo/x`, `nav.`nav`` etc. → prose text, not variables. - if s.starts_with('/') || s.contains(".`") { - Ok(Expr::Literal(Literal::Text(s.to_string()))) - } else { - Ok(parse_interp(s)) - } - } - } + parse_call_arg_value_mode(input, true, false) } fn is_text_only_div_chain(e: &Expr) -> bool { @@ -235,6 +236,10 @@ struct Parser<'a> { i: usize, /// When true (italic/bold), bare words are variables, not text literals. prefer_var: bool, + /// `` 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. + allow_paren_call: bool, } impl<'a> Parser<'a> { @@ -243,6 +248,16 @@ impl<'a> Parser<'a> { src, i: 0, prefer_var, + allow_paren_call: true, + } + } + + fn new_plain(src: &'a str, prefer_var: bool, allow_paren_call: bool) -> Self { + Self { + src, + i: 0, + prefer_var, + allow_paren_call, } } @@ -600,6 +615,14 @@ impl<'a> Parser<'a> { self.bump_char(); } let word = self.src[start..self.i].to_string(); + // `name(args)` postfix call: `(` must follow immediately. `` M1 + if self.allow_paren_call && self.rest().starts_with('(') { + let from_word = &self.src[start..]; + if let Some((call, used)) = try_paren_call(from_word, self.prefer_var)? { + self.i = start + used; + return Ok(Expr::Call(call)); + } + } self.skip_ws(); if self.starts_with("[^") { return self.parse_index_chain(Expr::Var(word)); @@ -916,6 +939,10 @@ pub fn parse_call_tail(s: &str, prefer_var: bool) -> Result<(CallExpr, usize)> { return Ok((call, consumed)); } + if let Some((call, consumed)) = try_paren_call(s, prefer_var)? { + return Ok((call, consumed)); + } + let callee_tok = { let mut parts = s.split_whitespace(); parts @@ -924,14 +951,7 @@ pub fn parse_call_tail(s: &str, prefer_var: bool) -> Result<(CallExpr, usize)> { .to_string() }; - let (receiver, callee, path) = if let Some((r, m)) = split_method_callee(&callee_tok) { - (Some(r), m, None) - } else if let Some(segments) = split_lib_path_callee(&callee_tok) { - let last = segments.last().cloned().unwrap_or_default(); - (None, last, Some(segments)) - } else { - (None, callee_tok.clone(), None) - }; + let (receiver, callee, path) = split_callee(&callee_tok); let after_callee_offset = { let idx = s.find(&callee_tok).unwrap(); @@ -940,7 +960,7 @@ pub fn parse_call_tail(s: &str, prefer_var: bool) -> Result<(CallExpr, usize)> { let after = &s[after_callee_offset..]; let args_src = after.trim_start(); let ws = after.len() - args_src.len(); - let (args, args_consumed) = parse_call_args(args_src, prefer_var)?; + let (args, args_consumed) = parse_call_args(args_src, prefer_var, false)?; Ok(( CallExpr { @@ -955,6 +975,70 @@ pub fn parse_call_tail(s: &str, prefer_var: bool) -> Result<(CallExpr, usize)> { )) } + +/// Split a callee token into `(receiver, callee, lib path)`. +fn split_callee(callee_tok: &str) -> (Option, String, Option>) { + if let Some((r, m)) = split_method_callee(callee_tok) { + (Some(r), m, None) + } else if let Some(segments) = split_lib_path_callee(callee_tok) { + let last = segments.last().cloned().unwrap_or_default(); + (None, last, Some(segments)) + } else { + (None, callee_tok.to_string(), None) + } +} + +/// `callee(args)` — callee is **everything before the first `(`** (spaces allowed). +/// +/// Returns `None` when the shape is not a paren call (e.g. `print text=…`, +/// `text=(a)`), so callers can fall back to the classic token form. `` M1. +fn try_paren_call(s: &str, prefer_var: bool) -> Result> { + let Some(open) = s.find('(') else { + return Ok(None); + }; + if open == 0 { + return Ok(None); + } + let callee_tok = s[..open].trim(); + if callee_tok.is_empty() { + return Ok(None); + } + // A named argument (`text=a(b)`) is not a paren call, and neither is a + // bracket-marked argument (`trim [stdout](…)`): the callee side must not + // contain `=`, quotes or brackets. Backticks stay legal so that the + // backticked-receiver method form `` `obj`.方法(…) `` still reaches here. + if callee_tok + .chars() + .any(|c| matches!(c, '=' | '[' | ']' | '(' | ')' | '"' | '\'')) + { + return Ok(None); + } + let first = callee_tok.chars().next().unwrap_or(' '); + if matches!(first, '[' | ']' | '"' | '\'') { + return Ok(None); + } + let inside = &s[open + 1..]; + let (args, used) = parse_call_args(inside, prefer_var, true)?; + let rest = &inside[used..]; + let rest_t = rest.trim_start(); + if !rest_t.starts_with(')') { + return Ok(None); + } + let consumed = open + 1 + used + (rest.len() - rest_t.len()) + 1; + let (receiver, callee, path) = split_callee(callee_tok); + Ok(Some(( + CallExpr { + callee, + path, + receiver, + args, + pre_modifiers: Vec::new(), + bracket_marked: false, + }, + consumed, + ))) +} + /// `mod… [callee] args` — `]` must not be immediately followed by `(` (that is link-index). fn try_bracket_marked_call(s: &str, prefer_var: bool) -> Result> { let bytes = s.as_bytes(); @@ -1032,7 +1116,7 @@ fn try_bracket_marked_call(s: &str, prefer_var: bool) -> Result Result> { let mut out = Vec::new(); let mut rest = pre.trim(); while !rest.is_empty() { - let (tok, next) = split_first_token(rest); + let (tok, next) = split_first_token(rest, false); if tok.is_empty() { break; } @@ -1078,24 +1162,38 @@ fn split_modifiers(pre: &str) -> Result> { /// Parse call args; returns `(args, bytes_consumed)` from the start of `args_str`. /// Stops before an unmatched `)` so parenthesized expression nesting works. -fn parse_call_args(args_str: &str, prefer_var: bool) -> Result<(Vec, usize)> { +fn parse_call_args( + args_str: &str, + prefer_var: bool, + paren_mode: bool, +) -> Result<(Vec, usize)> { use crate::ast::Arg; let mut args = Vec::new(); let mut seen_named = false; let mut rest = args_str; while !rest.is_empty() { - if rest.starts_with(')') { + rest = rest.trim_start(); + if rest.is_empty() || rest.starts_with(')') { break; } + // `` M1: optional comma separator inside `callee(...)`. + if paren_mode { + while let Some(r) = rest.strip_prefix(',') { + rest = r.trim_start(); + } + if rest.is_empty() || rest.starts_with(')') { + break; + } + } if let Some((key, after_eq)) = try_named_arg(rest) { seen_named = true; - let val_end = find_next_arg_boundary(after_eq); + let val_end = find_next_arg_boundary(after_eq, paren_mode); let val_raw = after_eq[..val_end].trim_end(); let value = if prefer_var { - parse_call_arg_value_prefer_var(val_raw)? + parse_call_arg_value_mode(val_raw, prefer_var, paren_mode)? } else { - parse_call_arg_value(val_raw)? + parse_call_arg_value_mode(val_raw, prefer_var, paren_mode)? }; args.push(Arg::Named { name: key, @@ -1106,14 +1204,14 @@ fn parse_call_args(args_str: &str, prefer_var: bool) -> Result<(Vec Option<(String, &str)> { None } -fn split_first_token(s: &str) -> (&str, &str) { +/// Split one call-argument token off `s`. +/// +/// Stops at a **top-level** whitespace, `)`, and (when `stop_comma`) `,`. +/// Tracks `()` `[]` `{}` nesting plus quoted strings and backticks, so nested +/// calls (`f(g(1))`) and JSON-ish values stay one token. `` M1. +fn split_first_token(s: &str, paren_mode: bool) -> (&str, &str) { let s = s.trim_start(); - if s.starts_with('(') { - let mut depth = 0i32; - for (i, c) in s.char_indices() { - match c { - '(' => depth += 1, - ')' => { - depth -= 1; - if depth == 0 { - let end = i + c.len_utf8(); - return (&s[..end], &s[end..]); - } - } - _ => {} + let mut depth = 0i32; + let mut in_str = false; + let mut in_bt = false; + let mut chars = s.char_indices().peekable(); + while let Some((i, c)) = chars.next() { + if in_str { + if c == '\\' { + chars.next(); + continue; } + if c == '"' { + in_str = false; + } + continue; + } + if in_bt { + if c == '`' { + in_bt = false; + } + continue; + } + match c { + '`' => { + in_bt = true; + continue; + } + '"' => { + in_str = true; + continue; + } + '(' | '[' | '{' => { + depth += 1; + continue; + } + ')' | ']' | '}' => { + if depth == 0 { + // Top-level closer terminates the token and is NOT consumed. + return (&s[..i], &s[i..]); + } + depth -= 1; + continue; + } + ',' if paren_mode && depth == 0 => return (&s[..i], &s[i..]), + c if depth == 0 && c.is_whitespace() => return (&s[..i], &s[i..]), + _ => {} } } - if s.starts_with('"') { - if let Some(end) = end_of_quoted_string(s) { - return (&s[..end], &s[end..]); - } - } - if s.starts_with('`') { - // `` `name` `` as one token - if let Some(end) = s[1..].find('`') { - let end = end + 2; // include closing ` - return (&s[..end], &s[end..]); - } - } - match s.find(char::is_whitespace) { - Some(i) => (&s[..i], &s[i..]), - None => (s, ""), - } + (s, "") } /// `[key](…)` with no whitespace between `]` and `(`. @@ -1245,7 +1364,7 @@ fn bracket_callee_shape_ahead(s: &str) -> bool { fn is_bracket_callee_inner(inner: &str) -> bool { let t = inner.trim(); - if t.is_empty() || t.chars().any(|c| c.is_whitespace()) { + if t.is_empty() { return false; } // JSON arrays / objects / strings are never callees. @@ -1267,9 +1386,10 @@ fn is_bracket_callee_inner(inner: &str) -> bool { if t.chars().next().is_some_and(|c| c.is_ascii_digit()) { return false; } - // Bare name or `lib.path` callee. + // Bare name or `lib.path` callee. Internal spaces allowed: `[加一 号] 31` + // is the bracket-marked form of a callee whose name contains spaces (D8). t.chars() - .all(|c| c.is_alphanumeric() || c == '_' || c == '.' || !c.is_ascii()) + .all(|c| c.is_alphanumeric() || c == '_' || c == '.' || c == ' ' || !c.is_ascii()) } fn is_modifier_token(name: &str) -> bool { @@ -1279,13 +1399,14 @@ fn is_modifier_token(name: &str) -> bool { .all(|c| c.is_alphanumeric() || c == '_' || !c.is_ascii()) } -fn find_next_arg_boundary(after_eq: &str) -> usize { +fn find_next_arg_boundary(after_eq: &str, paren_mode: bool) -> usize { // Look for ` =` pattern not inside backticks, quoted strings, or // JSON-ish `[…]` / `{…}` (GAP-07: `text=["a"] other=…`). let mut in_bt = false; let mut in_str = false; let mut bracket_depth: i32 = 0; let mut brace_depth: i32 = 0; + let mut paren_depth: i32 = 0; let mut chars = after_eq.char_indices().peekable(); while let Some((i, c)) = chars.next() { if in_str { @@ -1329,9 +1450,24 @@ fn find_next_arg_boundary(after_eq: &str) -> usize { brace_depth = brace_depth.saturating_sub(1); continue; } + '(' => { + paren_depth += 1; + continue; + } + ')' => { + if paren_depth == 0 { + // `` M1: `)` ends the enclosing call's argument list. + return i; + } + paren_depth -= 1; + continue; + } + ',' if paren_mode && paren_depth == 0 && bracket_depth == 0 && brace_depth == 0 => { + return i; + } _ => {} } - if bracket_depth > 0 || brace_depth > 0 { + if bracket_depth > 0 || brace_depth > 0 || paren_depth > 0 { continue; } if c.is_whitespace() { @@ -1354,27 +1490,6 @@ fn find_next_arg_boundary(after_eq: &str) -> usize { after_eq.len() } -/// Byte index after a leading `"..."` token (opening quote included in slice). -fn end_of_quoted_string(s: &str) -> Option { - if !s.starts_with('"') { - return None; - } - let mut escaped = false; - for (i, c) in s.char_indices().skip(1) { - if escaped { - escaped = false; - continue; - } - if c == '\\' { - escaped = true; - continue; - } - if c == '"' { - return Some(i + c.len_utf8()); - } - } - None -} /// Parse `> callee args` call expression/statement text (without leading `>`). /// When `prefer_var` (inside `*…*` / `**…**`), bare call-arg words are variables @@ -1734,6 +1849,121 @@ mod bracket_call_tests { assert!(matches!(e, Expr::Index { .. })); } + // ---- M1: `()` 内调用语法(`)` 终止 / 逗号 / 嵌套 / 空格 callee)---- + + fn call_of(e: Expr) -> crate::ast::CallExpr { + match e { + Expr::Call(c) => c, + other => panic!("expected Call, got {other:?}"), + } + } + + #[test] + fn paren_call_single_positional() { + let (c, used) = parse_call_tail("加(1)", false).unwrap(); + assert_eq!(c.callee, "加"); + assert_eq!(used, "加(1)".len()); + assert_eq!(c.args.len(), 1); + } + + #[test] + fn paren_call_bare_number_stops_at_paren() { + // 历史缺陷:末个位置实参会吞掉 `)` + let (c, used) = parse_call_tail("加(31)", false).unwrap(); + assert_eq!(used, "加(31)".len(), "consumed must cover the closing paren"); + assert_eq!(c.args.len(), 1); + } + + #[test] + fn paren_call_comma_and_space_separated() { + for src in ["加(1, 2)", "加(1 2)", "加(1,2)", "加( 1 , 2 )"] { + let (c, _) = parse_call_tail(src, false).unwrap(); + assert_eq!(c.args.len(), 2, "src={src}"); + } + } + + #[test] + fn paren_call_named_args() { + let (c, _) = parse_call_tail("计税(档位=2, 金额=100)", false).unwrap(); + assert_eq!(c.callee, "计税"); + assert_eq!(c.args.len(), 2); + match &c.args[0] { + crate::ast::Arg::Named { name, .. } => assert_eq!(name, "档位"), + other => panic!("{other:?}"), + } + } + + #[test] + fn paren_call_callee_may_contain_spaces() { + let (c, used) = parse_call_tail("加一 号(31)", false).unwrap(); + assert_eq!(c.callee, "加一 号"); + assert_eq!(used, "加一 号(31)".len()); + assert_eq!(c.args.len(), 1); + } + + #[test] + fn paren_call_zero_args() { + let (c, _) = parse_call_tail("刷新()", false).unwrap(); + assert_eq!(c.callee, "刷新"); + assert!(c.args.is_empty()); + } + + #[test] + fn paren_call_lib_path_and_method() { + let c = call_of(parse_expr("txt.str_trim(s)").unwrap()); + assert_eq!(c.callee, "str_trim"); + assert_eq!(c.path.as_deref(), Some(&["txt".to_string(), "str_trim".to_string()][..])); + + // 点号 callee 在 parse 期保存为 lib path;若 `obj` 是局部变量, + // 运行期 eval_call 会把它当 method receiver(与 `> obj.方法` 一致)。 + let c = call_of(parse_expr("obj.方法(1)").unwrap()); + assert_eq!(c.callee, "方法"); + assert_eq!( + c.path.as_deref(), + Some(&["obj".to_string(), "方法".to_string()][..]) + ); + assert!(c.receiver.is_none()); + } + + #[test] + fn paren_call_nested_in_expression() { + let c = call_of(parse_expr("加(加(1 2), 3)").unwrap()); + assert_eq!(c.args.len(), 2); + match &c.args[0] { + crate::ast::Arg::Positional(Expr::Call(inner)) => { + assert_eq!(inner.callee, "加"); + assert_eq!(inner.args.len(), 2); + } + other => panic!("expected nested call, got {other:?}"), + } + } + + #[test] + fn paren_call_quoted_args_keep_commas() { + // 逗号只在括号形里当分隔符;字符串内的逗号不受影响 + let (c, _) = parse_call_tail(r#"拼接("a,b", "c")"#, false).unwrap(); + assert_eq!(c.args.len(), 2); + } + + #[test] + fn whitespace_call_unaffected_by_commas() { + // 旧式空格调用:`text=a,b` 的逗号仍是文本一部分 + let (c, _) = parse_call_tail("print text=a,b", false).unwrap(); + match &c.args[0] { + crate::ast::Arg::Named { value, .. } => match value { + Expr::Literal(Literal::Text(s)) => assert_eq!(s, "a,b"), + other => panic!("expected text a,b, got {other:?}"), + }, + other => panic!("{other:?}"), + } + } + + #[test] + fn bracketed_call_still_works() { + let (c, _) = parse_call_tail("[加一 号] 31", false).unwrap(); + assert_eq!(c.callee, "加一 号"); + } + #[test] fn modifier_conflict_expands() { let (c, _) = parse_call_tail("礼貌 [问候] 礼貌=False", false).unwrap();