//! 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 { 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 { 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 { 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, Vec, 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, uses: &mut Vec, ) -> 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) -> Result { 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, 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 { 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 { 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> { // `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 = 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)> { 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 = 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> { 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 { self.skip_noise(); let mut header: Vec = Vec::new(); let mut header_line: u32 = 1; let mut data_rows: Vec<(u32, Vec)> = 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 { 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 { 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(); // `` 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> { 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> { 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> { let mut meta_var: Option = 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=".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 { 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 { 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 { 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 { 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()) } /// `` 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(); // `遍历 为 ` (English `for as ` 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> { 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 { 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)> { 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 { 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::>() .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 { 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 { 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 = 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, uses: &mut Vec, 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 { 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 { 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> { 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 { 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) { 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 { 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, 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 = None; let mut var_contracts: std::collections::HashMap = std::collections::HashMap::new(); let mut keep: Vec = 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, u32)], inherited: &HashSet, ) -> 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)=¶m.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)> = 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, needs: &mut std::collections::HashSet, loop_items: &std::collections::HashSet, 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> = 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) { 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) { 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 { 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 { 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, header_line: u32, data_rows: Vec<(u32, Vec)>, ) -> Result { 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 = 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 { 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::>() ); } #[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::>(), ["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::>(), ["题干"]); 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::>(), ["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", ""), // 内联标记 ("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"); } }