Files
marqdo/src/parse/mod.rs
T
cflmyandCursor ecc92f473a Unify frontmatter imports as import bind:target and drop > imports.
`import json:lib/json.mq.md` binds file libraries; `import fmt:time.format`
binds member short names (replaces `> use`). Legacy `> path.mq.md` / `> use`
now hard-error with a hint. Migrates repo docs, skills, ext, lib, public, examples,
man-test and tests; adds a negative gold and updates view/catalog rendering.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-08-13 10:03:21 +08:00

1369 lines
43 KiB
Rust

//! Line-oriented recursive descent → AST (no Bison).
mod expr;
pub use expr::{
parse_call_after_gt, parse_call_arg_value, parse_expr, parse_expr_prefer_var,
parse_value_or_interp,
};
use anyhow::{bail, Result};
use crate::ast::{
BranchArm, Expr, Function, Import, Literal, Module, Stmt, Use,
};
use crate::diagnostics::{bail_at, Diagnostic, Span};
use crate::lex::{classify_source, ClassifiedLine, LineKind};
use crate::parse::expr::parse_call_after_gt as call_after_gt;
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);
parse_classified(&lines)
}
pub fn parse_classified(lines: &[ClassifiedLine]) -> Result<Module> {
let mut cur = Cursor::new(lines);
let (imports, uses) = cur.parse_frontmatter()?;
let mut functions = Vec::new();
while cur.skip_noise() {
let Some(line) = cur.peek() else { break };
let trimmed = line.text.trim();
if is_heading(trimmed) {
functions.push(cur.parse_function(1)?);
} 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);
}
}
Ok(Module {
imports,
uses,
functions,
import_modules: std::collections::HashMap::new(),
})
}
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 + comment; return true if a line remains.
fn skip_noise(&mut self) -> bool {
while let Some(l) = self.peek() {
match l.kind {
LineKind::Blank | LineKind::Comment | LineKind::Writeback => {
self.i += 1;
}
LineKind::Code => return true,
}
}
false
}
fn parse_frontmatter(&mut self) -> Result<(Vec<Import>, Vec<Use>)> {
let mut imports = Vec::new();
let mut uses = Vec::new();
if !self.skip_noise() {
return Ok((imports, uses));
}
let Some(first) = self.peek() else {
return Ok((imports, uses));
};
if first.text.trim() != "---" {
return Ok((imports, uses));
}
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));
}
match parse_import_line(t) {
Ok(Some(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);
}
Ok(Some(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(None) => {}
Err(e) => return Err(bail_at(None, span, e.to_string())),
}
self.bump();
}
Ok((imports, uses))
}
fn parse_function(&mut self, min_level: u8) -> 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,
};
// Parameter zone: indented `- name` pure identifiers.
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 {
fun.children.push(self.parse_function(level + 1)?);
continue;
}
break;
}
if let Some(param) = parse_param_line(trimmed) {
// Only accept as param before any body stmt (params first).
if fun.body.is_empty() {
fun.params.push(param);
self.bump();
continue;
}
}
break;
}
// Body until next heading at level <= ours, or explicit end (--- / *** / empty **).
while self.skip_noise() {
let Some(l) = self.peek() else { break };
let trimmed = l.text.trim();
// Empty bold return ends the function body.
if is_empty_bold_return(trimmed) {
let span = Span {
line: l.line_no,
col: 1,
};
self.bump();
fun.body.push(Stmt::Return {
value: Expr::Literal(Literal::None),
span,
});
break;
}
// --- / *** at function body top level ends the function (no return).
if is_frame(trimmed) {
self.bump();
break;
}
if is_heading(trimmed) {
let (nl, _) = parse_heading(trimmed).unwrap();
if nl > level {
fun.children.push(self.parse_function(level + 1)?);
continue;
}
break;
}
// Nested params mid-body shouldn't happen; treat `-` as control flow.
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;
}
fun.body.push(self.parse_simple_stmt()?);
}
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) {
bail!("{span}: unexpected frame line as statement");
}
if trimmed.starts_with("$$") {
bail!(
"{span}: formula fence must follow an empty assignment (`name` =); \
`$$:name` binding was removed"
);
}
// Bold return **…** (empty inner → None)
if trimmed.starts_with("**") && trimmed.ends_with("**") && trimmed.len() >= 4 {
let inner = &trimmed[2..trimmed.len() - 2];
let value = if inner.trim().is_empty() {
Expr::Literal(Literal::None)
} else {
parse_expr_prefer_var(inner)?
};
return Ok(Stmt::Return { value, span });
}
// Italic statement *…*
if trimmed.starts_with('*') && trimmed.ends_with('*') && !trimmed.starts_with("**") {
let inner = &trimmed[1..trimmed.len() - 1];
return self.parse_italic_assign(inner, span);
}
// Call >
if trimmed.starts_with('>') {
let call = call_after_gt(trimmed[1..].trim())?;
return Ok(Stmt::Call { call, span });
}
// Bare assign `` `x` = … `` possibly followed by formula fence or table
if trimmed.starts_with('`') {
if let Some(stmt) = self.parse_backtick_assign(trimmed, span.clone())? {
return Ok(stmt);
}
}
Err(Diagnostic::new(None, span, format!("unrecognized statement: {trimmed}")).into())
}
fn parse_italic_assign(&mut self, inner: &str, span: Span) -> Result<Stmt> {
let Some((name, rhs)) = split_assign_inner(inner) else {
bail!("{span}: italic statement must be an assignment (name = …)");
};
if crate::aliases::is_reserved_keyword(&name) {
bail!("{span}: `{name}` is a reserved keyword");
}
let (value, end_line) = self.resolve_assign_rhs(&rhs, span, true)?;
Ok(Stmt::Assign {
name,
value,
span,
end_line,
})
}
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(&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,
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() {
return self.consume_formula_fence(span);
}
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())?), 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,
))
}
fn consume_formula_fence(&mut self, span: Span) -> Result<(Expr, u32)> {
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 `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");
}
return Ok((
formula_fence_to_expr(body)
.map_err(|e| anyhow::anyhow!("{open_line}:1: formula: {e}"))?,
open_line,
));
}
if trimmed != "$$" {
bail!(
"{open_line}:1: expected `$$` fence opener after empty assignment, 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 text = body_lines.join("\n").trim().to_string();
if text.is_empty() {
bail!("{open_line}:1: empty formula");
}
let expr = formula_fence_to_expr(&text)
.map_err(|e| anyhow::anyhow!("{open_line}:1: formula: {e}"))?;
Ok((expr, 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)
///
/// 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");
}
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 = if cond_src == "*" || cond_src.is_empty() {
None
} else {
Some(parse_expr_str(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();
// foreach: [item](collection)
if let Some((item, coll)) = parse_foreach_header(rest) {
let body = self.parse_indented_body(base_indent)?;
return Ok(Stmt::ForEach {
item,
collection: coll,
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 `+`/`-` 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;
}
body.push(self.parse_simple_stmt()?);
}
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$$` → Formula or numeric matrix List; otherwise None.
fn try_parse_inline_formula(rhs: &str) -> Result<Option<Expr>> {
let rhs = rhs.trim();
if !rhs.starts_with("$$") {
return Ok(None);
}
if rhs.starts_with("$$:") || rhs.starts_with("$$ name=") {
bail!(
"`$$:name` / `$$ name=` binding was removed; use `name` = then a `$$…$$` fence"
);
}
if rhs.ends_with("$$") && rhs.len() > 4 {
let body = rhs[2..rhs.len() - 2].trim();
if body.is_empty() {
bail!("empty formula");
}
let expr = formula_fence_to_expr(body).map_err(|e| anyhow::anyhow!("formula: {e}"))?;
return Ok(Some(expr));
}
bail!("incomplete inline formula (expected `$$…$$` on one line)");
}
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) -> 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, default })
}
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())
}
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))
}
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 parsing one frontmatter `import` / `导入` line.
#[derive(Debug, Clone)]
pub enum ImportLine {
File(Import),
Member(Use),
}
fn legacy_frontmatter_import_hint(trimmed: &str) -> Option<String> {
let t = trimmed.trim();
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(
"legacy frontmatter import `> …` is removed; use `import bind:path.mq.md` \
or `import bind:lib.member` (Chinese: `导入`)"
.into(),
);
}
None
}
/// Parse `import json:lib/json.mq.md` / `导入 fmt:time.format`.
/// Returns `Ok(None)` for non-import frontmatter lines (e.g. `title:`).
pub fn parse_import_line(trimmed: &str) -> Result<Option<ImportLine>> {
let t = trimmed.trim();
let after = 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() {
bail!("expected `导入 bind:target`");
}
a
} else {
return Ok(None);
};
let Some((bind_raw, target_raw)) = after.split_once(':') else {
bail!("expected `import bind:target` (file `.mq.md` or `lib.member`)");
};
let bind = bind_raw.trim();
let target = target_raw.trim();
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(Some(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(Some(ImportLine::Member(Use {
path,
bind: bind.to_string(),
})))
}
fn is_simple_bind_name(s: &str) -> bool {
is_simple_type_name(s)
}
/// Parse a file import line body for catalog / tooling (`bind:path.mq.md` after keyword stripped),
/// or the full `import bind:path` / legacy-free form via [`parse_import_line`].
pub fn parse_import_spec(line: &str) -> Option<Import> {
match parse_import_line(line).ok()? {
Some(ImportLine::File(imp)) => Some(imp),
_ => 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 bold return `****` is handled separately; frames are --- or *** (etc.).
if is_empty_bold_return(trimmed) {
return false;
}
trimmed.chars().all(|c| c == '-') || trimmed.chars().all(|c| c == '*')
}
/// `****` 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 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);
t.split('|').map(|c| c.trim().to_string()).collect()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ast::Stmt;
#[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_italic_bare_lhs_prefer_var() {
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_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:?}"),
}
}
}