diff --git a/.cursor/skills/marqdo-dev/SKILL.md b/.cursor/skills/marqdo-dev/SKILL.md index 52ddd2a..49cfbbe 100644 --- a/.cursor/skills/marqdo-dev/SKILL.md +++ b/.cursor/skills/marqdo-dev/SKILL.md @@ -88,25 +88,31 @@ Better still — call a named helper: 3. `##` handlers: short prose OK; data as tables; return via `browser.*` / `web.*` / one `table.put`. 4. Blank line between comment paragraphs and code. 5. Run `marqdo run path.mq.md` from repo root. -6. **Calls in narrative:** prefer `**结果 = 某函数 名=`x`**` (no `>` on the RHS). Use `> …` for standalone step lists. See `examples/code-as-docs/`. +6. **Calls in narrative:** prefer `**结果 = 某函数 名=`x`**` (no `>` on the RHS). Bracket form `礼貌 [问候] "x"` / `**出 = [put] …**` is fine when modifiers help. Use `> …` for standalone step lists. See `examples/code-as-docs/`. 7. **Do not use `##` inside `# main` for document sectioning** — those become nested functions. Use paragraphs / `---` breaks instead. +8. **Index:** prefer `[键](集合)` / `` [`名`](集合) `` over footnote `` m[^k] ``. Browser client programs: prefer `import browser:lib/browser.mq.md` (no native plugin). Server sites: `ext/web` + GFM page/style tables. ## Developing libraries (`lib/*`, `ext/*`) +Canonical thin-template + waves: [lib-code-as-docs.md](../../doc/design/lib-code-as-docs.md) · [roadmap/lib-ext-code-as-docs.md](../../doc/roadmap/lib-ext-code-as-docs.md). + ### Goals - **Authors** see tables and short calls; **library** may hide `table.put` / host calls. - One concern per helper; name the effect (`set_text`, `canvas`, …), do not expose bag surgery. - EN + ZH pair when shipping user-facing libs (`lib/browser.mq.md` ↔ `lib/浏览器.mq.md`, `ext/web` ↔ `ext/web/网页.mq.md`). - `ext/**` never calls `host_*` — use plugins / public lib only (`doc/design/ext-agent.md`). +- Collection get: **`[key](coll)`** (no new footnote indexes). Calls in examples may use `修饰 [fn] …` or classic `>` / bold. ### Library checklist +- [ ] Purpose sentence + prose params + one example + short body - [ ] Public examples use **tables + helpers**, not json glue +- [ ] Index with `[k](c)`; foreach `- [item](coll)` - [ ] Helpers documented with a one-line purpose above `##` -- [ ] Defaults on `+` params; omit `None` fields in merged maps +- [ ] Defaults on params; omit `None` fields in merged maps - [ ] No `json.set` chains in new code — use `table.put` / `table.merge` / GFM - [ ] `marqdo run` on a tiny demo under `examples/` or inline smoke diff --git a/.cursor/skills/marqdo/SKILL.md b/.cursor/skills/marqdo/SKILL.md index 8f822fd..ab52b30 100644 --- a/.cursor/skills/marqdo/SKILL.md +++ b/.cursor/skills/marqdo/SKILL.md @@ -34,6 +34,7 @@ Canonical design (repo): [`markdown-mapping-v0.3.md`](../../doc/design/markdown- 9. **`ext/**` never calls `host_*`.** Agent/OKF helpers are plugin names (`agent_kb_*`, …) after `plugin.load`. Do **not** add agent/OKF domain code to `src/host/` (core bloat). See `doc/design/ext-agent.md` §4. 10. **Browser (route C/D/E/F):** client logic is Marqdo on WASM; official bridge is host glue and **may** implement lists, routing, storage, WebSocket, canvas, file read, observers — authors **must not hand-write business JS**. Use `web.client_embed` / `data-mq-source-url` auto-mount. Client effects: prefer **GFM tables + `lib/browser`** ([marqdo-dev](../marqdo-dev/SKILL.md)). 11. **Code-as-documentation / no bag glue:** Prefer **GFM tables** for maps, lists, wire, commands. Prefer **`table.put` / named helpers** over `json.set` / `json.append` chains. `lib/json` is for parse/stringify/quote only — not a dict builder. Unreadable json pipelines are a style bug. +12. **Bracket-marked calls:** Function name may be marked with `[函数名]`; bare words before `[` are boolean modifiers (`礼貌 [问候] x` → `礼貌=True`). `]` immediately followed by `(` is **index** `[key](coll)`, not a call. Prefer `[k](c)` over footnote index in new code. See [bracket-call-modifiers.md](../../doc/design/bracket-call-modifiers.md). ## Markup → meaning (v0.3) @@ -46,6 +47,7 @@ Canonical design (repo): [`markdown-mapping-v0.3.md`](../../doc/design/markdown- | `- …` inside body | Loop (`while` or `` [item](coll) `` / `` [`item`](`coll`) ``) | | Line `N. *` | Else arm | | `> fn args` | Call (named `k=v` or positional) | +| `修饰 [fn] args` | Bracket-marked call; leading words → `名=True` | | `` > `obj`.method args `` | Method call (`obj` must be a map with `_type`) | | Frontmatter `import bind:path.mq.md` / `导入` | Import file (bind library name) | | Frontmatter `import bind:lib.member` / `导入` | Short name for a library member (same keyword; no separate `use`) | diff --git a/doc/design/bracket-call-modifiers.md b/doc/design/bracket-call-modifiers.md new file mode 100644 index 0000000..db1d058 --- /dev/null +++ b/doc/design/bracket-call-modifiers.md @@ -0,0 +1,54 @@ +# 方括号标记调用与前置修饰语 + +| | | +|---|---| +| 状态 | **Active** | +| 日期 | 2026-09-14 | +| 相关 | [call-arguments.md](call-arguments.md) · [collection-access-link.md](collection-access-link.md) · [markdown-mapping-v0.3.md](markdown-mapping-v0.3.md) | + +--- + +## 1. 动机 + +无标记时,修饰语+函数名与函数名+实参都是词列,**无法消歧**。消歧标记必须来自 Marqdo 语法,**不能**依赖任一自然语言词法(「的」、形容词位置等)。 + +## 2. 形状 + +```text +修饰语… [函数名] 实参… +``` + +| 例子 | 含义 | +|------|------| +| `[问候] marqdo` | 调用 `问候`,位置实参 | +| `礼貌 [问候] marqdo` | 另加 `礼貌=True` | +| `正式 礼貌 [问候] marqdo` | `正式=True` `礼貌=True` | +| `[结账摘要] 品名="拿铁" 杯数=2` | 仅具名实参 | +| `[问候] ([格式化] `名字`)` | 嵌套:内层整段用 `()` | + +旧形保留:`> 问候 …`、`**问候 …**`、`礼貌=True` 显式具名。 + +## 3. 与取元 / foreach + +| 形状 | 语义 | +|------|------| +| `[X](Y)`(`]` 后**紧邻** `(`) | 取元 | +| `[X]`(`]` 后不是 `(`) | 函数名标记 | +| `- [X](Y)` | foreach | + +## 4. 修饰语绑定 + +- `[` 前按空白切开;每段为标识(可 `` `名` ``)。 +- 降为 `Named(名, Bool(true))`,再与 `]` 后实参合并。 +- 与显式同名具名冲突 → 诊断。 +- **核心不剥语言词缀**;形参叫 `礼貌` 则写 `礼貌 [问候]`。 + +## 5. AST + +`CallExpr.pre_modifiers: Vec`;求值/字节码在绑参前展开。 + +## 6. 修订历史 + +| 日期 | 说明 | +|------|------| +| 2026-09-14 | 初稿并落地 | diff --git a/doc/design/call-arguments.md b/doc/design/call-arguments.md index 92dfbe7..c9a9a1b 100644 --- a/doc/design/call-arguments.md +++ b/doc/design/call-arguments.md @@ -2,9 +2,9 @@ | | | |---|---| -| 状态 | 已定(v0.1 增补) | +| 状态 | 已定(v0.1 增补;2026-09-14:方括号标记调用) | | 日期 | 2026-08-07 | -| 相关 | [markdown-mapping.md](markdown-mapping.md) · [keywords.md](keywords.md) · [module-namespace.md](module-namespace.md) | +| 相关 | [markdown-mapping.md](markdown-mapping.md) · [keywords.md](keywords.md) · [module-namespace.md](module-namespace.md) · [bracket-call-modifiers.md](bracket-call-modifiers.md) | --- @@ -16,20 +16,26 @@ |------|------|------| | **具名**(保留) | `> 问候 谁=Marqdo` | `名=值`;值可含空格(至下一 `名=`) | | **位置**(新增) | `> 问候 Marqdo` | 按形参声明顺序绑定 | +| **方括号标记**(增补) | `礼貌 [问候] Marqdo` | `[函数名]` 消歧;`[` 前裸词 → `名=True`;见 [bracket-call-modifiers.md](bracket-call-modifiers.md) | -二者可混用:位置实参按「尚未被具名绑定的形参」从左到右填充。具名不可绑定同一形参两次;位置实参不得出现在「已出现具名实参」之后(对齐常见「位置在前、关键字在后」习惯)。 +二者可混用:位置实参按「尚未被具名绑定的形参」从左到右填充。具名不可绑定同一形参两次;位置实参不得出现在「已出现具名实参」之后(对齐常见「位置在前、关键字在后」习惯)。前置修饰语与显式同名具名冲突则报错。 --- ## 2. 文法(调用尾部) ``` -call_tail ::= callee arg* +call_tail ::= bracket_call | classic_call +bracket_call ::= modifier* '[' callee ']' arg* +classic_call ::= callee arg* arg ::= named | positional named ::= ident '=' value -positional ::= value_token +positional ::= value_token | '(' call_tail ')' +modifier ::= ident # 展开为 ident=True;核心不剥语言词缀 ``` +- `]` 后**紧邻** `(` → **取元** `[key](collection)`,不是 callee 标记(见 [collection-access-link.md](collection-access-link.md))。 +- 嵌套调用:把内层整段放进 `()`,例如 `[问候] ([格式化] "x")`。 - `value`(具名右侧):可含空格与 `` `var` `` 插值,直到下一个 `ident=` 边界。 - `value_token`(位置):空白分隔的一个词法单元——数字、`` `名` ``、标识/文本词;**不含空格**。多词字符串请用具名,例如 `> print text=Hello World!`。 - 实参值中 `` `变量` `` 后**紧跟** `[^…]` 时按**脚注取元**解析(可链式),而非文本:`> print text=苹果单价:`水果价格`[^苹果]`、`> print text=`订单`[^2][^品名]`。 @@ -44,13 +50,14 @@ positional ::= value_token ## 3. 绑定算法 -1. 收集具名 → 映射;冲突则报错。 -2. 按函数形参表顺序:若具名已提供则用之,否则取下一个位置实参。 -3. 位置实参有余、或必填形参仍缺 → 报错(内置 `input` 的 `prompt` 可缺省)。 -4. 用户函数:额外具名键仍写入调用环境(便于扩展);位置实参不可超过形参数目。 +1. 将前置修饰语展开为 `名=True` 具名(与显式具名冲突则报错)。 +2. 收集具名 → 映射;冲突则报错。 +3. 按函数形参表顺序:若具名已提供则用之,否则取下一个位置实参。 +4. 位置实参有余、或必填形参仍缺 → 报错(内置 `input` 的 `prompt` 可缺省)。 +5. 用户函数:额外具名键仍写入调用环境(便于扩展);位置实参不可超过形参数目。 --- ## 4. 金样例 -见 `tests/structure/positional-call.mq.md`、`tests/structure/ns/`(点号路径 / `use`)与 `tests/structure/import/`(导入解析)。 +见 `tests/structure/positional-call.mq.md`、`tests/structure/bracket-call.mq.md`、`tests/structure/ns/`(点号路径 / `use`)与 `tests/structure/import/`(导入解析)。 diff --git a/doc/design/lib-code-as-docs.md b/doc/design/lib-code-as-docs.md new file mode 100644 index 0000000..0fcc952 --- /dev/null +++ b/doc/design/lib-code-as-docs.md @@ -0,0 +1,53 @@ +# 标准库 / 扩展库:代码即文档 + +| | | +|---|---| +| 状态 | **Active** | +| 日期 | 2026-09-14 | +| 相关 | [code-as-docs-gaps.md](code-as-docs-gaps.md) · [bracket-call-modifiers.md](bracket-call-modifiers.md) · [collection-access-link.md](collection-access-link.md) · [stdlib.md](stdlib.md) · [marqdo-dev skill](../../.cursor/skills/marqdo-dev/SKILL.md) · [roadmap](../roadmap/lib-ext-code-as-docs.md) | + +--- + +## 1. 目标 + +`lib/*` 与 `ext/*` 的 `.mq.md` 应**可当说明书读、可当程序跑**。薄库不写长文;厚领域库(web / quantum / …)仍用叙述承载意图,但数据与调用面与用户程序同一套标记。 + +## 2. 薄库模板(默认) + +每个导出函数 / 方法尽量按此骨架(中英分文件锁步): + +1. **目的句**(一句人话,无标记即可)。 +2. **叙述形参**:正文里出现 `` `名` `` / `` `名`=默认 ``(推断签名);过渡期可保留 `` + `名` ``。 +3. **一例**:粗体或 `>` 调用;优先可读表面。 +4. **实现**:短;取元用 `[键](集合)`,**禁止新增**脚注取元 `` `m`[^k] ``(旧解析仍可用)。 + +调用示例(三种等价,试点期任选;新叙述优先括号标记或粗体): + +```markdown +**出 = [put] 入=`表` 键="a" 值=1** + +**出 = put 入=`表` 键="a" 值=1** + +> put 入=`表` 键="a" 值=1 +``` + +带布尔开关时可用前置修饰:`严格 [parse] text=`源`` → `严格=True`(形参名与修饰语字面一致;核心不剥「的」等词缀)。 + +## 3. 硬约束 + +| 要 | 不要 | +|----|------| +| GFM 表作数据;`table.put` / 具名助手 | `json.set` 链当字典构造器 | +| `[k](c)` 取元;`- [项](集合)` foreach | 新代码写 `` m[^k] `` | +| 中英 API 对称(见 [stdlib-i18n.md](stdlib-i18n.md)) | 只改一侧 | +| 一例跑通即文档 | 另开第二套「文档站」手写说明 | + +## 4. 波次 + +见 [roadmap/lib-ext-code-as-docs.md](../roadmap/lib-ext-code-as-docs.md):先稳定调用表面,再 M1 试点 table/text/json,其后批次 lib → ext。 + +## 5. 修订历史 + +| 日期 | 说明 | +|------|------| +| 2026-09-14 | 初稿(随括号调用落地) | diff --git a/doc/design/markdown-mapping-v0.3.md b/doc/design/markdown-mapping-v0.3.md index dd20c57..cd73697 100644 --- a/doc/design/markdown-mapping-v0.3.md +++ b/doc/design/markdown-mapping-v0.3.md @@ -212,6 +212,7 @@ v0.3: | `N. *` | else 臂(此处 `*` 仍是「空条件」标记,**不是**返回值;见 §7.3) | | GFM 表格 | 集合(不变) | | 表达式 `[键](集合)` | **取元**(与 foreach 同形;见 [collection-access-link.md](collection-access-link.md)) | +| `修饰… [函数名] 实参…` | **方括号标记调用**(前置修饰 → `名=True`;见 [bracket-call-modifiers.md](bracket-call-modifiers.md)) | | `` 集合[^键] `` | **过渡**:旧脚注取元(仍可用) | | ` ```lang ` | 外联(不变) | | 单独一行 `---` / `***` | **叙述分隔**(跳过;模块顶与函数体内相同) | @@ -226,21 +227,24 @@ v0.3: ## 6. 调用 -### 6.1 两种表面形式 +### 6.1 调用表面 ```markdown > 加一函数 37 **加一函数 37** + +礼貌 [问候] marqdo ``` -二者均解析为对 `加一函数` 的调用,实参位置绑定(或具名 `n=37`)。 +前两种解析为对 `加一函数` 的调用;第三种为**方括号标记调用**(`[` `]` 标出函数名,前置裸词展开为 `名=True`)。实参位置或具名绑定;详见 [call-arguments.md](call-arguments.md) · [bracket-call-modifiers.md](bracket-call-modifiers.md)。 | 形式 | 典型用途 | |------|----------| | `> …` | 步骤列表、独立可执行行、与 v0.2/AI 习惯兼容 | | `**…**` | 嵌在句子中:「或者可以直接这么调用**加一函数 37**」 | | `**x = 加一 37**` | 粗体赋值右侧为调用时**可省略 `>`**(代码即文档首选;`> 加一 37` 仍合法) | +| `修饰… [函数] 实参…` | 叙述里需要「形容词 + 动词」时消歧;与 `[键](集合)` 取元靠 `]` 后是否紧邻 `(` 区分 | ### 6.2 粗体内调用的判别 diff --git a/doc/design/stdlib.md b/doc/design/stdlib.md index 14051d9..ba553de 100644 --- a/doc/design/stdlib.md +++ b/doc/design/stdlib.md @@ -4,8 +4,9 @@ |---|---| | 状态 | **S0–S3 + 核心 L1 + Mid M1–M6 + Mid2 M7–M10 已落地** | | 日期 | 2026-09-09 | -| 相关 | [keywords.md](keywords.md) · [objects.md](objects.md) · [call-arguments.md](call-arguments.md) · [stdlib-i18n.md](stdlib-i18n.md) · [stdlib-modules.md](stdlib-modules.md) · [**stdlib-mid.md**](stdlib-mid.md) · [**stdlib-mid2.md**](stdlib-mid2.md) · [module-namespace.md](module-namespace.md) · [ext-abi.md](ext-abi.md) | +| 相关 | [keywords.md](keywords.md) · [objects.md](objects.md) · [call-arguments.md](call-arguments.md) · [lib-code-as-docs.md](lib-code-as-docs.md) · [stdlib-i18n.md](stdlib-i18n.md) · [stdlib-modules.md](stdlib-modules.md) · [**stdlib-mid.md**](stdlib-mid.md) · [**stdlib-mid2.md**](stdlib-mid2.md) · [module-namespace.md](module-namespace.md) · [ext-abi.md](ext-abi.md) | +> **库写法(代码即文档)**:[lib-code-as-docs.md](lib-code-as-docs.md) · [roadmap/lib-ext-code-as-docs.md](../roadmap/lib-ext-code-as-docs.md)。 > **多语言库命名**:见 [stdlib-i18n.md](stdlib-i18n.md)(不设 `lang:`;中英分文件)。 > **L1 模块清单**(含 math/foreign/plugin):见 [stdlib-modules.md](stdlib-modules.md)。 > **中层标准库 Mid(M1–M6)**:已落地——[stdlib-mid.md](stdlib-mid.md) · [roadmap/stdlib-mid.md](../roadmap/stdlib-mid.md)。 diff --git a/doc/design/view-markup-surface.md b/doc/design/view-markup-surface.md new file mode 100644 index 0000000..6293121 --- /dev/null +++ b/doc/design/view-markup-surface.md @@ -0,0 +1,34 @@ +# View:Markup 表面保真 + +| | | +|---|---| +| 状态 | **Active** | +| 日期 | 2026-09-14 | +| 相关 | [view.md](view.md) · [bracket-call-modifiers.md](bracket-call-modifiers.md) · [collection-access-link.md](collection-access-link.md) · [markdown-mapping-v0.3.md](markdown-mapping-v0.3.md) | + +--- + +## 1. 目标 + +`marqdo view` 的 Structure / 表达式展示应**贴近作者写出的 Markup**,而不是内部 AST 的旧拼法。读者从 view 抄回源文件时,应仍是合法、推荐的表面。 + +## 2. 表面对照 + +| AST / 概念 | View 优先显示 | 备注 | +|------------|---------------|------| +| `Expr::Index` | `[键](基)` | 嵌套 `[k2]([k1](base))` | +| `InterpPart::Index` | 同上嵌套链接形 | 不再默认 `` `base`[^k] `` | +| `CallExpr` + `pre_modifiers` | `修饰 [callee] 实参…` | 无修饰时仍可显示 `> callee …` | +| 赋值 / 返回 | 粗体 / 斜体语义即可 | 不强制还原整句叙述 | +| foreach | `- [项](集合)` | 不变 | + +## 3. 非目标 + +- 不把 view 做成第二语法;解析真相仍在 mapping / call-arguments。 +- 不删除对脚注取元、旧 `>` 调用的兼容显示需求时,可用次要提示,但默认推荐面优先。 + +## 4. 修订历史 + +| 日期 | 说明 | +|------|------| +| 2026-09-14 | 初稿;Index 链接形 + 括号调用修饰表面 | diff --git a/doc/design/view.md b/doc/design/view.md index 7965309..234d663 100644 --- a/doc/design/view.md +++ b/doc/design/view.md @@ -4,7 +4,7 @@ |---|---| | 状态 | 已定(v0.0.2 方向) | | 日期 | 2026-08-04 | -| 相关 | [examples-and-tests.md](examples-and-tests.md) · [generated-yaml-manifest.md](generated-yaml-manifest.md) · 视觉参考 [id.cflmy.cn](https://id.cflmy.cn) | +| 相关 | [examples-and-tests.md](examples-and-tests.md) · [view-markup-surface.md](view-markup-surface.md) · [generated-yaml-manifest.md](generated-yaml-manifest.md) · 视觉参考 [id.cflmy.cn](https://id.cflmy.cn) | --- diff --git a/doc/roadmap/lib-ext-code-as-docs.md b/doc/roadmap/lib-ext-code-as-docs.md new file mode 100644 index 0000000..f60a98d --- /dev/null +++ b/doc/roadmap/lib-ext-code-as-docs.md @@ -0,0 +1,41 @@ +# Roadmap:lib / ext 代码即文档 + +| | | +|---|---| +| 状态 | **Active** | +| 日期 | 2026-09-14 | +| 相关 | [lib-code-as-docs.md](../design/lib-code-as-docs.md) · [view-markup-surface.md](../design/view-markup-surface.md) · [bracket-call-modifiers.md](../design/bracket-call-modifiers.md) · [collection-access-link.md](../design/collection-access-link.md) | + +--- + +## 0. 总序(防返工) + +1. **方括号标记调用**(设计 + AST + 金样)— **已落地** +2. lib / view 设计文档 — **已写** +3. View 表面(Index 链接形、括号调用)— **已落地** +4. 分波改造 `lib/*` → `ext/*` + +旧 `>` / 粗体调用、脚注取元解析均保留。 + +## 1. 里程碑 + +| 波 | 内容 | 状态 | +|----|------|------| +| **Call** | `pre_modifiers`;`tests/structure/bracket-call.mq.md`;mapping / call-arguments | **done** | +| **M0 View** | `InterpPart::Index` → `[k](base)`;`call_display` 修饰表面 | **done** | +| **M1** | 试点 `lib/table` · `lib/text` · `lib/json`(中英)+ public/stdlib 摘录 | pending | +| **M2** | 其余 `lib/*` 叙述化;禁新脚注取元 | pending | +| **M3–M4** | `ext/web`、`ext/ai`:脚注→链接取元;叙述;示例可逐步换括号调用 | pending | +| **M5** | quantum / linalg + full gold | pending | + +## 2. 验收(出门) + +- 括号调用与 `[k](c)` 取元金样并存、不回归。 +- 试点库可读:目的句 + 叙述形参 + 一例 + 短实现。 +- `cargo test --test gold` 绿。 + +## 3. 修订历史 + +| 日期 | 说明 | +|------|------| +| 2026-09-14 | 初稿;Call + M0 标 done | diff --git a/src/ast.rs b/src/ast.rs index c49875b..e91ba00 100644 --- a/src/ast.rs +++ b/src/ast.rs @@ -118,6 +118,41 @@ pub struct CallExpr { /// When set, `` `recv`.callee `` method call; receiver is a variable name. pub receiver: Option, pub args: Vec, + /// Pre-bracket modifiers: `礼貌 [问候] x` → `["礼貌"]`, expanded to `礼貌=True` at eval. + /// See [bracket-call-modifiers.md](../../doc/design/bracket-call-modifiers.md). + pub pre_modifiers: Vec, +} + +impl CallExpr { + /// Fold `pre_modifiers` into leading `name=True` named args (conflicts → Err). + pub fn with_modifiers_expanded(&self) -> Result { + let mut call = self.clone(); + for m in &call.pre_modifiers { + if call + .args + .iter() + .any(|a| matches!(a, Arg::Named { name, .. } if name == m)) + { + return Err(format!( + "pre-bracket modifier `{m}` conflicts with named argument `{m}`" + )); + } + } + if call.pre_modifiers.is_empty() { + return Ok(call); + } + let mut args = Vec::with_capacity(call.pre_modifiers.len() + call.args.len()); + for m in &call.pre_modifiers { + args.push(Arg::Named { + name: m.clone(), + value: Expr::Literal(Literal::Bool(true)), + }); + } + args.append(&mut call.args); + call.args = args; + call.pre_modifiers.clear(); + Ok(call) + } } #[derive(Debug, Clone)] diff --git a/src/bytecode/compile.rs b/src/bytecode/compile.rs index b823da3..fc07297 100644 --- a/src/bytecode/compile.rs +++ b/src/bytecode/compile.rs @@ -434,7 +434,9 @@ impl<'a> FnCompiler<'a> { } fn compile_call(&mut self, call: &CallExpr, as_stmt: bool) -> Result<()> { - let mut call = call.clone(); + let mut call = call + .with_modifiers_expanded() + .map_err(|m| self.err(m))?; if let Some(path) = &call.path { // Bare dotted callee `a.b`: if `a` is a local variable, it is a method // receiver (Python-style unified namespace); otherwise it's a library path. diff --git a/src/interp.rs b/src/interp.rs index 17b32b4..6568aee 100644 --- a/src/interp.rs +++ b/src/interp.rs @@ -601,7 +601,18 @@ impl Interpreter { call.callee = callee; } + for m in &call.pre_modifiers { + if call.args.iter().any(|a| matches!(a, Arg::Named { name, .. } if name == m)) { + return Err(self.err(format!( + "pre-bracket modifier `{m}` conflicts with named argument `{m}`" + ))); + } + } + let mut ev_args = Vec::new(); + for m in &call.pre_modifiers { + ev_args.push(EvArg::Named(m.clone(), Value::Bool(true))); + } for arg in &call.args { match arg { Arg::Positional(e) => { diff --git a/src/parse/expr.rs b/src/parse/expr.rs index 9c0a50d..fa95323 100644 --- a/src/parse/expr.rs +++ b/src/parse/expr.rs @@ -461,10 +461,20 @@ impl<'a> Parser<'a> { } return Ok(e); } - // Link-shaped index: `[key](collection)` / `` [`var`](collection) `` - // (same Markdown shape as foreach `- [item](coll)`; see collection-access-link.md). + // 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("[^") { - return self.parse_link_index(); + if link_index_shape_ahead(self.rest()) { + return self.parse_link_index(); + } + if bracket_callee_shape_ahead(self.rest()) { + let rest = self.rest(); + let prefer_var = self.prefer_var; + let (call, consumed) = parse_call_tail(rest, prefer_var)?; + self.i += consumed; + return Ok(Expr::Call(call)); + } + bail!("unexpected '[' in expression (not a link index or bracket call)"); } if self.eat("\"") { return self.parse_quoted_string('"'); @@ -486,6 +496,11 @@ impl<'a> Parser<'a> { } return self.parse_index_chain(Expr::Var(name)); } + // `礼貌 [问候] x` — after quotes/ticks so `[DONE]` inside strings is safe. + if let Some((call, consumed)) = try_bracket_marked_call(self.rest(), self.prefer_var)? { + self.i += consumed; + return Ok(Expr::Call(call)); + } if self.eat(">") { // Inline call: `> name k=v` self.skip_ws(); @@ -887,15 +902,19 @@ fn is_word_end(s: &str, len: usize) -> bool { } } -/// Parse `name key=val …` / positional args; returns call + bytes consumed. +/// Parse `name key=val …` / positional args; returns call + bytes consumed from `s` +/// (after leading trim). Does **not** consume a trailing unmatched `)` so +/// `([callee] arg)` expression nesting works. /// Callee may be a bare name, library path `time.parse`, or method `` `recv`.method ``. +/// Bracket-marked form: `mod… [callee] args…` (see bracket-call-modifiers.md). /// When `prefer_var`, bare call-arg words parse as variables and bare dotted /// callees are allowed to be method receivers. pub fn parse_call_tail(s: &str, prefer_var: bool) -> Result<(CallExpr, usize)> { - use crate::ast::Arg; - let s = s.trim_start(); - let original_len = s.len(); + + if let Some((call, consumed)) = try_bracket_marked_call(s, prefer_var)? { + return Ok((call, consumed)); + } let callee_tok = { let mut parts = s.split_whitespace(); @@ -918,12 +937,156 @@ pub fn parse_call_tail(s: &str, prefer_var: bool) -> Result<(CallExpr, usize)> { let idx = s.find(&callee_tok).unwrap(); idx + callee_tok.len() }; - let mut args_str = s[after_callee_offset..].trim_start(); + 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)?; + + Ok(( + CallExpr { + callee, + path, + receiver, + args, + pre_modifiers: Vec::new(), + }, + after_callee_offset + ws + args_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(); + let mut i = 0usize; + while i < bytes.len() { + if bytes[i] == b'[' { + if i + 1 < bytes.len() && bytes[i + 1] == b'^' { + i += 1; + continue; + } + // Only treat as callee marker at start or after whitespace. + if i > 0 && !s[..i].chars().last().map(|c| c.is_whitespace()).unwrap_or(false) { + i += 1; + continue; + } + let close = match s[i + 1..].find(']') { + Some(rel) => i + 1 + rel, + None => { + i += 1; + continue; + } + }; + let after = &s[close + 1..]; + if after.starts_with('(') { + // `[key](coll)` link index — not a callee marker. + i = close + 1; + continue; + } + let pre = s[..i].trim(); + // Classic calls may embed `[…]` inside named/paren args + // (`print text=(礼貌 [问候] x)`). Only treat as bracket-marked + // when the prefix is pure modifiers (no `=` / `(` / quotes / `:`). + if pre.contains('=') + || pre.contains('(') + || pre.contains('"') + || pre.contains('\'') + || pre.contains(':') + { + return Ok(None); + } + let inner = s[i + 1..close].trim(); + if inner.is_empty() { + bail!("empty bracket callee `[]`"); + } + if !is_bracket_callee_inner(inner) { + i = close + 1; + continue; + } + let pre_modifiers = match split_modifiers(pre) { + Ok(ms) if ms.iter().all(|m| is_modifier_token(m)) => ms, + _ => return Ok(None), + }; + let callee_tok = if inner.starts_with('`') && inner.ends_with('`') && inner.len() >= 2 { + inner.to_string() + } else { + inner.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 { + let name = if callee_tok.starts_with('`') + && callee_tok.ends_with('`') + && callee_tok.len() >= 2 + { + callee_tok[1..callee_tok.len() - 1].to_string() + } else { + callee_tok + }; + (None, name, None) + }; + let after_full = &s[close + 1..]; + let args_src = after_full.trim_start(); + let ws = after_full.len() - args_src.len(); + let (args, args_consumed) = parse_call_args(args_src, prefer_var)?; + let consumed = close + 1 + ws + args_consumed; + return Ok(Some(( + CallExpr { + callee, + path, + receiver, + args, + pre_modifiers, + }, + consumed, + ))); + } + i += 1; + } + Ok(None) +} + +fn split_modifiers(pre: &str) -> Result> { + let mut out = Vec::new(); + let mut rest = pre.trim(); + while !rest.is_empty() { + let (tok, next) = split_first_token(rest); + if tok.is_empty() { + break; + } + let name = if tok.starts_with('`') && tok.ends_with('`') && tok.len() >= 2 { + tok[1..tok.len() - 1].to_string() + } else { + if tok.contains('=') { + bail!("pre-bracket modifier cannot be a named arg (`{tok}`); put named args after `]`"); + } + tok.to_string() + }; + if name.is_empty() { + bail!("empty pre-bracket modifier"); + } + out.push(name); + rest = next.trim_start(); + } + Ok(out) +} + +/// 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)> { + use crate::ast::Arg; let mut args = Vec::new(); let mut seen_named = false; + let mut rest = args_str; - while !args_str.is_empty() { - if let Some((key, after_eq)) = try_named_arg(args_str) { + while !rest.is_empty() { + if 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_raw = after_eq[..val_end].trim_end(); @@ -936,12 +1099,12 @@ pub fn parse_call_tail(s: &str, prefer_var: bool) -> Result<(CallExpr, usize)> { name: key, value, }); - args_str = after_eq[val_end..].trim_start(); + rest = after_eq[val_end..].trim_start(); } else { if seen_named { bail!("positional argument after named argument is not allowed"); } - let (tok, rest) = split_first_token(args_str); + let (tok, next) = split_first_token(rest); if tok.is_empty() { break; } @@ -951,19 +1114,11 @@ pub fn parse_call_tail(s: &str, prefer_var: bool) -> Result<(CallExpr, usize)> { parse_call_arg_value(tok)? }; args.push(Arg::Positional(value)); - args_str = rest.trim_start(); + rest = next.trim_start(); } } - - Ok(( - CallExpr { - callee, - path, - receiver, - args, - }, - original_len, - )) + let consumed = args_str.len() - rest.len(); + Ok((args, consumed)) } /// `` `recv`.method `` → (recv, method). @@ -1023,6 +1178,22 @@ fn try_named_arg(s: &str) -> Option<(String, &str)> { fn split_first_token(s: &str) -> (&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..]); + } + } + _ => {} + } + } + } if s.starts_with('"') { if let Some(end) = end_of_quoted_string(s) { return (&s[..end], &s[end..]); @@ -1041,6 +1212,71 @@ fn split_first_token(s: &str) -> (&str, &str) { } } +/// `[key](…)` with no whitespace between `]` and `(`. +fn link_index_shape_ahead(s: &str) -> bool { + let s = s.trim_start(); + if !s.starts_with('[') || s.starts_with("[^") { + return false; + } + let Some(close_rel) = s[1..].find(']') else { + return false; + }; + let after = &s[1 + close_rel + 1..]; + after.starts_with('(') +} + +/// `[callee] …` (not link-index): inner must look like a function/method name, not JSON. +fn bracket_callee_shape_ahead(s: &str) -> bool { + let s = s.trim_start(); + if !s.starts_with('[') || s.starts_with("[^") { + return false; + } + let Some(close_rel) = s[1..].find(']') else { + return false; + }; + let after = &s[1 + close_rel + 1..]; + if after.starts_with('(') { + return false; + } + is_bracket_callee_inner(&s[1..1 + close_rel]) +} + +fn is_bracket_callee_inner(inner: &str) -> bool { + let t = inner.trim(); + if t.is_empty() || t.chars().any(|c| c.is_whitespace()) { + return false; + } + // JSON arrays / objects / strings are never callees. + if t.contains(',') + || t.contains(':') + || t.contains('{') + || t.contains('}') + || t.contains('[') + || t.contains(']') + || t.starts_with('"') + || t.starts_with('\'') + { + return false; + } + if t.starts_with('`') { + return split_method_callee(t).is_some() + || (t.ends_with('`') && t.len() >= 2 && !t[1..t.len() - 1].contains('`')); + } + if t.chars().next().is_some_and(|c| c.is_ascii_digit()) { + return false; + } + // Bare name or `lib.path` callee. + t.chars() + .all(|c| c.is_alphanumeric() || c == '_' || c == '.' || !c.is_ascii()) +} + +fn is_modifier_token(name: &str) -> bool { + !name.is_empty() + && name + .chars() + .all(|c| c.is_alphanumeric() || c == '_' || !c.is_ascii()) +} + fn find_next_arg_boundary(after_eq: &str) -> usize { // Look for ` =` pattern not inside backticks, quoted strings, or // JSON-ish `[…]` / `{…}` (GAP-07: `text=["a"] other=…`). @@ -1440,3 +1676,63 @@ mod tests { } + +#[cfg(test)] +mod bracket_call_tests { + use super::*; + use crate::ast::{Arg, Expr}; + + #[test] + fn bracket_with_modifier() { + let (c, _) = parse_call_tail(r#"礼貌 [问候] "Marqdo""#, true).unwrap(); + assert_eq!(c.callee, "问候"); + assert_eq!(c.pre_modifiers, vec!["礼貌".to_string()]); + assert_eq!(c.args.len(), 1); + } + + #[test] + fn nested_paren_arg() { + let (c, _) = parse_call_tail(r#"[问候] ([格式化] "x")"#, true).unwrap(); + assert_eq!(c.callee, "问候"); + match &c.args[0] { + Arg::Positional(Expr::Call(inner)) => { + assert_eq!(inner.callee, "格式化"); + } + other => panic!("expected nested call, got {:?}", other), + } + } + + #[test] + fn paren_expr_bracket_call() { + let e = parse_expr_prefer_var(r#"([文本] "hi")"#).unwrap(); + match e { + Expr::Call(c) => assert_eq!(c.callee, "文本"), + other => panic!("{:?}", other), + } + } + + #[test] + fn modifier_in_paren_expr() { + let e = parse_expr_prefer_var(r#"(礼貌 [问候] "Ada")"#).unwrap(); + match e { + Expr::Call(c) => { + assert_eq!(c.callee, "问候"); + assert_eq!(c.pre_modifiers, vec!["礼貌".to_string()]); + } + other => panic!("{:?}", other), + } + } + + #[test] + fn link_index_not_bracket_call() { + let e = parse_expr_prefer_var("[拿铁](菜单)").unwrap(); + assert!(matches!(e, Expr::Index { .. })); + } + + #[test] + fn modifier_conflict_expands() { + let (c, _) = parse_call_tail("礼貌 [问候] 礼貌=False", false).unwrap(); + let err = c.with_modifiers_expanded().unwrap_err(); + assert!(err.contains("conflicts")); + } +} diff --git a/src/view/render.rs b/src/view/render.rs index 23c05eb..4a73a13 100644 --- a/src/view/render.rs +++ b/src/view/render.rs @@ -1248,17 +1248,38 @@ fn stmt_shell(line: u32, inner: &str, mode: StructureMode) -> String { } fn call_display(call: &CallExpr) -> String { - let mut s = String::from("> "); - if let Some(recv) = &call.receiver { - s.push('`'); - s.push_str(recv); - s.push('`'); - s.push('.'); - s.push_str(&call.callee); - } else if let Some(path) = &call.path { - s.push_str(&path.join(".")); + let mut s = String::new(); + if !call.pre_modifiers.is_empty() { + for m in &call.pre_modifiers { + s.push_str(m); + s.push(' '); + } + s.push('['); + if let Some(recv) = &call.receiver { + s.push('`'); + s.push_str(recv); + s.push('`'); + s.push('.'); + s.push_str(&call.callee); + } else if let Some(path) = &call.path { + s.push_str(&path.join(".")); + } else { + s.push_str(&call.callee); + } + s.push(']'); } else { - s.push_str(&call.callee); + s.push_str("> "); + if let Some(recv) = &call.receiver { + s.push('`'); + s.push_str(recv); + s.push('`'); + s.push('.'); + s.push_str(&call.callee); + } else if let Some(path) = &call.path { + s.push_str(&path.join(".")); + } else { + s.push_str(&call.callee); + } } for a in &call.args { match a { @@ -1297,14 +1318,12 @@ fn expr_prec(expr: &Expr, parent_prec: u8) -> String { s.push('`'); } InterpPart::Index { base, labels } => { - s.push('`'); - s.push_str(base); - s.push('`'); + // Preferred surface: nested `[key](base)` (legacy footnote still parses). + let mut inner = format!("`{base}`"); for label in labels { - s.push_str("[^"); - s.push_str(label); - s.push(']'); + inner = format!("[{label}]({inner})"); } + s.push_str(&inner); } } } diff --git a/tests/gold.rs b/tests/gold.rs index 7b13231..aa842c6 100644 --- a/tests/gold.rs +++ b/tests/gold.rs @@ -284,6 +284,29 @@ fn structure_link_index() { assert_out("tests/structure/link-index.mq.md", "28\n18\n桃"); } +#[test] +fn structure_bracket_call() { + assert_out( + "tests/structure/bracket-call.mq.md", + "True, Marqdo! +False, Ada! +False, Hi Bo!! +28", + ); +} + +#[test] +fn bytecode_bracket_call() { + assert_out_backend( + "tests/structure/bracket-call.mq.md", + "bytecode", + "True, Marqdo! +False, Ada! +False, Hi Bo!! +28", + ); +} + #[test] fn structure_footnote_map_digits() { assert_out( diff --git a/tests/structure/bracket-call.mq.md b/tests/structure/bracket-call.mq.md new file mode 100644 index 0000000..469ea54 --- /dev/null +++ b/tests/structure/bracket-call.mq.md @@ -0,0 +1,32 @@ +--- +title: 方括号标记调用与前置修饰语 +description: 礼貌 [问候] …;嵌套 ([…]);与 [键](集合) 取元消歧 +--- + +# main + +**打印 内容=(礼貌 [问候] "Marqdo")** +**打印 内容=([问候] "Ada")** +**打印 内容=([问候] ([格式化] "Bo"))** + +`菜单` = + +| 美式 | 拿铁 | +|------|------| +| 18 | 28 | + +**价 = [拿铁](菜单)** +**打印 内容=`价`** + +## 问候 + + `谁` + + `礼貌`=False + +**出 = `礼貌` + ", " + `谁` + "!"** +*出* + +## 格式化 + + `名` + +**出 = "Hi " + `名` + "!"** +*出*