Files
marqdo/src/parse/mod.rs
T
cflmy 9331af78e2 release(2.8.0): 合入 CHANGELOG/README/发版说明/skills prove 任务;CI 链接指向 doc/releases
- CHANGELOG.md:v2.8.0 条目(中英双语);
- README.md:版本行 2.7.1→2.8.0 + 愿景第 6 条(知识可证明);
- doc/releases/v2.8.0.md:双语发版说明(亮点/用法/已知限制);
- skills/marqdo-dev/index.mq.md:新增 prove 任务(路径/目录模式/
  require_lean/json;参数用 + 行声明升参,check 与 narrative-ratio 通过);
- 设计文档 §12.5 标记已合入;发版链接统一指向 doc/releases/v2.8.0.md。
2026-11-18 10:29:26 +08:00

3006 lines
103 KiB
Rust
Executable File
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Line-oriented recursive descent → AST (no Bison).
pub mod expr;
mod prose;
pub use expr::{
parse_call_after_gt, parse_call_arg_value, parse_expr, parse_expr_prefer_var,
parse_value_or_interp,
};
pub use prose::{
classify_narrative_target, scan_md_links_in_line, scan_narrative_links, scan_prose_line,
NarrativeLink, NarrativeLinkKind, ProseBit,
};
use anyhow::{bail, Result};
use std::collections::HashSet;
use crate::ast::{
BranchArm, Expr, Function, Import, IndexKey, Literal, Module, Param, Stmt, Use,
};
use crate::diagnostics::{bail_at, Diagnostic, Span};
use crate::lex::{ClassifiedLine, LineKind, classify_source, has_unterminated_string};
use crate::parse::expr::parse_call_after_gt as call_after_gt;
use crate::parse::expr::parse_call_tail;
use crate::parse::expr::parse_expr as parse_expr_str;
/// Parse full source (with optional frontmatter) into a module AST.
pub fn parse_source(source: &str) -> Result<Module> {
let lines = classify_source(source);
let mut module = parse_classified(&lines)?;
module.source = crate::diagnostics::SourceIdentity::from_source(None, source);
Ok(module)
}
pub fn parse_classified(lines: &[ClassifiedLine]) -> Result<Module> {
let mut cur = Cursor::new(lines);
let (imports, uses, metadata_raw) = cur.parse_frontmatter()?;
let mut functions = Vec::new();
while cur.skip_noise() {
let Some(line) = cur.peek() else { break };
let trimmed = line.text.trim();
// Module-level Markdown thematic breaks (`---` / `***`) are narrative skip.
if is_frame(trimmed) {
cur.bump();
continue;
}
if is_heading(trimmed) {
functions.push(cur.parse_function(1, &HashSet::new())?);
} else if line.kind == LineKind::Comment {
// Intro paragraphs may still contain return-shaped italics (`返回*值*`)
// or leftover soft emphasis; executable prose belongs inside functions.
cur.bump();
continue;
} else {
bail!(
"{}:1: expected heading (`#` object or `##` function), got: {trimmed}",
line.line_no
);
}
}
for u in &uses {
if imports.iter().any(|i| i.bind == u.bind) {
bail!("import bind `{}` conflicts with file import library name", u.bind);
}
if functions.iter().any(|f| f.name == u.bind) {
bail!("import bind `{}` conflicts with top-level name", u.bind);
}
}
let module=Module {
source: Default::default(),
imports,
uses,
functions,
import_modules: std::collections::HashMap::new(),
metadata_raw,
metadata: Vec::new(),
};
crate::ast::validate_parameters(&module)?;
Ok(module)
}
/// Parse one GFM table with the source language's cell and shape rules.
/// Document readers reject nonliteral expressions before using the value.
pub(crate) fn parse_gfm_table(source: &str) -> Result<Expr> {
let lines = classify_source(source);
let mut cursor = Cursor::new(&lines);
let table = cursor.consume_table()?;
if cursor.skip_noise() {
bail!("unexpected content after the selected GFM table");
}
Ok(table)
}
struct Cursor<'a> {
lines: &'a [ClassifiedLine],
i: usize,
}
impl<'a> Cursor<'a> {
fn new(lines: &'a [ClassifiedLine]) -> Self {
Self { lines, i: 0 }
}
fn peek(&self) -> Option<&'a ClassifiedLine> {
self.lines.get(self.i)
}
fn bump(&mut self) -> Option<&'a ClassifiedLine> {
let l = self.lines.get(self.i)?;
self.i += 1;
Some(l)
}
/// Skip blank + writeback; stop on Code **or** Comment that has v0.3 inline bits.
fn skip_noise(&mut self) -> bool {
while let Some(l) = self.peek() {
match l.kind {
LineKind::Blank | LineKind::Writeback => {
self.i += 1;
}
LineKind::Comment => {
let bits = scan_prose_line(l.text.trim_end_matches(['\r', '\n']));
if bits.iter().any(|b| {
matches!(
b,
ProseBit::BoldCode { .. }
| ProseBit::ItalicReturn { .. }
| ProseBit::Decl { .. }
)
}) {
return true;
}
self.i += 1;
}
LineKind::Code => return true,
}
}
false
}
/// True if peek is a Comment line with executable/decl prose bits.
fn peek_is_prose(&self) -> bool {
let Some(l) = self.peek() else {
return false;
};
if l.kind != LineKind::Comment {
return false;
}
let bits = scan_prose_line(l.text.trim_end_matches(['\r', '\n']));
bits.iter().any(|b| {
matches!(
b,
ProseBit::BoldCode { .. }
| ProseBit::ItalicReturn { .. }
| ProseBit::Decl { .. }
)
})
}
fn parse_frontmatter(
&mut self,
) -> Result<(
Vec<Import>,
Vec<Use>,
Vec<(String, crate::binding::MetaValue)>,
)> {
let mut imports = Vec::new();
let mut uses = Vec::new();
let mut metadata_raw = Vec::new();
let mut import_keyword: Option<&'static str> = None;
if !self.skip_noise() {
return Ok((imports, uses, metadata_raw));
}
let Some(first) = self.peek() else {
return Ok((imports, uses, metadata_raw));
};
if first.text.trim() != "---" {
return Ok((imports, uses, metadata_raw));
}
self.bump();
while let Some(line) = self.peek() {
let t = line.text.trim();
if t == "---" {
self.bump();
break;
}
let span = Span::new(line.line_no, 1);
if let Some(msg) = legacy_frontmatter_import_hint(t) {
return Err(bail_at(None, span, msg));
}
// Artifact metadata key: value (flat Phase 1); `import:` / `导入:` are nested maps
if let Some((key, rest)) = split_frontmatter_key(t) {
if key == "import" || key == "导入" {
let kw = if key == "import" { "import" } else { "导入" };
if let Some(prev) = import_keyword {
if prev != kw {
return Err(bail_at(
None,
span,
format!(
"cannot mix `{prev}:` and `{kw}:` in one frontmatter (one language per file)"
),
));
}
return Err(bail_at(
None,
span,
format!("duplicate `{kw}:` block in frontmatter"),
));
}
if !rest.is_empty() {
return Err(bail_at(
None,
span,
format!(
"`{kw}:` must be a nested YAML map (not `{kw}: …` on one line); \
use indented `bind: target` under `{kw}:`"
),
));
}
import_keyword = Some(kw);
self.bump();
self.collect_import_map(span, &mut imports, &mut uses)?;
continue;
}
self.bump();
let value_raw = if rest.is_empty()
|| rest == "|"
|| rest == "|-"
|| rest == "|+"
|| rest == ">"
|| rest == ">-"
|| rest == ">+"
{
collect_block_scalar(self, rest)?
} else {
rest.to_string()
};
let mv = crate::binding::parse_meta_value(&value_raw)
.map_err(|e| bail_at(None, span, e.to_string()))?;
if metadata_raw.iter().any(|(k, _)| k == key) {
return Err(bail_at(
None,
span,
format!("duplicate metadata key `{key}`"),
));
}
metadata_raw.push((key.to_string(), mv));
continue;
}
// Unknown / non-key line: skip (compat with freeform frontmatter notes)
self.bump();
}
Ok((imports, uses, metadata_raw))
}
/// Consume indented `bind: target` lines under `import:` / `导入:`.
fn collect_import_map(
&mut self,
header_span: Span,
imports: &mut Vec<Import>,
uses: &mut Vec<Use>,
) -> Result<()> {
let _ = header_span;
while let Some(line) = self.peek() {
let raw = line.text.trim_end_matches(['\r', '\n']);
let bt = raw.trim();
if bt == "---" {
break;
}
if bt.is_empty() {
self.bump();
continue;
}
// Next top-level key ends the import map
if !raw.starts_with(' ') && !raw.starts_with('\t') {
break;
}
let span = Span::new(line.line_no, 1);
self.bump();
let content = strip_yaml_indent(raw);
let Some((bind_raw, target_raw)) = content.split_once(':') else {
return Err(bail_at(
None,
span,
format!("expected `bind: target` under import map, got `{content}`"),
));
};
let bind = bind_raw.trim();
let target = target_raw.trim();
let entry = parse_import_binding(bind, target)
.map_err(|e| bail_at(None, span, e.to_string()))?;
push_import_line(imports, uses, entry, span)?;
}
Ok(())
}
fn parse_function(&mut self, min_level: u8, inherited: &HashSet<String>) -> Result<Function> {
let line = self.bump().unwrap();
let (level, raw_name) = parse_heading(line.text.trim())
.ok_or_else(|| anyhow::anyhow!("{}:1: expected heading", line.line_no))?;
if level < min_level {
bail!("{}:1: heading level {level} < expected {min_level}", line.line_no);
}
let span = Span {
line: line.line_no,
col: 1,
};
let (name, base) = parse_object_decl(level, raw_name, span)?;
let mut fun = Function {
name,
level,
span,
params: Vec::new(),
body: Vec::new(),
children: Vec::new(),
base,
dead_binds: Vec::new(),
contract: None,
var_contracts: std::collections::HashMap::new(),
claims: Vec::new(),
};
// Prose decls pending promotion (name → optional default text).
let mut prose_decls: Vec<(String, Option<String>, u32)> = Vec::new();
// Parameter zone: explicit `+` lines (legacy / optional).
while self.skip_noise() {
let Some(l) = self.peek() else { break };
let trimmed = l.text.trim();
if is_heading(trimmed) {
let (nl, _) = parse_heading(trimmed).unwrap();
if nl > level {
let mut visible = inherited.clone();
let mut unused_reads = HashSet::new();
let mut unused_declarations = Vec::new();
collect_names_needing_input(&fun.body, &mut visible, &mut unused_reads, &HashSet::new(), &mut unused_declarations);
visible.extend(prose_decls.iter().map(|(name, _, _)| name.clone()));
visible.extend(fun.params.iter().map(|param| param.name.clone()));
fun.children.push(self.parse_function(level + 1, &visible)?);
continue;
}
break;
}
if self.peek_is_prose() {
break;
}
if let Some(param) = parse_param_line(trimmed, Span::new(l.line_no,1)) {
if fun.body.is_empty() {
fun.params.push(param);
self.bump();
continue;
}
}
break;
}
// Body until next heading at level <= ours, or explicit end.
while self.skip_noise() {
let Some(l) = self.peek() else { break };
let trimmed = l.text.trim();
// Empty return: whole-line `**`, `****`, `** **`
if is_empty_return_marker(trimmed) {
let span = Span {
line: l.line_no,
col: 1,
};
self.bump();
fun.body.push(Stmt::Return {
value: Expr::Literal(Literal::None),
span,
});
// Objects (`#`) may still declare `##` methods after the constructor return.
if level >= 2 {
break;
}
continue;
}
// `---` / `***` = Markdown thematic break (narrative skip), not function end.
// Side-effect-only helpers end with `*None*` / whole-line `**` / `****`, or at
// the next heading / EOF.
if is_frame(trimmed) {
self.bump();
continue;
}
if is_heading(trimmed) {
let (nl, _) = parse_heading(trimmed).unwrap();
if nl > level {
let mut visible = inherited.clone();
let mut unused_reads = HashSet::new();
let mut unused_declarations = Vec::new();
collect_names_needing_input(&fun.body, &mut visible, &mut unused_reads, &HashSet::new(), &mut unused_declarations);
visible.extend(prose_decls.iter().map(|(name, _, _)| name.clone()));
visible.extend(fun.params.iter().map(|param| param.name.clone()));
fun.children.push(self.parse_function(level + 1, &visible)?);
continue;
}
break;
}
if self.peek_is_prose() {
let line = self.bump().unwrap();
let span = Span {
line: line.line_no,
col: 1,
};
let bits = scan_prose_line(line.text.trim_end_matches(['\r', '\n']));
let mut end_body = false;
for bit in bits {
match bit {
ProseBit::Decl { name, default, .. } => {
if !prose_decls.iter().any(|(n, _, _)| n == &name) {
prose_decls.push((name, default, span.line));
}
}
ProseBit::BoldCode { inner, .. } => {
fun.body
.push(self.stmt_from_bold_inner(&inner, span.clone())?);
}
ProseBit::ItalicReturn { inner, .. } => {
fun.body.push(stmt_from_italic_return(&inner, span.clone())?);
// `##`+ : return ends the function so outer/sibling lines attach.
// `#` objects: keep scanning for method headings.
end_body = level >= 2;
break;
}
}
}
if end_body {
break;
}
continue;
}
if self.peek_is_formula_fence() {
if let Some(stmt) = self.try_parse_meta_formula_assign()? {
fun.body.push(stmt);
continue;
}
}
if is_ordered_branch(trimmed) {
fun.body.push(self.parse_branch()?);
continue;
}
if trimmed.starts_with('-') {
fun.body.push(self.parse_loop_or_err()?);
continue;
}
// Unbound GFM table = collection value (not assigned); evaluate and discard.
if trimmed.starts_with('|') {
let span = Span {
line: l.line_no,
col: 1,
};
let value = self.consume_table()?;
fun.body.push(Stmt::Expr { value, span });
continue;
}
let stmt = self.parse_simple_stmt()?;
let end_body = matches!(stmt, Stmt::Return { .. }) && level >= 2;
fun.body.push(stmt);
if end_body {
break;
}
}
// 契约提取(T2.1)必须在升参推断**之前**:契约表的单元不污染推断。
extract_function_contract(&mut fun, self.lines)?;
merge_inferred_params(&mut fun, &prose_decls, inherited)?;
Ok(fun)
}
fn parse_simple_stmt(&mut self) -> Result<Stmt> {
let line = self.bump().unwrap();
let span = Span {
line: line.line_no,
col: 1,
};
let trimmed = line.text.trim();
if is_frame(trimmed) {
// Should be skipped by callers; keep defensive message if reached.
bail!("{span}: unexpected frame line as statement (use empty return `*None*` / `**` / `****` to end a side-effect body)");
}
if trimmed.starts_with("$$") {
// Standalone meta formulas are handled before parse_simple_stmt.
bail!(
"{span}: formula fence must follow an empty assignment (`name` =) \
or include `% marqdo: var=name` inside the block"
);
}
// v0.3: whole-line empty return `**` / `****`
if is_empty_return_marker(trimmed) {
return Ok(Stmt::Return {
value: Expr::Literal(Literal::None),
span,
});
}
// v0.3: **…** = code segment (assign / call / expr)
if trimmed.starts_with("**") && trimmed.ends_with("**") && trimmed.len() >= 4 {
let inner = &trimmed[2..trimmed.len() - 2];
return self.stmt_from_bold_inner(inner, span);
}
// D9: bold code whose string literal is never closed. The line reaches
// this point (classifier keeps it Code) but has no closing `**`, so the
// generic "unrecognized statement" would hide the real cause.
if trimmed.starts_with("**") && has_unterminated_string(trimmed) {
bail!(
"{span}: unterminated string: this line starts bold code but \
contains an odd number of `\"` -- close the string and the \
trailing `**` (line: {trimmed})"
);
}
// v0.3: *…* = return. A lone `*` (markdown emphasis leftover) must NOT
// enter this branch: it both starts and ends with `*`, and the slice
// below would panic (`[1..0]`). Require a real opener+closer pair; a
// bare `*` falls through to the ordinary statement error / narration
// handling instead of crashing the whole process.
if trimmed.starts_with('*') && trimmed.ends_with('*') && trimmed.len() >= 2 && !trimmed.starts_with("**") {
let inner = &trimmed[1..trimmed.len() - 1];
return stmt_from_italic_return(inner, span);
}
// Call >
if trimmed.starts_with('>') {
let call = call_after_gt(trimmed[1..].trim(), false)?;
return Ok(Stmt::Call { call, span });
}
// Unbound GFM table (header already consumed by bump above).
if trimmed.starts_with('|') {
self.i -= 1;
let value = self.consume_table()?;
return Ok(Stmt::Expr { value, span });
}
// Bare assign `` `x` = … ``
if trimmed.starts_with('`') {
if let Some(stmt) = self.parse_backtick_assign(trimmed, span.clone())? {
return Ok(stmt);
}
}
// Mid-line prose on a Code-classified line: scan inlines
let bits = scan_prose_line(line.text.trim_end_matches(['\r', '\n']));
if bits.iter().any(|b| {
matches!(
b,
ProseBit::BoldCode { .. } | ProseBit::ItalicReturn { .. }
)
}) {
// Expand to multiple stmts — caller only expects one; push extras via...
// For whole-line Code that's actually "先写**…**再写**…**", classify is Comment
// and handled in prose path. If we get here, emit first executable bit only
// and require callers to use prose path for multi — but multi-bold is Comment.
let mut stmts = Vec::new();
for bit in bits {
match bit {
ProseBit::BoldCode { inner, .. } => {
stmts.push(self.stmt_from_bold_inner(&inner, span.clone())?);
}
ProseBit::ItalicReturn { inner, .. } => {
stmts.push(stmt_from_italic_return(&inner, span.clone())?);
}
ProseBit::Decl { .. } => {}
}
}
if stmts.len() == 1 {
return Ok(stmts.pop().unwrap());
}
if stmts.len() > 1 {
// Represent as a synthetic block: execute by chaining — use first and
// stash is awkward. Prefer: return error asking for prose classification.
// Simpler: fold into a Branch with one arm? No.
// Use Stmt::Call sequence — add by making parse_function handle this.
bail!("{span}: multiple inline code segments on one code line; use narrative line");
}
}
Err(Diagnostic::new(None, span, format!("unrecognized statement: {trimmed}")).into())
}
/// Parse bold-code inner into Assign / Call / Expr (design §6.2).
fn stmt_from_bold_inner(&mut self, inner: &str, span: Span) -> Result<Stmt> {
let inner = inner.trim();
if inner.is_empty() {
return Ok(Stmt::Return {
value: Expr::Literal(Literal::None),
span,
});
}
if let Some((name, rhs)) = split_assign_inner(inner) {
if crate::aliases::is_reserved_keyword(&name) {
bail!("{span}: `{name}` is a reserved keyword");
}
let (value, end_line) = self.resolve_assign_rhs(&name, &rhs, span, true)?;
return Ok(Stmt::Assign {
name,
value,
span,
end_line,
});
}
if let Some(rest) = inner.strip_prefix('>') {
// Explicit `>` keeps standalone call rules (bare words = text).
let call = parse_call_after_gt(rest.trim(), false)
.map_err(|e| anyhow::anyhow!("{span}: bold code: {e}"))?;
return Ok(Stmt::Call { call, span });
}
// Expression first (`n + 1` / `[k](c)`); bare call second (`加一 37`).
if let Ok(e) = parse_expr_prefer_var(inner) {
match e {
Expr::Call(call) => return Ok(Stmt::Call { call, span }),
Expr::Var(_) | Expr::Literal(_) => {}
value => return Ok(Stmt::Expr { value, span }),
}
}
let multi = inner.split_whitespace().count() >= 2 || inner.contains('=');
if multi {
let call = parse_call_tail(inner, true)
.map(|(c, _)| c)
.map_err(|e| anyhow::anyhow!("{span}: bold code: {e}"))?;
return Ok(Stmt::Call { call, span });
}
bail!("{span}: bold code must be assignment, call, or expression (got `{inner}`)");
}
fn parse_backtick_assign(&mut self, trimmed: &str, span: Span) -> Result<Option<Stmt>> {
// `name` = [rhs]
let Some(rest) = trimmed.strip_prefix('`') else {
return Ok(None);
};
let Some(end) = rest.find('`') else {
return Ok(None);
};
let name = rest[..end].to_string();
if crate::aliases::is_reserved_keyword(&name) {
bail!("{span}: `{name}` is a reserved keyword");
}
let after = rest[end + 1..].trim_start();
if !after.starts_with('=') {
return Ok(None);
}
let rhs = after[1..].trim().to_string();
let (value, end_line) = self.resolve_assign_rhs(&name, &rhs, span, false)?;
Ok(Some(Stmt::Assign {
name,
value,
span,
end_line,
}))
}
/// RHS on the same line, or empty RHS → following `$$` / ```lang fence or table.
/// Returns `(expr, inclusive end_line)`.
/// `prefer_var`: italic RHS uses variable-preferring expression syntax.
fn resolve_assign_rhs(
&mut self,
assign_name: &str,
rhs: &str,
span: Span,
prefer_var: bool,
) -> Result<(Expr, u32)> {
let rhs = rhs.trim();
if rhs.is_empty() {
self.skip_blanks();
if self.peek_is_formula_fence() {
let (expr, end_line, meta_var) = self.consume_formula_fence(span)?;
check_formula_meta_var(assign_name, meta_var.as_deref(), span)?;
return Ok((expr, end_line));
}
if self.peek_is_code_fence() {
return self.consume_code_fence(span);
}
let start_i = self.i;
let table = self.consume_table()?;
let end_line = if self.i > start_i {
self.lines[self.i - 1].line_no
} else {
span.line
};
return Ok((table, end_line));
}
if let Some(expr) = try_parse_inline_formula(rhs)? {
return Ok((expr, span.line));
}
if rhs.starts_with('>') {
return Ok((
Expr::Call(call_after_gt(rhs[1..].trim(), prefer_var)?),
span.line,
));
}
// v0.3 prefer_var RHS: expression first (`p + qn`), else bare call (`加一 37`).
if prefer_var {
if let Ok(e) = parse_expr_prefer_var(rhs) {
return Ok((e, span.line));
}
let multi = rhs.split_whitespace().count() >= 2 || rhs.contains('=');
if multi {
if let Ok((call, consumed)) = parse_call_tail(rhs, true) {
let rest = rhs.get(consumed..).unwrap_or("").trim();
if rest.is_empty() {
return Ok((Expr::Call(call), span.line));
}
}
}
}
let value = if prefer_var {
parse_expr_prefer_var(rhs)?
} else {
parse_value_or_interp(rhs)?
};
Ok((value, span.line))
}
fn skip_blanks(&mut self) {
while let Some(l) = self.peek() {
if l.kind == LineKind::Blank {
self.i += 1;
} else {
break;
}
}
}
fn peek_is_formula_fence(&self) -> bool {
self.peek()
.map(|l| l.text.trim().starts_with("$$"))
.unwrap_or(false)
}
fn peek_is_code_fence(&self) -> bool {
self.peek()
.map(|l| crate::foreign::is_fence_opener(l.text.trim()))
.unwrap_or(false)
}
fn consume_code_fence(&mut self, span: Span) -> Result<(Expr, u32)> {
let open = self
.bump()
.ok_or_else(|| anyhow::anyhow!("{span}: expected ```lang code fence"))?;
let open_line = open.line_no;
let trimmed = open.text.trim();
let lang = crate::foreign::fence_lang(trimmed).ok_or_else(|| {
anyhow::anyhow!("{open_line}:1: expected ```lang fence after empty assignment")
})?;
if trimmed.contains("name=") {
bail!(
"{open_line}:1: `name=` on fences was removed; \
use `name` = then a ```{lang} fence (same shape as formulas)"
);
}
let mut body_lines: Vec<String> = Vec::new();
let mut closed = false;
let mut end_line = open_line;
while let Some(l) = self.peek() {
if crate::foreign::is_fence_closer(l.text.trim()) {
end_line = l.line_no;
self.bump();
closed = true;
break;
}
body_lines.push(l.text.clone());
self.bump();
}
if !closed {
bail!("{open_line}:1: unclosed code fence ```{lang}");
}
let source = body_lines.join("\n");
Ok((
Expr::Code(crate::value::CodeBlock { lang, source }),
end_line,
))
}
/// Consume `$$…$$`. Returns `(expr, end_line, optional var from % marqdo: var=)`.
fn consume_formula_fence(&mut self, span: Span) -> Result<(Expr, u32, Option<String>)> {
let open = self
.bump()
.ok_or_else(|| anyhow::anyhow!("{span}: expected `$$` formula fence"))?;
let open_line = open.line_no;
let trimmed = open.text.trim();
if trimmed.starts_with("$$:") || trimmed.starts_with("$$ name=") {
bail!(
"{open_line}:1: `$$:name` / `$$ name=` binding was removed; \
use `% marqdo: var=name` inside `$$…$$` or `name` = then a fence"
);
}
// Single-line: $$body$$
if trimmed.starts_with("$$") && trimmed.ends_with("$$") && trimmed.len() > 4 {
let body = trimmed[2..trimmed.len() - 2].trim();
if body.is_empty() {
bail!("{open_line}:1: empty formula");
}
let (meta_var, tex) = strip_formula_marqdo_meta(body)
.map_err(|e| anyhow::anyhow!("{open_line}:1: {e}"))?;
if tex.is_empty() {
bail!("{open_line}:1: empty formula");
}
return Ok((
formula_fence_to_expr(&tex)
.map_err(|e| anyhow::anyhow!("{open_line}:1: formula: {e}"))?,
open_line,
meta_var,
));
}
if trimmed != "$$" {
bail!(
"{open_line}:1: expected `$$` fence opener, got: {trimmed}"
);
}
let mut body_lines: Vec<String> = Vec::new();
let mut closed = false;
let mut end_line = open_line;
while let Some(l) = self.peek() {
if l.text.trim() == "$$" {
end_line = l.line_no;
self.bump();
closed = true;
break;
}
body_lines.push(l.text.clone());
self.bump();
}
if !closed {
bail!("{open_line}:1: unclosed formula fence `$$`");
}
let raw = body_lines.join("\n");
let (meta_var, tex) = strip_formula_marqdo_meta(&raw)
.map_err(|e| anyhow::anyhow!("{open_line}:1: {e}"))?;
if tex.is_empty() {
bail!("{open_line}:1: empty formula");
}
let expr = formula_fence_to_expr(&tex)
.map_err(|e| anyhow::anyhow!("{open_line}:1: formula: {e}"))?;
Ok((expr, end_line, meta_var))
}
/// Standalone `$$` with `% marqdo: var=` → Assign (no empty RHS required).
fn try_parse_meta_formula_assign(&mut self) -> Result<Option<Stmt>> {
if !self.peek_is_formula_fence() {
return Ok(None);
}
let Some(l) = self.peek() else {
return Ok(None);
};
let span = Span {
line: l.line_no,
col: 1,
};
let (value, end_line, meta_var) = self.consume_formula_fence(span)?;
let Some(name) = meta_var else {
bail!(
"{span}: formula fence must follow an empty assignment (`name` =) \
or include `% marqdo: var=name` inside the block"
);
};
if crate::aliases::is_reserved_keyword(&name) {
bail!("{span}: `{name}` is a reserved keyword");
}
Ok(Some(Stmt::Assign {
name,
value,
span,
end_line,
}))
}
/// GFM table after empty RHS:
/// - 1-col → List
/// - first header `@` / `行` / `row` → List of row Maps (marker col excluded)
/// - else ≥2-col → Map (column-oriented)
///
/// Also used for **unbound** tables in a function body (value computed, not stored).
///
/// Data cells are expressions ([`parse_call_arg_value`]); headers stay key text.
fn consume_table(&mut self) -> Result<Expr> {
self.skip_noise();
let mut header: Vec<String> = Vec::new();
let mut header_line: u32 = 1;
let mut data_rows: Vec<(u32, Vec<String>)> = Vec::new();
let mut header_done = false;
let mut sep_done = false;
while let Some(l) = self.peek() {
if l.kind != LineKind::Code {
break;
}
let t = l.text.trim();
if !t.starts_with('|') {
break;
}
let line_no = l.line_no;
self.bump();
let cells = split_table_row(t);
if !header_done {
header = cells;
header_line = line_no;
header_done = true;
continue;
}
if !sep_done
&& cells
.iter()
.all(|c| c.chars().all(|ch| ch == '-' || ch == ':' || ch.is_whitespace()))
{
sep_done = true;
continue;
}
sep_done = true;
data_rows.push((line_no, cells));
}
if !header_done {
bail!("expected GFM table after empty assignment");
}
// Strong / Surface: unequal row arity is stuck — no silent pad/truncate.
for (line_no, cells) in &data_rows {
if cells.len() != header.len() {
return Err(Diagnostic::new(
None,
Span {
line: *line_no,
col: 1,
},
format!(
"table row arity mismatch: expected {} columns, got {}",
header.len(),
cells.len()
),
)
.into());
}
}
let row_oriented = header
.first()
.map(|h| is_row_table_marker(h))
.unwrap_or(false);
if row_oriented {
return build_row_oriented_table(header, header_line, data_rows);
}
if header.len() <= 1 {
let mut rows = Vec::new();
for (line_no, cells) in data_rows {
if let Some(cell) = cells.first() {
rows.push(parse_table_cell(cell, line_no)?);
}
}
return Ok(Expr::List(rows));
}
// Duplicate header keys are errors (column identity must be unique).
let mut seen = std::collections::HashSet::new();
for key in &header {
if !seen.insert(key.clone()) {
return Err(Diagnostic::new(
None,
Span {
line: header_line,
col: 1,
},
format!("duplicate table header `{key}`"),
)
.into());
}
}
let n_rows = data_rows.len();
let mut pairs = Vec::with_capacity(header.len());
for (col, key) in header.iter().enumerate() {
if n_rows == 1 {
let (line_no, cells) = &data_rows[0];
let raw = cells.get(col).map(|s| s.as_str()).unwrap_or("");
pairs.push((key.clone(), parse_table_cell(raw, *line_no)?));
} else {
// 0 rows → empty lists; ≥2 rows → column lists.
let mut col_vals = Vec::with_capacity(n_rows);
for (line_no, cells) in &data_rows {
let raw = cells.get(col).map(|s| s.as_str()).unwrap_or("");
col_vals.push(parse_table_cell(raw, *line_no)?);
}
pairs.push((key.clone(), Expr::List(col_vals)));
}
}
Ok(Expr::Map(pairs))
}
fn parse_branch(&mut self) -> Result<Stmt> {
let first = self.peek().unwrap();
let span = Span {
line: first.line_no,
col: 1,
};
let base_indent = indent_of(&first.text);
let mut arms = Vec::new();
while self.skip_noise() {
let Some(l) = self.peek() else { break };
let ind = indent_of(&l.text);
if ind < base_indent {
break;
}
let trimmed = l.text.trim();
let Some(num) = ordered_item_number(trimmed) else {
break;
};
if ind != base_indent {
break;
}
// Same-indent restart at `1.` begins a new Branch statement.
if !arms.is_empty() && num == 1 {
break;
}
let cond_src = strip_ordered(trimmed).unwrap();
self.bump();
let condition = parse_branch_condition(cond_src)?;
let body = self.parse_indented_body(base_indent)?;
arms.push(BranchArm { condition, body });
}
if arms.is_empty() {
bail!("{span}: empty branch");
}
Ok(Stmt::Branch { arms, span })
}
fn parse_loop_or_err(&mut self) -> Result<Stmt> {
let line = self.bump().unwrap();
let span = Span {
line: line.line_no,
col: 1,
};
let base_indent = indent_of(&line.text);
let trimmed = line.text.trim();
let rest = trimmed.strip_prefix('-').unwrap().trim();
// `<TAB>` M3: occlusion loop `- [描述](遍历 集合 为 变量)`
if crate::parse::expr::markup_default() == crate::parse::expr::Markup::Occlusion {
if let Some((label, coll, item)) = parse_occluded_foreach(rest) {
let body = self.parse_indented_body(base_indent)?;
return Ok(Stmt::ForEach {
item,
collection: coll,
label: Some(label),
body,
span,
});
}
}
// foreach: [item](collection) or narrative sugar
if let Some((item, coll)) = parse_foreach_header(rest)
.or_else(|| parse_foreach_narrative(rest))
{
let body = self.parse_indented_body(base_indent)?;
return Ok(Stmt::ForEach {
item,
collection: coll,
label: None,
body,
span,
});
}
// while: expression
let condition = parse_expr_str(rest)?;
let body = self.parse_indented_body(base_indent)?;
Ok(Stmt::While {
condition,
body,
span,
})
}
fn parse_indented_body(&mut self, parent_indent: usize) -> Result<Vec<Stmt>> {
let mut body = Vec::new();
while self.skip_noise() {
let Some(l) = self.peek() else { break };
let ind = indent_of(&l.text);
if ind <= parent_indent {
// Same-indent `2.` / `-` ends body (next arm / sibling).
break;
}
let trimmed = l.text.trim();
if is_frame(trimmed) {
self.bump();
continue;
}
if is_heading(trimmed) {
break;
}
if is_ordered_branch(trimmed) {
// Nested branch inside body
body.push(self.parse_branch()?);
continue;
}
if trimmed.starts_with('-') {
body.push(self.parse_loop_or_err()?);
continue;
}
// Same prose rights as function body (fixes arm/loop narrative escape).
if self.peek_is_prose() {
let line = self.bump().unwrap();
let span = Span {
line: line.line_no,
col: 1,
};
let bits = scan_prose_line(line.text.trim_end_matches(['\r', '\n']));
let mut end_arm = false;
for bit in bits {
match bit {
ProseBit::Decl { .. } => {}
ProseBit::BoldCode { inner, .. } => {
body.push(self.stmt_from_bold_inner(&inner, span.clone())?);
}
ProseBit::ItalicReturn { inner, .. } => {
body.push(stmt_from_italic_return(&inner, span.clone())?);
end_arm = true;
break;
}
}
}
if end_arm {
break;
}
continue;
}
if self.peek_is_formula_fence() {
if let Some(stmt) = self.try_parse_meta_formula_assign()? {
body.push(stmt);
continue;
}
}
let stmt = self.parse_simple_stmt()?;
let end_arm = matches!(stmt, Stmt::Return { .. });
body.push(stmt);
if end_arm {
break;
}
}
Ok(body)
}
}
fn split_assign_inner(inner: &str) -> Option<(String, String)> {
let inner = inner.trim();
if let Some(rest) = inner.strip_prefix('`') {
let end = rest.find('`')?;
let name = rest[..end].to_string();
if name.is_empty() {
return None;
}
let after = rest[end + 1..].trim_start();
let rhs = after.strip_prefix('=')?.trim().to_string();
return Some((name, rhs));
}
// Bare LHS: `answer = …` (italic exemption).
let eq = inner.find('=')?;
let name = inner[..eq].trim();
if !is_bare_assign_ident(name) {
return None;
}
let rhs = inner[eq + 1..].trim().to_string();
Some((name.to_string(), rhs))
}
fn is_bare_assign_ident(s: &str) -> bool {
if s.is_empty() || s.contains('`') || s.chars().any(char::is_whitespace) {
return false;
}
let mut chars = s.chars();
let Some(first) = chars.next() else {
return false;
};
if !(first.is_alphanumeric() || first == '_' || !first.is_ascii()) {
return false;
}
true
}
/// Same-line `$$body$$` or `$body$` → Formula; otherwise None.
fn try_parse_inline_formula(rhs: &str) -> Result<Option<Expr>> {
let rhs = rhs.trim();
if rhs.starts_with("$$:") || rhs.starts_with("$$ name=") {
bail!(
"`$$:name` / `$$ name=` binding was removed; use `% marqdo: var=name` \
inside `$$…$$` or `name` = then a fence"
);
}
if rhs.starts_with("$$") {
if rhs.ends_with("$$") && rhs.len() > 4 {
let body = rhs[2..rhs.len() - 2].trim();
if body.is_empty() {
bail!("empty formula");
}
let (_meta, tex) = strip_formula_marqdo_meta(body)
.map_err(|e| anyhow::anyhow!("{e}"))?;
if tex.is_empty() {
bail!("empty formula");
}
let expr = formula_fence_to_expr(&tex).map_err(|e| anyhow::anyhow!("formula: {e}"))?;
return Ok(Some(expr));
}
bail!("incomplete inline formula (expected `$$…$$` on one line)");
}
// Traditional inline: $…$ (not $$)
if rhs.starts_with('$') && rhs.ends_with('$') && rhs.len() > 2 && !rhs.starts_with("$$") {
let body = rhs[1..rhs.len() - 1].trim();
if body.is_empty() {
bail!("empty formula");
}
if body.contains('%') && body.to_lowercase().contains("marqdo:") {
bail!(
"inline `$…$` must not use `% marqdo:` (breaks Markdown/TeX); \
bind with `name` = $…$ or use a `$$` block with `% marqdo: var=`"
);
}
let expr = formula_fence_to_expr(body).map_err(|e| anyhow::anyhow!("formula: {e}"))?;
return Ok(Some(expr));
}
Ok(None)
}
/// Strip `% marqdo: var=name` directive lines from formula fence body.
/// Returns `(optional var name, remaining TeX)`.
fn strip_formula_marqdo_meta(body: &str) -> Result<(Option<String>, String), String> {
let mut meta_var: Option<String> = None;
let mut out: Vec<&str> = Vec::new();
for line in body.lines() {
let t = line.trim();
if let Some(rest) = t.strip_prefix('%') {
let rest = rest.trim_start();
if rest.to_ascii_lowercase().starts_with("marqdo:") {
let after = rest["marqdo:".len()..].trim_start();
let mut got_var = false;
for part in after.split_whitespace() {
if let Some(v) = part.strip_prefix("var=") {
if v.is_empty() {
return Err("% marqdo: var= requires a name".into());
}
if !is_bare_assign_ident(v) {
return Err(format!("invalid marqdo var name `{v}`"));
}
if meta_var.as_deref() == Some(v) || meta_var.is_none() {
meta_var = Some(v.to_string());
} else {
return Err(format!(
"conflicting % marqdo: var= ({} vs {v})",
meta_var.as_deref().unwrap_or("")
));
}
got_var = true;
} else {
return Err(format!("unknown marqdo key `{part}` (only var= is supported)"));
}
}
if !got_var {
return Err("% marqdo: requires var=<name>".into());
}
continue; // strip directive line
}
}
out.push(line);
}
Ok((meta_var, out.join("\n").trim().to_string()))
}
fn check_formula_meta_var(assign_name: &str, meta: Option<&str>, span: Span) -> Result<()> {
match meta {
None => Ok(()),
Some(v) if v == assign_name => Ok(()),
Some(v) => bail!(
"{span}: formula `% marqdo: var={v}` conflicts with assignment `{assign_name}`"
),
}
}
fn formula_fence_to_expr(body: &str) -> Result<Expr, String> {
if crate::formula::looks_like_matrix(body) {
let rows = crate::formula::parse_eval_matrix(body)?;
return Ok(Expr::Formula(crate::formula::Expr::Matrix {
source: body.trim().to_string(),
rows,
}));
}
let expr = crate::formula::parse(body)?;
Ok(Expr::Formula(expr))
}
fn parse_backtick_ident(s: &str) -> Option<String> {
let s = s.trim();
if !s.starts_with('`') {
return None;
}
let inner = &s[1..];
let end = inner.find('`')?;
let name = &inner[..end];
if name.is_empty() || s.len() != end + 2 {
return None;
}
Some(name.to_string())
}
fn parse_param_line(trimmed: &str, span:Span) -> Option<crate::ast::Param> {
use crate::ast::Param;
let rest = trimmed.strip_prefix('+')?.trim();
if rest.is_empty() || !rest.starts_with('`') {
return None;
}
let end_tick = rest[1..].find('`')?;
let name = rest[1..end_tick + 1].to_string();
if name.is_empty() {
return None;
}
let after = rest[end_tick + 2..].trim();
let default = if let Some(def_s) = after.strip_prefix('=') {
let def_s = def_s.trim();
if def_s.is_empty() {
return None;
}
Some(parse_call_arg_value(def_s).ok()?)
} else if after.is_empty() {
None
} else {
return None;
};
Some(Param {
name,
span,
default,
inferred: false,
})
}
fn parse_foreach_ident(s: &str) -> Option<String> {
let s = s.trim();
if s.starts_with('`') {
return parse_backtick_ident(s);
}
if s.is_empty() {
return None;
}
// Bare name exemption: `[item](list)` without ticks (foreach only).
if s.chars().any(|c| c.is_whitespace() || c == '`' || c == '[' || c == ']') {
return None;
}
let mut chars = s.chars();
let first = chars.next()?;
if !(first.is_alphanumeric() || first == '_' || !first.is_ascii()) {
return None;
}
Some(s.to_string())
}
/// `<TAB>` M3: `[描述](遍历 集合 为 变量)` → `(label, collection, item)`.
fn parse_occluded_foreach(rest: &str) -> Option<(String, String, String)> {
let rest = rest.trim();
if !rest.starts_with('[') {
return None;
}
let end = rest.find(']')?;
let label = rest[1..end].trim().to_string();
let after = rest[end + 1..].trim_start();
if !after.starts_with('(') || !after.ends_with(')') {
return None;
}
let inner = after[1..after.len() - 1].trim();
let parts: Vec<&str> = inner.split_whitespace().collect();
// `遍历 <collection> 为 <item>` (English `for <c> as <i>` accepted too)
if parts.len() != 4 {
return None;
}
let head_ok = matches!(parts[0], "遍历" | "for");
let mid_ok = matches!(parts[2], "为" | "as" | "in");
if !head_ok || !mid_ok {
return None;
}
let coll = parse_foreach_ident(parts[1])?;
let item = parse_foreach_ident(parts[3])?;
Some((label, coll, item))
}
fn parse_foreach_header(rest: &str) -> Option<(String, String)> {
// [`item`](`collection`) or bare [item](collection); sides may mix.
let rest = rest.trim();
if !rest.starts_with('[') {
return None;
}
let end_item = rest.find(']')?;
let item = parse_foreach_ident(&rest[1..end_item])?;
let after = rest[end_item + 1..].trim_start();
if !after.starts_with('(') || !after.ends_with(')') {
return None;
}
let coll = parse_foreach_ident(&after[1..after.len() - 1])?;
Some((item, coll))
}
/// Narrative foreach sugar (recommended remains `- [item](coll)`).
/// - ZH: `对`xs`的每一项`项`` optional `遍历`
/// - EN: `for each `item` in `xs``
fn parse_foreach_narrative(rest: &str) -> Option<(String, String)> {
let rest = rest.trim();
if let Some(after) = rest.strip_prefix('对') {
let (coll, after) = take_backtick_token(after.trim_start())?;
let after = after.trim_start().strip_prefix("的每一项")?;
let (item, after) = take_backtick_token(after.trim_start())?;
let after = after
.trim()
.trim_end_matches('。')
.trim();
let after = after.strip_prefix("遍历").unwrap_or(after).trim();
if after.is_empty() {
return Some((item, coll));
}
return None;
}
let lower = rest.to_ascii_lowercase();
let Some(idx) = lower.find("for each ") else {
return None;
};
if idx != 0 {
return None;
}
let after = rest["for each ".len()..].trim_start();
let (item, after) = take_backtick_token(after)?;
let after = after.trim_start();
let after_l = after.to_ascii_lowercase();
if !after_l.starts_with("in ") && !after_l.starts_with("in\t") {
// require ` in `
let Some(in_at) = after_l.find("in ") else {
return None;
};
if in_at != 0 {
return None;
}
}
let after = after["in ".len()..].trim_start();
let (coll, after) = take_backtick_token(after)?;
if after.trim().is_empty() {
return Some((item, coll));
}
None
}
fn take_backtick_token(s: &str) -> Option<(String, &str)> {
let s = s.trim_start();
if !s.starts_with('`') {
return None;
}
let end = s[1..].find('`')?;
let name = s[1..1 + end].to_string();
if name.is_empty() {
return None;
}
Some((name, &s[1 + end + 1..]))
}
/// Branch arm condition: expr, bold code, narrative (当`n`大于 0 时), or else `*`.
fn parse_branch_condition(cond_src: &str) -> Result<Option<Expr>> {
let t = cond_src.trim();
if t.is_empty() || t == "*" {
return Ok(None);
}
// "否则 *" / "else *"
if let Some(before) = t.strip_suffix('*') {
let before = before.trim();
if before.is_empty()
|| before == "否则"
|| before == "其它"
|| before == "其他"
|| before.eq_ignore_ascii_case("else")
|| before.eq_ignore_ascii_case("otherwise")
{
return Ok(None);
}
}
if let Ok(e) = parse_expr_str(t) {
return Ok(Some(e));
}
if let Some(inner) = extract_first_bold_inner(t) {
if let Ok(e) = parse_expr_str(inner.trim()) {
return Ok(Some(e));
}
}
if let Some(e) = try_narrative_condition(t) {
return Ok(Some(e));
}
bail!(
"branch condition: cannot parse `{t}` \
(use an expression, **`n` > 0**, or 当`n`大于 0 时)"
)
}
fn extract_first_bold_inner(s: &str) -> Option<&str> {
let start = s.find("**")?;
let rest = &s[start + 2..];
let end = rest.find("**")?;
Some(&rest[..end])
}
fn try_narrative_condition(s: &str) -> Option<Expr> {
let mut s = s.trim();
for p in ["当且仅当", "当", "若", "如果"] {
if let Some(r) = s.strip_prefix(p) {
s = r.trim_start();
break;
}
}
let lower = s.to_ascii_lowercase();
if let Some(r) = lower.strip_prefix("when ") {
let _ = r;
s = s[5..].trim_start();
} else if let Some(r) = lower.strip_prefix("if ") {
let _ = r;
s = s[3..].trim_start();
}
for suf in ["的话", "时", "则"] {
if let Some(r) = s.strip_suffix(suf) {
s = r.trim_end();
}
}
let mut mapped = s.to_string();
let replacements = [
("大于等于", ">="),
("小于等于", "<="),
("不等于", "!="),
("等于", "=="),
("大于", ">"),
("小于", "<"),
];
for (zh, op) in replacements {
if mapped.contains(zh) {
mapped = mapped.replace(zh, op);
break;
}
}
parse_expr_str(mapped.trim()).ok()
}
fn parse_heading(trimmed: &str) -> Option<(u8, &str)> {
if !trimmed.starts_with('#') {
return None;
}
let mut level = 0u8;
for c in trimmed.chars() {
if c == '#' {
level = level.saturating_add(1);
} else {
break;
}
}
if level == 0 || level > 6 {
return None;
}
let name = trimmed[level as usize..].trim();
if name.is_empty() {
return None;
}
Some((level, name))
}
/// `# Child = > Parent` → `(Child, Some(Parent))`; plain `# Child` → `(Child, None)`.
fn parse_object_decl(level: u8, raw: &str, span: Span) -> Result<(String, Option<String>)> {
let raw = raw.trim();
if let Some(eq) = raw.find('=') {
if level != 1 {
return Err(Diagnostic::new(
None,
span,
"inheritance (`= > Base`) is only allowed on `#` object headings",
)
.into());
}
let name = raw[..eq].trim();
let rhs = raw[eq + 1..].trim();
if name.is_empty() {
return Err(Diagnostic::new(None, span, "object name missing before `=`").into());
}
if !is_simple_type_name(name) {
return Err(Diagnostic::new(
None,
span,
format!("invalid object name `{name}`"),
)
.into());
}
let Some(after_gt) = rhs.strip_prefix('>') else {
return Err(Diagnostic::new(
None,
span,
"object inheritance requires `# Name = > Base` (base must follow `>`)",
)
.into());
};
let base = after_gt.trim();
if base.is_empty() {
return Err(Diagnostic::new(None, span, "missing base type after `>`").into());
}
if base.contains('.') {
return Err(Diagnostic::new(
None,
span,
format!("base type must be a simple name, not a path (`{base}`)"),
)
.into());
}
if !is_simple_type_name(base) {
return Err(Diagnostic::new(
None,
span,
format!("invalid base type name `{base}`"),
)
.into());
}
return Ok((name.to_string(), Some(base.to_string())));
}
Ok((raw.to_string(), None))
}
fn is_simple_type_name(s: &str) -> bool {
let mut chars = s.chars();
let Some(first) = chars.next() else {
return false;
};
if !(first.is_alphabetic() || first == '_' || !first.is_ascii()) {
return false;
}
chars.all(|c| c.is_alphanumeric() || c == '_' || !c.is_ascii())
}
/// Result of one import map entry (`bind: target` under `import:` / `导入:`).
#[derive(Debug, Clone)]
pub enum ImportLine {
File(Import),
Member(Use),
}
/// Hint shown when legacy one-line or `>` imports are rejected.
pub const NESTED_IMPORT_HINT: &str = "legacy frontmatter import removed; use nested YAML \
`import:\\n bind: target` (Chinese: `导入:`) — or run `marqdo migrate imports --write`";
fn split_frontmatter_key(trimmed: &str) -> Option<(&str, &str)> {
let t = trimmed.trim();
if t.is_empty() || t.starts_with('#') {
return None;
}
let Some((key, rest)) = t.split_once(':') else {
return None;
};
let key = key.trim();
if key.is_empty() || key.contains(' ') {
return None;
}
// Avoid treating `http://…` style as key (no spaces in key already; also reject if key has `/`)
if key.contains('/') {
return None;
}
Some((key, rest.trim()))
}
fn collect_block_scalar(cur: &mut Cursor<'_>, indicator: &str) -> Result<String> {
let mut lines = Vec::new();
while let Some(line) = cur.peek() {
let raw = line.text.trim_end_matches(['\r', '\n']);
let bt = raw.trim();
if bt == "---" {
break;
}
// Next top-level key ends the block
if !raw.starts_with(' ') && !raw.starts_with('\t') && !bt.is_empty() {
if split_frontmatter_key(bt).is_some() {
break;
}
if indicator.is_empty() {
// empty rest on key line without block indicator: no body
break;
}
}
if indicator.is_empty() {
break;
}
cur.bump();
if raw.starts_with(' ') || raw.starts_with('\t') {
lines.push(strip_yaml_indent(raw));
} else if bt.is_empty() {
lines.push(String::new());
} else {
// folded content without indent — take as-is once
lines.push(bt.to_string());
break;
}
}
if indicator.starts_with('>') {
Ok(lines
.into_iter()
.filter(|l| !l.is_empty())
.collect::<Vec<_>>()
.join(" "))
} else {
Ok(lines.join("\n"))
}
}
fn strip_yaml_indent(line: &str) -> String {
if line.starts_with(" ") {
line[2..].to_string()
} else if line.starts_with('\t') {
line[1..].to_string()
} else {
line.trim_start_matches([' ', '\t']).to_string()
}
}
/// True for removed one-liner `import bind:target` / `导入 bind:target`.
pub fn is_legacy_import_oneliner(trimmed: &str) -> bool {
let t = trimmed.trim();
if t.starts_with("import")
&& t.get(6..)
.is_some_and(|s| s.starts_with(|c: char| c.is_whitespace()))
{
let after = t[6..].trim();
return after.contains(':') && !after.is_empty();
}
if let Some(a) = t.strip_prefix("导入") {
let a = a.trim_start();
// `导入:` is the new nested header, not a one-liner
if a.is_empty() || a.starts_with(':') {
return false;
}
return a.contains(':');
}
false
}
fn legacy_frontmatter_import_hint(trimmed: &str) -> Option<String> {
let t = trimmed.trim();
if is_legacy_import_oneliner(t) {
return Some(NESTED_IMPORT_HINT.into());
}
if !t.starts_with('>') {
return None;
}
let rest = t[1..].trim();
let looks_file = rest.contains(".mq.md");
let looks_use = rest.starts_with("use")
|| rest.starts_with("使用")
|| rest.starts_with("use ")
|| rest.starts_with("使用 ");
if looks_file || looks_use {
return Some(NESTED_IMPORT_HINT.into());
}
None
}
/// Parse one `bind` / `target` pair from a nested import map entry.
pub fn parse_import_binding(bind: &str, target: &str) -> Result<ImportLine> {
if bind.is_empty() || !is_simple_bind_name(bind) {
bail!("invalid import bind `{bind}`");
}
if target.is_empty() || target.contains('`') || target.contains(char::is_whitespace) {
bail!("invalid import target `{target}`");
}
if target.ends_with(".mq.md") {
return Ok(ImportLine::File(Import {
path: target.to_string(),
bind: bind.to_string(),
}));
}
let path: Vec<String> = target
.split('.')
.map(|s| s.trim().to_string())
.collect();
if path.len() < 2 || path.iter().any(|p| p.is_empty() || !is_simple_bind_name(p)) {
bail!(
"import target `{target}` must be a `.mq.md` path or dotted member path (e.g. `time.format`)"
);
}
Ok(ImportLine::Member(Use {
path,
bind: bind.to_string(),
}))
}
fn push_import_line(
imports: &mut Vec<Import>,
uses: &mut Vec<Use>,
entry: ImportLine,
span: Span,
) -> Result<()> {
match entry {
ImportLine::File(imp) => {
if imports.iter().any(|i| i.bind == imp.bind) || uses.iter().any(|u| u.bind == imp.bind)
{
return Err(bail_at(
None,
span,
format!("duplicate import bind `{}`", imp.bind),
));
}
imports.push(imp);
}
ImportLine::Member(u) => {
if imports.iter().any(|i| i.bind == u.bind) || uses.iter().any(|x| x.bind == u.bind) {
return Err(bail_at(
None,
span,
format!("duplicate import bind `{}`", u.bind),
));
}
uses.push(u);
}
}
Ok(())
}
/// Format an import entry as the catalog display string `import bind:target`.
pub fn format_import_display(line: &ImportLine) -> String {
match line {
ImportLine::File(imp) => format!("import {}:{}", imp.bind, imp.path),
ImportLine::Member(u) => format!("import {}:{}", u.bind, u.path.join(".")),
}
}
/// Scan frontmatter for nested `import:` / `导入:` entries (soft; skips legacy / errors).
pub fn scan_frontmatter_imports(source: &str) -> Vec<ImportLine> {
let source = source.strip_prefix('\u{feff}').unwrap_or(source);
let lines: Vec<&str> = source.lines().collect();
if lines.first().map(|l| l.trim()) != Some("---") {
return Vec::new();
}
let mut out = Vec::new();
let mut i = 1usize;
while i < lines.len() {
let t = lines[i].trim();
if t == "---" {
break;
}
if let Some((key, rest)) = split_frontmatter_key(t) {
if (key == "import" || key == "导入") && rest.is_empty() {
i += 1;
while i < lines.len() {
let raw = lines[i].trim_end_matches(['\r', '\n']);
let bt = raw.trim();
if bt == "---" {
break;
}
if bt.is_empty() {
i += 1;
continue;
}
if !raw.starts_with(' ') && !raw.starts_with('\t') {
break;
}
let content = strip_yaml_indent(raw);
if let Some((bind_raw, target_raw)) = content.split_once(':') {
if let Ok(entry) =
parse_import_binding(bind_raw.trim(), target_raw.trim())
{
out.push(entry);
}
}
i += 1;
}
continue;
}
}
i += 1;
}
out
}
fn is_simple_bind_name(s: &str) -> bool {
is_simple_type_name(s)
}
/// Parse a catalog-style `import bind:path` display string, or bare `bind:path`.
pub fn parse_import_spec(line: &str) -> Option<Import> {
let t = line.trim();
let body = if t.starts_with("import")
&& t.get(6..)
.is_some_and(|s| s.starts_with(|c: char| c.is_whitespace()))
{
t[6..].trim()
} else if let Some(a) = t.strip_prefix("导入") {
let a = a.trim();
if a.is_empty() || a.starts_with(':') {
return None;
}
a
} else {
t
};
let (bind, target) = body.split_once(':')?;
match parse_import_binding(bind.trim(), target.trim()).ok()? {
ImportLine::File(imp) => Some(imp),
ImportLine::Member(_) => None,
}
}
/// Rejected API: old one-liner always errors (kept for callers that still probe lines).
pub fn parse_import_line(trimmed: &str) -> Result<Option<ImportLine>> {
if is_legacy_import_oneliner(trimmed) {
bail!("{NESTED_IMPORT_HINT}");
}
Ok(None)
}
fn is_heading(trimmed: &str) -> bool {
parse_heading(trimmed).is_some()
}
fn is_frame(trimmed: &str) -> bool {
if trimmed.len() < 3 {
return false;
}
// Empty returns `**` / `****` are not frames.
if is_empty_return_marker(trimmed) {
return false;
}
trimmed.chars().all(|c| c == '-') || trimmed.chars().all(|c| c == '*')
}
/// `****` or `**` + whitespace only + `**`, or whole-line `**` (v0.3 empty italic).
fn is_empty_return_marker(trimmed: &str) -> bool {
if trimmed == "**" {
return true;
}
is_empty_bold_return(trimmed)
}
/// `****` or `**` + whitespace only + `**`.
fn is_empty_bold_return(trimmed: &str) -> bool {
if !(trimmed.starts_with("**") && trimmed.ends_with("**") && trimmed.len() >= 4) {
return false;
}
trimmed[2..trimmed.len() - 2].trim().is_empty()
}
fn stmt_from_italic_return(inner: &str, span: Span) -> Result<Stmt> {
let inner = inner.trim();
let value = if inner.is_empty()
|| inner == "None"
|| inner == "无"
|| inner == "空"
{
Expr::Literal(Literal::None)
} else {
parse_expr_prefer_var(inner)?
};
Ok(Stmt::Return { value, span })
}
/// Merge declarations into params: promote names that are read in the body (or have defaults).
///
/// Design §8.2: a declaration is a backtick mention or the first bold assignment
/// to that name. Elevate only when an executable read cannot be satisfied by a prior
/// local assign that does not itself read the name (e.g. `score = 1` is local;
/// `n = n + 1` still needs external `n`).
// ---------- 契约提取(T2.1 · 渐进式契约 / 标注类型) ----------
//
// 未绑定文档表 → 契约;**位置 + 形状**双重判定;在升参推断之前执行。
// 契约表从 body 移除(元数据永不执行、不污染升参推断);
// 非契约表(普通文档/数据表,含一切**绑定**表)原样保留 ⇒ 无契约文件零回归。
/// 从表头行起收集连续 `|` 行作为契约原文(诊断 `doc_quote`)。
fn table_quote(lines: &[ClassifiedLine], start_line: u32) -> (u32, Vec<String>) {
let Some(mut idx) = (0..lines.len()).find(|&i| lines[i].line_no == start_line) else {
return (start_line, Vec::new());
};
let mut quote = Vec::new();
let mut end = start_line;
while idx < lines.len() && lines[idx].text.trim().starts_with('|') {
quote.push(lines[idx].text.trim_end().to_string());
end = lines[idx].line_no;
idx += 1;
}
(end, quote)
}
/// 是否「字段契约形状」的未绑定文档表(紧邻判定的透明跳过用)。
fn is_fields_contract_stmt(stmt: &Stmt, lines: &[ClassifiedLine]) -> bool {
let Stmt::Expr { value: Expr::Map(pairs), span } = stmt else {
return false;
};
let (end_line, quote) = table_quote(lines, span.line);
matches!(
crate::contract::parse_contract_table(pairs, span.line, end_line, quote),
Some(Ok(ref c)) if !c.fields.is_empty()
)
}
/// 紧邻绑定名:跳过连续的字段契约表后,下一条是不是 `` `名` = `` 绑定。
fn next_binding_name(body: &[Stmt], start: usize, lines: &[ClassifiedLine]) -> Option<String> {
let mut j = start;
while j < body.len() && is_fields_contract_stmt(&body[j], lines) {
j += 1;
}
match body.get(j) {
Some(Stmt::Assign { name, .. }) => Some(name.clone()),
_ => None,
}
}
fn empty_like(piece: &crate::contract::Contract) -> crate::contract::Contract {
crate::contract::Contract {
params: Vec::new(),
returns: None,
fields: Vec::new(),
start_line: piece.start_line,
end_line: piece.end_line,
quote: Vec::new(),
}
}
/// 合并契约块;重复行/重复表 → `contract.duplicate` 诊断(防两份契约打架)。
fn merge_piece(
dst: &mut Option<crate::contract::Contract>,
piece: crate::contract::Contract,
unit: &str,
span: Span,
) -> Result<()> {
match dst {
None => *dst = Some(piece),
Some(slot) => {
if let Err(m) = crate::contract::merge_contract(slot, piece.clone()) {
return Err(piece
.diagnostic(
"contract.duplicate",
unit,
m,
"删除重复契约表,只保留一份".to_string(),
None,
span,
)
.into());
}
}
}
Ok(())
}
fn extract_function_contract(fun: &mut Function, lines: &[ClassifiedLine]) -> Result<()> {
let body = std::mem::take(&mut fun.body);
let mut fun_contract: Option<crate::contract::Contract> = None;
let mut var_contracts: std::collections::HashMap<String, crate::contract::Contract> =
std::collections::HashMap::new();
let mut keep: Vec<Stmt> = Vec::with_capacity(body.len());
// 「函数体首个可执行行之前」:未绑定表(Map/List 形状的 `Stmt::Expr`)不算可执行行。
let mut prefix_zone = true;
let mut i = 0usize;
while i < body.len() {
let stmt = &body[i];
let (pairs, span) = match stmt {
Stmt::Expr {
value: Expr::Map(pairs),
span,
} => (pairs, *span),
other => {
if !matches!(other, Stmt::Expr { value: Expr::List(_), .. }) {
prefix_zone = false;
}
keep.push(other.clone());
i += 1;
continue;
}
};
let (end_line, quote) = table_quote(lines, span.line);
let Some(parsed) = crate::contract::parse_contract_table(pairs, span.line, end_line, quote)
else {
// 非契约形状:先试定理表(ADR 0010),再按普通表保留。
match crate::contract::parse_claim_table(pairs, span.line) {
// 合法定理表:只在「首个可执行行之前」生效;提取后从 body 移除。
// 其余位置仍是普通表,由 `check --proof` 报 proof.claim_misplaced。
Some(Ok(rows)) if prefix_zone => {
fun.claims.extend(rows);
i += 1;
continue;
}
// 畸形/歧义/错位的定理形表:保持普通表(默认关),
// `check --proof` 重扫 body 时报 malformed/ambiguous/misplaced。
_ => {
keep.push(stmt.clone());
i += 1;
continue;
}
}
};
let piece = parsed?; // 契约形状但畸形 → 必产诊断(contract.malformed)
let is_fn_contract = !piece.params.is_empty() || piece.returns.is_some();
if is_fn_contract {
// 形参/返回表只在「首个可执行行之前」生效,否则视为普通表。
if !prefix_zone {
keep.push(stmt.clone());
i += 1;
continue;
}
merge_piece(&mut fun_contract, piece, &fun.name, span)?;
i += 1;
continue;
}
// 字段表:紧邻 `` `名` = `` 绑定之前 → 集合契约;对象体首成员前 → 对象字段契约。
if let Some(name) = next_binding_name(&body, i + 1, lines) {
let mut slot = Some(
var_contracts
.remove(&name)
.unwrap_or_else(|| empty_like(&piece)),
);
merge_piece(&mut slot, piece, &name, span)?;
var_contracts.insert(name, slot.unwrap());
i += 1;
continue;
}
if prefix_zone && fun.is_object() {
merge_piece(&mut fun_contract, piece, &fun.name, span)?;
i += 1;
continue;
}
// 不在允许位置 → 不是契约,原样保留。
keep.push(stmt.clone());
i += 1;
}
fun.body = keep;
fun.contract = fun_contract;
fun.var_contracts = var_contracts;
Ok(())
}
fn merge_inferred_params(
fun: &mut Function,
prose_decls: &[(String, Option<String>, u32)],
inherited: &HashSet<String>,
) -> Result<()> {
use std::collections::HashSet;
let mut needs_input = HashSet::new();
// Captured entry/object bindings are available before the child body.
// An explicit prose input still shadows an outer binding of the same name.
let explicit: HashSet<_> = prose_decls.iter().map(|(name, _, _)| name.clone()).collect();
let mut bound: HashSet<_> = inherited.difference(&explicit).cloned().collect();
let mut assign_decls = Vec::new();
// Defaults execute before the body. Reads used only there still require
// declared inputs; later body assignments cannot satisfy those reads.
for param in &fun.params {
if let Some(default)=&param.default { collect_reads_expr(default,&mut needs_input); }
}
for (_,default,_) in prose_decls {
if let Some(default)=default {
let parsed=parse_expr_prefer_var(default).or_else(|_|parse_value_or_interp(default))?;
collect_reads_expr(&parsed,&mut needs_input);
}
}
collect_names_needing_input(
&fun.body,
&mut bound,
&mut needs_input,
&HashSet::new(),
&mut assign_decls,
);
needs_input.retain(|name| !inherited.contains(name) || explicit.contains(name));
// Declaration order is source order: backtick mentions and first assignment
// left-hand sides. An assignment promotes only when its right-hand side (or a
// later read) still needs an external value.
let mut events: Vec<(u32, usize, String, Option<String>)> = Vec::new();
for (i, (name, default_txt, line)) in prose_decls.iter().enumerate() {
events.push((*line, i, name.clone(), default_txt.clone()));
}
let prose_n = events.len();
for (j, (name, line)) in assign_decls.iter().enumerate() {
if prose_decls.iter().any(|(n, _, _)| n == name) {
continue;
}
if !needs_input.contains(name) {
continue;
}
events.push((*line, prose_n + j, name.clone(), None));
}
events.sort_by_key(|e| (e.0, e.1));
for (line, _ord, name, default_txt) in events {
if name == "self" || name == "自" {
continue;
}
if fun.params.iter().any(|p| p.name == name) {
continue;
}
let has_default = default_txt.is_some();
// Elevate: defaulted always; or executable read that needs an external input.
if !has_default && !needs_input.contains(&name) {
if !bound.contains(&name) {
fun.dead_binds.push(name);
}
continue; // dead bind or pure local
}
let default = if let Some(txt) = default_txt {
Some(parse_expr_prefer_var(&txt).or_else(|_| parse_value_or_interp(&txt))?)
} else {
None
};
fun.params.push(Param {
name,
span:Span::new(line,1),
default,
inferred: true,
});
}
Ok(())
}
/// Walk body in order. `bound` = names already assigned locally without needing input.
/// On read of unbound name → needs input. On assign, RHS reads are checked first
/// (so `n = n + 1` marks `n` as needing input before binding).
/// `assign_decls` records the first assignment of each name, which §8.2 treats as
/// a declaration when no backtick mention came first. Loop items are not declarations.
fn collect_names_needing_input(
stmts: &[Stmt],
bound: &mut std::collections::HashSet<String>,
needs: &mut std::collections::HashSet<String>,
loop_items: &std::collections::HashSet<String>,
assign_decls: &mut Vec<(String, u32)>,
) {
for s in stmts {
match s {
Stmt::Assign { name, value, span, .. } => {
let mut rhs_reads = std::collections::HashSet::new();
collect_reads_expr(value, &mut rhs_reads);
for r in &rhs_reads {
if !bound.contains(r) && !loop_items.contains(r) {
needs.insert(r.clone());
}
}
if !loop_items.contains(name)
&& !assign_decls.iter().any(|(n, _)| n == name)
{
assign_decls.push((name.clone(), span.line));
}
bound.insert(name.clone());
}
Stmt::Return { value, .. } => {
let mut reads = std::collections::HashSet::new();
collect_reads_expr(value, &mut reads);
for r in reads {
if !bound.contains(&r) && !loop_items.contains(&r) {
needs.insert(r);
}
}
}
Stmt::Call { call, .. } => {
let mut reads = std::collections::HashSet::new();
collect_reads_call(call, &mut reads);
for r in reads {
if !bound.contains(&r) && !loop_items.contains(&r) {
needs.insert(r);
}
}
}
Stmt::Expr { value, .. } => {
let mut reads = std::collections::HashSet::new();
collect_reads_expr(value, &mut reads);
for r in reads {
if !bound.contains(&r) && !loop_items.contains(&r) {
needs.insert(r);
}
}
}
Stmt::Branch { arms, .. } => {
let has_else = arms.iter().any(|a| a.condition.is_none());
let mut common: Option<std::collections::HashSet<String>> = None;
for a in arms {
if let Some(c) = &a.condition {
let mut reads = std::collections::HashSet::new();
collect_reads_expr(c, &mut reads);
for r in reads {
if !bound.contains(&r) && !loop_items.contains(&r) {
needs.insert(r);
}
}
}
let mut arm_bound = bound.clone();
collect_names_needing_input(
&a.body,
&mut arm_bound,
needs,
loop_items,
assign_decls,
);
if has_else {
common = Some(match common {
None => arm_bound,
Some(prev) => prev.intersection(&arm_bound).cloned().collect(),
});
}
}
if let Some(c) = common {
for n in c {
bound.insert(n);
}
}
}
Stmt::While {
condition, body, ..
} => {
let mut reads = std::collections::HashSet::new();
collect_reads_expr(condition, &mut reads);
for r in reads {
if !bound.contains(&r) && !loop_items.contains(&r) {
needs.insert(r);
}
}
collect_names_needing_input(body, bound, needs, loop_items, assign_decls);
}
Stmt::ForEach {
item,
collection,
body,
..
} => {
if !bound.contains(collection) && !loop_items.contains(collection) {
needs.insert(collection.clone());
}
let mut nested = loop_items.clone();
nested.insert(item.clone());
collect_names_needing_input(body, bound, needs, &nested, assign_decls);
}
}
}
}
fn collect_reads_call(call: &crate::ast::CallExpr, reads: &mut std::collections::HashSet<String>) {
if let Some(recv) = &call.receiver {
reads.insert(recv.clone());
}
// Callee name itself is not a variable read.
for a in &call.args {
match a {
crate::ast::Arg::Positional(e) | crate::ast::Arg::Named { value: e, .. } => {
collect_reads_expr(e, reads);
}
}
}
}
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());
}
Expr::Call(c) => collect_reads_call(c, reads),
Expr::Binary { left, right, .. } => {
collect_reads_expr(left, reads);
collect_reads_expr(right, reads);
}
Expr::Unary { expr, .. } => collect_reads_expr(expr, reads),
Expr::Index { base, label } => {
collect_reads_expr(base, reads);
if let IndexKey::Var(n) = label {
reads.insert(n.clone());
}
}
Expr::List(xs) => {
for x in xs {
collect_reads_expr(x, reads);
}
}
Expr::Map(entries) => {
for (_, v) in entries {
collect_reads_expr(v, reads);
}
}
Expr::Interp(parts) => {
for p in parts {
match p {
crate::ast::InterpPart::Var(n) => {
reads.insert(n.clone());
}
crate::ast::InterpPart::Index { base, .. } => {
reads.insert(base.clone());
}
crate::ast::InterpPart::Lit(_) => {}
}
}
}
Expr::Literal(_) | Expr::Formula(_) | Expr::Code(_) => {}
}
}
fn is_ordered_branch(trimmed: &str) -> bool {
strip_ordered(trimmed).is_some()
}
/// Leading `N` in an ordered-list item `N. …` (1-based Markdown marker).
fn ordered_item_number(trimmed: &str) -> Option<u32> {
let mut chars = trimmed.chars();
let mut n: u32 = 0;
let mut saw_digit = false;
while let Some(c) = chars.next() {
if let Some(d) = c.to_digit(10) {
saw_digit = true;
n = n.saturating_mul(10).saturating_add(d);
continue;
}
if c == '.' && saw_digit {
return Some(n);
}
return None;
}
None
}
fn strip_ordered(trimmed: &str) -> Option<&str> {
let mut chars = trimmed.chars();
let mut saw_digit = false;
while let Some(c) = chars.next() {
if c.is_ascii_digit() {
saw_digit = true;
continue;
}
if c == '.' && saw_digit {
return Some(chars.as_str().trim_start());
}
return None;
}
None
}
fn indent_of(text: &str) -> usize {
text.chars()
.take_while(|c| *c == ' ' || *c == '\t')
.map(|c| if c == '\t' { 4 } else { 1 })
.sum()
}
fn parse_table_cell(raw: &str, line: u32) -> Result<Expr> {
parse_call_arg_value(raw).map_err(|e| {
Diagnostic::new(
None,
Span { line, col: 1 },
format!("table cell: {e}"),
)
.into()
})
}
/// First-column header that opts into row-oriented records (`List` of `Map`).
fn is_row_table_marker(header: &str) -> bool {
matches!(header.trim(), "@" | "行" | "row")
}
fn build_row_oriented_table(
header: Vec<String>,
header_line: u32,
data_rows: Vec<(u32, Vec<String>)>,
) -> Result<Expr> {
if header.len() < 2 {
return Err(Diagnostic::new(
None,
Span {
line: header_line,
col: 1,
},
"row-oriented table needs field columns after `@` / `行` / `row`",
)
.into());
}
let fields: Vec<String> = header[1..].to_vec();
let mut seen = std::collections::HashSet::new();
for key in &fields {
if !seen.insert(key.clone()) {
return Err(Diagnostic::new(
None,
Span {
line: header_line,
col: 1,
},
format!("duplicate table header `{key}`"),
)
.into());
}
}
let mut rows = Vec::with_capacity(data_rows.len());
for (line_no, cells) in data_rows {
let mut pairs = Vec::with_capacity(fields.len());
for (i, key) in fields.iter().enumerate() {
// Skip marker column (index 0); fields start at column 1.
let raw = cells.get(i + 1).map(|s| s.as_str()).unwrap_or("");
pairs.push((key.clone(), parse_table_cell(raw, line_no)?));
}
rows.push(Expr::Map(pairs));
}
Ok(Expr::List(rows))
}
fn split_table_row(line: &str) -> Vec<String> {
let t = line.trim();
let t = t.strip_prefix('|').unwrap_or(t);
let t = t.strip_suffix('|').unwrap_or(t);
// GFM escaped pipes belong to a cell, including inside a quoted value.
// Preserve other escapes for the expression parser (e.g. \n in text).
let mut cells = Vec::new();
let mut cell = String::new();
let mut chars = t.chars().peekable();
while let Some(ch) = chars.next() {
if ch == '\\' {
match chars.peek().copied() {
Some('|') => {
chars.next();
cell.push('|');
}
Some('\\') => {
chars.next();
cell.push('\\');
cell.push('\\');
}
_ => cell.push(ch),
}
} else if ch == '|' {
cells.push(cell.trim().to_string());
cell.clear();
} else {
cell.push(ch);
}
}
cells.push(cell.trim().to_string());
cells
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ast::Stmt;
#[test]
fn parse_formula_meta_var_standalone() {
let src = "# main\n\n$$\n% marqdo: var=f\nx^2 - 2\n$$\n";
let m = parse_source(src).unwrap();
match &m.functions[0].body[0] {
Stmt::Assign { name, value, .. } => {
assert_eq!(name, "f");
assert!(matches!(value, Expr::Formula(_)));
}
other => panic!("expected formula assign, got {other:?}"),
}
}
#[test]
fn parse_formula_meta_conflicts_with_assign() {
let src = "# main\n\n`f` =\n$$\n% marqdo: var=g\nx\n$$\n";
let err = parse_source(src).unwrap_err().to_string();
assert!(
err.contains("conflicts") || err.contains("var=g"),
"{err}"
);
}
#[test]
fn parse_foreach_narrative_zh_en() {
let src = "# main\n\n- 对`xs`的每一项`项`\n > print text=`项`\n\n- for each `item` in `ys`\n > print text=`item`\n";
let m = parse_source(src).unwrap();
match &m.functions[0].body[0] {
Stmt::ForEach { item, collection, .. } => {
assert_eq!(item, "项");
assert_eq!(collection, "xs");
}
other => panic!("zh foreach: {other:?}"),
}
match &m.functions[0].body[1] {
Stmt::ForEach { item, collection, .. } => {
assert_eq!(item, "item");
assert_eq!(collection, "ys");
}
other => panic!("en foreach: {other:?}"),
}
}
#[test]
fn branch_arm_prose_stays_inside_arm() {
let src = include_str!("../../tests/markup-v03/branch-arm-prose.mq.md");
let m = parse_source(src).unwrap();
let main = &m.functions[0];
let branches: Vec<_> = main
.body
.iter()
.filter(|s| matches!(s, Stmt::Branch { .. }))
.collect();
assert_eq!(
branches.len(),
1,
"expected one Branch, body={:?}",
main.body
);
match &main.body[1] {
Stmt::Branch { arms, .. } => {
assert_eq!(arms.len(), 2, "arms={arms:?}");
assert!(
!arms[0].body.is_empty(),
"then arm must contain prose stmts: {:?}",
arms[0].body
);
assert!(
!arms[1].body.is_empty(),
"else arm must contain prose stmts: {:?}",
arms[1].body
);
}
other => panic!("expected Branch as body[1] after assign, got {other:?}"),
}
// No Call/Assign print siblings after the branch
assert!(
!main.body.iter().skip(2).any(|s| matches!(s, Stmt::Call { .. } | Stmt::Assign { .. })),
"prose escaped branch: {:?}",
main.body
);
}
#[test]
fn parse_hello() {
let src = include_str!("../../tests/structure/hello.mq.md");
let m = parse_source(src).unwrap();
assert_eq!(m.functions.len(), 1);
assert_eq!(m.functions[0].name, "Hello World");
assert_eq!(m.functions[0].body.len(), 1);
assert!(matches!(m.functions[0].body[0], Stmt::Call { .. }));
}
#[test]
fn parse_index() {
let src = include_str!("../../tests/structure/nested-call.mq.md");
let m = parse_source(src).unwrap();
assert!(m.imports.is_empty());
let main = m.functions.iter().find(|f| f.name == "main").unwrap();
assert_eq!(main.children.len(), 1);
assert_eq!(main.children[0].name, "问候");
assert_eq!(main.children[0].params[0].name, "谁");
}
#[test]
fn parse_optional_param_default() {
let src = "# main\n\n## f\n + `a`\n + `b`=Hi\n\n> print text=`a`\n";
let m = parse_source(src).unwrap();
let f = &m.functions[0].children[0];
assert_eq!(f.params.len(), 2);
assert_eq!(f.params[0].name, "a");
assert_eq!(f.params[1].name, "b");
assert!(matches!(
f.params[1].default,
Some(Expr::Literal(Literal::Text(ref s))) if s == "Hi"
));
}
#[test]
fn parse_foreach_backtick_ids() {
let src = "# main\n\n- [`x`](`xs`)\n > print text=`x`\n";
let m = parse_source(src).unwrap();
match &m.functions[0].body[0] {
Stmt::ForEach { item, collection, .. } => {
assert_eq!(item, "x");
assert_eq!(collection, "xs");
}
other => panic!("expected foreach, got {other:?}"),
}
}
#[test]
fn parse_foreach_bare_ids() {
let src = "# main\n\n- [x](xs)\n > print text=`x`\n";
let m = parse_source(src).unwrap();
match &m.functions[0].body[0] {
Stmt::ForEach { item, collection, .. } => {
assert_eq!(item, "x");
assert_eq!(collection, "xs");
}
other => panic!("expected foreach, got {other:?}"),
}
}
#[test]
fn parse_foreach_mixed_ticks() {
let src = "# main\n\n- [果](`篮子`)\n > print text=`果`\n";
let m = parse_source(src).unwrap();
match &m.functions[0].body[0] {
Stmt::ForEach { item, collection, .. } => {
assert_eq!(item, "果");
assert_eq!(collection, "篮子");
}
other => panic!("expected foreach, got {other:?}"),
}
}
#[test]
fn parse_bold_assign_italic_return() {
let src = "# main\n\n**answer = 1**\n*answer*\n";
let m = parse_source(src).unwrap();
match &m.functions[0].body[0] {
Stmt::Assign { name, value, .. } => {
assert_eq!(name, "answer");
assert!(matches!(value, Expr::Literal(Literal::Int(1))));
}
other => panic!("expected assign, got {other:?}"),
}
match &m.functions[0].body[1] {
Stmt::Return { value, .. } => {
assert!(matches!(value, Expr::Var(n) if n == "answer"));
}
other => panic!("expected return, got {other:?}"),
}
}
#[test]
fn parse_local_assign_not_inferred_param() {
let src = r#"## soft
Candidates may include lexical `score`.
**score = 1**
1. `score`
**_ = score**
2. *
**_ = 0**
---
# main
> soft
"#;
let m = parse_source(src).unwrap();
let soft = m.functions.iter().find(|f| f.name == "soft").unwrap();
assert!(
soft.params.iter().all(|p| p.name != "score"),
"score must stay local, params={:?}",
soft.params.iter().map(|p| &p.name).collect::<Vec<_>>()
);
}
#[test]
fn parse_prose_inc() {
let src = "## 加一\n\n输入`n`。**n=n+1**返回*n*。\n\n# main\n\n**r = 加一 1**\n**print text=r**\n";
let m = parse_source(src).unwrap();
let add = m.functions.iter().find(|f| f.name == "加一").unwrap();
assert_eq!(add.params.len(), 1);
assert_eq!(add.params[0].name, "n");
assert!(add.params[0].inferred);
let dump = crate::ast::format_ast_dump("t.mq.md", &m);
assert!(dump.contains("params=[n inferred]"), "{dump}");
assert!(!dump.contains("dead="), "{dump}");
}
#[test]
fn parse_bare_inc_is_required_param() {
// §8.2: the first bold assignment is a declaration. The RHS reads `n`
// before the bind, so `n` is a required parameter even without a backtick.
let src = "## inc\n\n**n = n + 1**\n*n*\n\n# main\n\n**print text=\"ok\"**\n";
let m = parse_source(src).unwrap();
let inc = m.functions.iter().find(|f| f.name == "inc").unwrap();
assert_eq!(
inc.params.iter().map(|p| p.name.as_str()).collect::<Vec<_>>(),
["n"]
);
assert!(inc.params[0].default.is_none());
assert!(inc.params[0].inferred);
}
#[test]
fn parse_dead_binds_visible_in_ast_dump() {
let src = include_str!("../../tests/markup-v03/dead-bind.mq.md");
let m = parse_source(src).unwrap();
let echo = m.functions.iter().find(|f| f.name == "回声").unwrap();
assert_eq!(echo.params.iter().map(|p| p.name.as_str()).collect::<Vec<_>>(), ["题干"]);
assert!(echo.dead_binds.contains(&"Markdown".to_string()), "{:?}", echo.dead_binds);
assert!(echo.dead_binds.contains(&"GFM".to_string()), "{:?}", echo.dead_binds);
let dump = crate::ast::format_ast_dump("t.mq.md", &m);
assert!(dump.contains("dead="), "{dump}");
assert!(dump.contains("Markdown"), "{dump}");
}
#[test]
fn parse_branch_rejects_plus_arm() {
let src = "# main\n\n+ `x` > 0\n > print text=ok\n";
let err = parse_source(src).unwrap_err();
let msg = format!("{err}");
assert!(
msg.contains("unrecognized") || msg.contains("empty branch"),
"{msg}"
);
}
#[test]
fn parse_branch() {
let src = include_str!("../../tests/structure/branch.mq.md");
let m = parse_source(src).unwrap();
let main = &m.functions[0];
assert!(main.body.iter().any(|s| matches!(s, Stmt::Branch { .. })));
}
#[test]
fn consecutive_branches_restart_at_one() {
let m = parse_source(include_str!(
"../../tests/structure/branch-consecutive.mq.md"
))
.unwrap();
let branches: Vec<_> = m.functions[0]
.body
.iter()
.filter(|s| matches!(s, Stmt::Branch { .. }))
.collect();
assert_eq!(
branches.len(),
3,
"expected three Branch stmts, got {:?}",
m.functions[0].body
);
for b in &branches {
match b {
Stmt::Branch { arms, .. } => assert_eq!(arms.len(), 2),
_ => unreachable!(),
}
}
// Arm bodies must hold the prints (not leaked as sibling Calls).
match branches[0] {
Stmt::Branch { arms, .. } => {
assert!(
matches!(arms[0].body[0], Stmt::Call { .. }),
"first arm body={:?}",
arms[0].body
);
}
_ => unreachable!(),
}
}
#[test]
fn consecutive_branches_without_blank_line() {
let src = "# main\n\n1. True\n > print text=A\n2. *\n > print text=skip\n1. True\n > print text=B\n";
let m = parse_source(src).unwrap();
let branches: Vec<_> = m.functions[0]
.body
.iter()
.filter(|s| matches!(s, Stmt::Branch { .. }))
.collect();
assert_eq!(branches.len(), 2, "got {:?}", m.functions[0].body);
match branches[0] {
Stmt::Branch { arms, .. } => assert_eq!(arms.len(), 2),
_ => unreachable!(),
}
}
#[test]
fn parse_formula_assign_fence() {
let src = "# main\n\n`f` =\n$$\nx^2 - 2\n$$\n\n> print text=`f`\n";
let m = parse_source(src).unwrap();
let body = &m.functions[0].body;
match &body[0] {
Stmt::Assign {
name,
value: Expr::Formula(e),
end_line,
..
} => {
assert_eq!(name, "f");
assert_eq!(e.as_display(), "x^2 - 2");
assert!(*end_line > 3, "end_line should cover the fence, got {end_line}");
}
other => panic!("expected formula assign, got {other:?}"),
}
}
#[test]
fn parse_code_assign_fence() {
let src = "# main\n\n`hi` =\n```python\nprint(1)\n```\n\n> print text=ok\n";
let m = parse_source(src).unwrap();
match &m.functions[0].body[0] {
Stmt::Assign {
name,
value: Expr::Code(c),
..
} => {
assert_eq!(name, "hi");
assert_eq!(c.lang, "python");
assert_eq!(c.source, "print(1)");
}
other => panic!("expected code assign, got {other:?}"),
}
}
#[test]
fn branch_else_common_local_is_not_a_param() {
let src = r#"# main
## f
+ `a`=None
1. `a`
**k = a**
2. *
**k = None**
| x |
|---|
| `k` |
"#;
let m = parse_source(src).unwrap();
let f = m
.functions
.iter()
.flat_map(|outer| outer.children.iter())
.find(|f| f.name == "f")
.unwrap();
assert_eq!(
f.params.iter().map(|p| p.name.as_str()).collect::<Vec<_>>(),
["a"],
"{:?}",
f.params
);
}
}
/// 核心表面构造注册表(T1.3)——`(id, Markdown 外形)`。
///
/// **紧邻分类代码维护**;与 `doc/design/core-surface.md` 的 id 列强一致,
/// 由 `tests/core_surface.rs` 守卫:改动任一侧不同步 → CI 红。
/// 新增条目必须走 ADR(`doc/design/layers.md` 准入戒律)。
pub const CORE_CONSTRUCTS: &[(&str, &str)] = &[
// 行构造
("narrative", "无标记文字"),
("blank", "空行"),
("heading-unit", "# / ##"),
("call-line", ">"),
("branch-list", "1. 递增"),
("loop-list", "-"),
("param", "+ `名`"),
("table", "GFM 表"),
("fence", "```lang"),
("hr", "--- / ***"),
("writeback", "<!-- marqdo-out -->"),
// 内联标记
("ident", "`名`"),
("bold-code", "**…**"),
("italic-return", "*…*"),
("empty-return", "*None* / ****"),
("link-index", "[键](集合)"),
("bracket-call", "修饰… [函数] …"),
("footnote-index", "集合[^键]"),
("soft-emphasis", "*仅* / **说明**"),
];
#[cfg(test)]
mod escaped_gfm_cell_tests {
use super::*;
#[test]
fn escaped_pipes_do_not_create_columns() {
assert_eq!(
split_table_row(r#"| "source\|skill" | "line\n" |"#),
[r#""source|skill""#, r#""line\n""#]
);
assert_eq!(split_table_row(r"| a\\| b |"), [r"a\\", "b"]);
let module = parse_source(
"## value\n\n`items` =\n\n| line |\n|---|\n| \"source\\|skill\" |\n\n*items*\n",
)
.unwrap();
assert!(format!("{:?}", module.functions[0].body).contains("source|skill"));
}
}
#[cfg(test)]
mod lexical_input_tests {
use super::*;
#[test]
fn child_updates_capture_existing_entry_state_without_extra_inputs() {
let source="# main\n\n**count = 0**\n\n## bump\n\nWe **count = count + 1** and return *count*.\n";
let module=parse_source(source).unwrap();
assert!(module.functions[0].children[0].params.is_empty());
}
#[test]
fn explicit_prose_inputs_can_shadow_parent_bindings() {
let source="# main\n\n**count = 0**\n\n## add\n\nUse `count` for this independent call.\nReturn *(count + 1)*.\n";
let module=parse_source(source).unwrap();
let params=&module.functions[0].children[0].params;
assert_eq!(params.len(),1);
assert_eq!(params[0].name,"count");
}
#[test]
fn reading_a_loop_item_in_a_branch_does_not_promote_a_later_local() {
let source="## select\n\nUse `values`.\n- [Inspect values](for values as item)\n 1. `item` != \"\"\n We **output = item**.\n\nWe **item = \"done\"** and return *item*.\n";
let module=parse_source(source).unwrap();
let params=&module.functions[0].params;
assert_eq!(params.len(),1);
assert_eq!(params[0].name,"values");
}
}