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