Files
marqdo/src/parse/expr.rs
T
cflmyandCursor bd5555afaa Unify bare-identifier semantics in *…* / **…** (Python namespace)
Inside italic/bold code segments every bare word is a variable — including
call arguments and method-call receivers — so text literals must be quoted
and receivers no longer need backticks. A bare dotted callee `a.b` resolves
as a method call when `a` is a local variable, otherwise as a library path
(Python-style unified namespace), in both the tree-walk and bytecode backends.

Migrate ~70 tests plus ext/web, ext/quantum, ext/ai and the example projects
to the new idiom; update SKILL.md and the design docs; fix the web/quantum
example data model (db/index.mq.md). Unit and gold suites pass; only the 3
network-live tests fail offline.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-08-18 11:20:46 +08:00

978 lines
30 KiB
Rust

//! Expression parser (recursive descent over a single string).
use anyhow::{bail, Result};
use crate::ast::{BinaryOp, CallExpr, Expr, InterpPart, Literal, UnaryOp};
pub fn parse_expr(input: &str) -> Result<Expr> {
parse_expr_mode(input, false)
}
/// Italic / bold value syntax: bare words are variables; text needs `"…"` / `'…'`.
pub fn parse_expr_prefer_var(input: &str) -> Result<Expr> {
parse_expr_mode(input, true)
}
fn parse_expr_mode(input: &str, prefer_var: bool) -> Result<Expr> {
let mut p = Parser::new(input.trim(), prefer_var);
let e = p.parse_or()?;
p.skip_ws();
if !p.rest().is_empty() {
bail!("trailing input in expression: {:?}", p.rest());
}
Ok(e)
}
/// Argument / template RHS: prefer a full expression; else interpolated text.
/// Hyphenated prose (`none-falsy`) is not parsed as subtraction.
/// Quoted `"..."` always uses the expression parser (never the hyphen short-circuit).
pub fn parse_value_or_interp(input: &str) -> Result<Expr> {
let s = input.trim();
if s.is_empty() {
return Ok(Expr::Literal(Literal::Text(String::new())));
}
if s.starts_with('"') || s.starts_with('\'') {
return match parse_expr(s) {
Ok(e) => Ok(e),
Err(_) => Ok(parse_interp(s)),
};
}
if has_hyphenated_prose(s) {
return Ok(parse_interp(s));
}
match parse_expr(s) {
Ok(e) => Ok(e),
Err(_) => Ok(parse_interp(s)),
}
}
/// Call-arg / param-default values: like [`parse_value_or_interp`], but also treat a chain of
/// unspaced `Text / Text` divisions as a single path string (`a/b`, `.marqdo/agent-kb`).
/// Real math (`1/2`, `` `n` / 2 ``) is unchanged.
pub fn parse_call_arg_value(input: &str) -> Result<Expr> {
let s = input.trim();
if s.is_empty() {
return Ok(Expr::Literal(Literal::Text(String::new())));
}
if s.starts_with('"') || s.starts_with('\'') {
return match parse_expr(s) {
Ok(e) => Ok(e),
Err(_) => Ok(parse_interp(s)),
};
}
if has_hyphenated_prose(s) {
return Ok(parse_interp(s));
}
match parse_expr(s) {
Ok(e) => Ok(collapse_text_div_path(e, s)),
Err(_) => {
// ext/web paths: `nav.`nav``, `articles.`articles`.title` — ticks are path
// punctuation, not interpolation.
if s.contains(".`") {
Ok(Expr::Literal(Literal::Text(s.to_string())))
} else {
Ok(parse_interp(s))
}
}
}
}
/// Like [`parse_call_arg_value`], but for call args inside `*…*` / `**…**`
/// value-expression segments: a bare word is a **variable** (not a text literal).
/// Quoted strings, hyphenated prose, and `/path` prose stay text; `` `x` `` still works.
pub fn parse_call_arg_value_prefer_var(input: &str) -> Result<Expr> {
let s = input.trim();
if s.is_empty() {
return Ok(Expr::Literal(Literal::Text(String::new())));
}
if s.starts_with('"') || s.starts_with('\'') {
return match parse_expr(s) {
Ok(e) => Ok(e),
Err(_) => Ok(parse_interp(s)),
};
}
if has_hyphenated_prose(s) {
return Ok(parse_interp(s));
}
match parse_expr_prefer_var(s) {
Ok(e) => Ok(e),
Err(_) => {
// `/about`, `.marqdo/x`, `nav.`nav`` etc. → prose text, not variables.
if s.starts_with('/') || s.contains(".`") {
Ok(Expr::Literal(Literal::Text(s.to_string())))
} else {
Ok(parse_interp(s))
}
}
}
}
fn is_text_only_div_chain(e: &Expr) -> bool {
match e {
Expr::Literal(Literal::Text(_)) => true,
Expr::Binary {
op: BinaryOp::Div,
left,
right,
} => is_text_only_div_chain(left) && matches!(right.as_ref(), Expr::Literal(Literal::Text(_))),
_ => false,
}
}
fn expr_has_div(e: &Expr) -> bool {
match e {
Expr::Binary {
op: BinaryOp::Div, ..
} => true,
Expr::Binary { left, right, .. } => expr_has_div(left) || expr_has_div(right),
Expr::Unary { expr, .. } => expr_has_div(expr),
_ => false,
}
}
fn collapse_text_div_path(e: Expr, raw: &str) -> Expr {
if expr_has_div(&e) && is_text_only_div_chain(&e) {
parse_interp(raw)
} else {
e
}
}
fn has_hyphenated_prose(s: &str) -> bool {
let chars: Vec<char> = s.chars().collect();
for i in 1..chars.len().saturating_sub(1) {
if chars[i] != '-' {
continue;
}
let left = chars[i - 1];
let right = chars[i + 1];
if left.is_whitespace() || right.is_whitespace() || left == '`' || right == '`' {
continue;
}
// `none-falsy` / `Hello-World` — not `` `n` - 1 ``
if left.is_alphanumeric() || right.is_alphanumeric() || !left.is_ascii() || !right.is_ascii()
{
return true;
}
}
false
}
pub fn parse_interp(s: &str) -> Expr {
let mut parts = Vec::new();
let mut rest = s;
while !rest.is_empty() {
if let Some(start) = rest.find('`') {
if start > 0 {
parts.push(InterpPart::Lit(rest[..start].to_string()));
}
let after = &rest[start + 1..];
if let Some(end) = after.find('`') {
let name = after[..end].to_string();
parts.push(InterpPart::Var(name));
rest = &after[end + 1..];
} else {
parts.push(InterpPart::Lit(format!("`{after}")));
break;
}
} else {
parts.push(InterpPart::Lit(rest.to_string()));
break;
}
}
if parts.len() == 1 {
match &parts[0] {
InterpPart::Lit(t) => return Expr::Literal(Literal::Text(t.clone())),
InterpPart::Var(n) => return Expr::Var(n.clone()),
}
}
Expr::Interp(parts)
}
struct Parser<'a> {
src: &'a str,
i: usize,
/// When true (italic/bold), bare words are variables, not text literals.
prefer_var: bool,
}
impl<'a> Parser<'a> {
fn new(src: &'a str, prefer_var: bool) -> Self {
Self {
src,
i: 0,
prefer_var,
}
}
fn rest(&self) -> &str {
&self.src[self.i..]
}
fn skip_ws(&mut self) {
while let Some(c) = self.peek_char() {
if c.is_whitespace() {
self.bump_char();
} else {
break;
}
}
}
fn peek_char(&self) -> Option<char> {
self.rest().chars().next()
}
fn bump_char(&mut self) -> Option<char> {
let mut chars = self.rest().chars();
let c = chars.next()?;
self.i += c.len_utf8();
Some(c)
}
fn starts_with(&self, s: &str) -> bool {
self.rest().starts_with(s)
}
fn eat(&mut self, s: &str) -> bool {
if self.starts_with(s) {
self.i += s.len();
true
} else {
false
}
}
/// Eat English or Chinese logic keyword with word-boundary check.
fn eat_logic_kw(&mut self, en: &str, zh: &str) -> bool {
if self.starts_with(en) && is_word_end(self.rest(), en.len()) {
self.i += en.len();
return true;
}
if self.starts_with(zh) && is_word_end(self.rest(), zh.len()) {
self.i += zh.len();
return true;
}
false
}
fn parse_or(&mut self) -> Result<Expr> {
let mut left = self.parse_and()?;
loop {
self.skip_ws();
if self.eat_logic_kw("or", "或") {
let right = self.parse_and()?;
left = Expr::Binary {
op: BinaryOp::Or,
left: Box::new(left),
right: Box::new(right),
};
} else {
break;
}
}
Ok(left)
}
fn parse_and(&mut self) -> Result<Expr> {
let mut left = self.parse_cmp()?;
loop {
self.skip_ws();
if self.eat_logic_kw("and", "且") {
let right = self.parse_cmp()?;
left = Expr::Binary {
op: BinaryOp::And,
left: Box::new(left),
right: Box::new(right),
};
} else {
break;
}
}
Ok(left)
}
fn parse_cmp(&mut self) -> Result<Expr> {
let mut left = self.parse_add()?;
self.skip_ws();
let op = if self.eat("==") {
Some(BinaryOp::Eq)
} else if self.eat("!=") {
Some(BinaryOp::Ne)
} else if self.eat("<=") {
Some(BinaryOp::Le)
} else if self.eat(">=") {
Some(BinaryOp::Ge)
} else if self.eat("<") {
Some(BinaryOp::Lt)
} else if self.eat(">") {
Some(BinaryOp::Gt)
} else {
None
};
if let Some(op) = op {
let right = self.parse_add()?;
left = Expr::Binary {
op,
left: Box::new(left),
right: Box::new(right),
};
}
Ok(left)
}
fn parse_add(&mut self) -> Result<Expr> {
let mut left = self.parse_mul()?;
loop {
self.skip_ws();
if self.eat("+") {
let right = self.parse_mul()?;
left = Expr::Binary {
op: BinaryOp::Add,
left: Box::new(left),
right: Box::new(right),
};
} else if self.eat("-") {
let right = self.parse_mul()?;
left = Expr::Binary {
op: BinaryOp::Sub,
left: Box::new(left),
right: Box::new(right),
};
} else {
break;
}
}
Ok(left)
}
fn parse_mul(&mut self) -> Result<Expr> {
let mut left = self.parse_unary()?;
loop {
self.skip_ws();
if self.eat("*") {
let right = self.parse_unary()?;
left = Expr::Binary {
op: BinaryOp::Mul,
left: Box::new(left),
right: Box::new(right),
};
} else if self.eat("/") {
let right = self.parse_unary()?;
left = Expr::Binary {
op: BinaryOp::Div,
left: Box::new(left),
right: Box::new(right),
};
} else {
break;
}
}
Ok(left)
}
fn parse_unary(&mut self) -> Result<Expr> {
self.skip_ws();
if self.eat_logic_kw("not", "非") {
let expr = self.parse_unary()?;
return Ok(Expr::Unary {
op: UnaryOp::Not,
expr: Box::new(expr),
});
}
if self.eat("-") {
let expr = self.parse_unary()?;
return Ok(Expr::Unary {
op: UnaryOp::Neg,
expr: Box::new(expr),
});
}
self.parse_primary()
}
fn parse_primary(&mut self) -> Result<Expr> {
self.skip_ws();
if self.eat("(") {
let e = self.parse_or()?;
self.skip_ws();
if !self.eat(")") {
bail!("expected ')'");
}
return Ok(e);
}
if self.eat("\"") {
return self.parse_quoted_string('"');
}
if self.eat("'") {
return self.parse_quoted_string('\'');
}
if self.eat("`") {
let start = self.i;
while let Some(c) = self.peek_char() {
if c == '`' {
break;
}
self.bump_char();
}
let name = self.src[start..self.i].to_string();
if !self.eat("`") {
bail!("unterminated `name`");
}
return self.parse_index_chain(Expr::Var(name));
}
if self.eat(">") {
// Inline call: `> name k=v`
self.skip_ws();
let prefer_var = self.prefer_var;
return Ok(Expr::Call(parse_call_tail(self.rest(), prefer_var).map(
|(c, consumed)| {
self.i += consumed;
c
},
)?));
}
if self.starts_with("True") && is_word_end(self.rest(), 4) {
self.i += 4;
return Ok(Expr::Literal(Literal::Bool(true)));
}
if self.starts_with("真") && is_word_end(self.rest(), '真'.len_utf8()) {
self.i += '真'.len_utf8();
return Ok(Expr::Literal(Literal::Bool(true)));
}
if self.starts_with("False") && is_word_end(self.rest(), 5) {
self.i += 5;
return Ok(Expr::Literal(Literal::Bool(false)));
}
if self.starts_with("假") && is_word_end(self.rest(), '假'.len_utf8()) {
self.i += '假'.len_utf8();
return Ok(Expr::Literal(Literal::Bool(false)));
}
if self.starts_with("None") && is_word_end(self.rest(), 4) {
self.i += 4;
return Ok(Expr::Literal(Literal::None));
}
if self.starts_with("空") && is_word_end(self.rest(), '空'.len_utf8()) {
self.i += '空'.len_utf8();
return Ok(Expr::Literal(Literal::None));
}
if self.peek_char().map(|c| c.is_ascii_digit()).unwrap_or(false) {
let start = self.i;
while self.peek_char().map(|c| c.is_ascii_digit()).unwrap_or(false) {
self.bump_char();
}
let n: i64 = self.src[start..self.i].parse()?;
return Ok(Expr::Literal(Literal::Int(n)));
}
// Bare identifier / text word. If immediately followed by `[^…]`, treat as
// variable + footnote index (exemption: ticks optional when `[^` marks the slot).
if self.peek_char().map(|c| c.is_alphanumeric() || c == '_' || !c.is_ascii()).unwrap_or(false)
{
let start = self.i;
while let Some(c) = self.peek_char() {
if c.is_whitespace()
|| matches!(
c,
'=' | '+'
| '-'
| '*'
| '/'
| '<'
| '>'
| '('
| ')'
| '`'
| '|'
| ','
| '"'
| '\''
| '['
| ']'
)
{
break;
}
self.bump_char();
}
let word = self.src[start..self.i].to_string();
self.skip_ws();
if self.starts_with("[^") {
return self.parse_index_chain(Expr::Var(word));
}
if self.prefer_var {
return Ok(Expr::Var(word));
}
return Ok(Expr::Literal(Literal::Text(word)));
}
bail!("unexpected expression input: {:?}", self.rest());
}
/// `` `xs`[^1] `` / `m[^key]` / chained `m[^k][^1]` (base already parsed).
fn parse_index_chain(&mut self, mut expr: Expr) -> Result<Expr> {
loop {
self.skip_ws();
if !self.starts_with("[^") {
break;
}
let label = self.parse_footnote_label()?;
expr = Expr::Index {
base: Box::new(expr),
label,
};
}
Ok(expr)
}
/// `"..."` or `'...'` with escapes and `` `var` `` interpolation.
fn parse_quoted_string(&mut self, quote: char) -> Result<Expr> {
use crate::ast::InterpPart;
let mut parts: Vec<InterpPart> = Vec::new();
let mut lit = String::new();
loop {
let Some(c) = self.peek_char() else {
bail!("unterminated {quote} string");
};
if c == quote {
self.bump_char();
break;
}
if c == '\\' {
self.bump_char();
let esc = self
.peek_char()
.ok_or_else(|| anyhow::anyhow!("dangling \\ in string"))?;
self.bump_char();
lit.push(match esc {
'n' => '\n',
't' => '\t',
'r' => '\r',
'\\' => '\\',
'"' => '"',
'\'' => '\'',
other => bail!("unknown escape \\{other} in string"),
});
continue;
}
if c == '`' {
if !lit.is_empty() {
parts.push(InterpPart::Lit(std::mem::take(&mut lit)));
}
self.bump_char();
let start = self.i;
while let Some(ch) = self.peek_char() {
if ch == '`' {
break;
}
self.bump_char();
}
let name = self.src[start..self.i].to_string();
if !self.eat("`") {
bail!("unterminated `name` in string");
}
parts.push(InterpPart::Var(name));
continue;
}
lit.push(c);
self.bump_char();
}
if !lit.is_empty() {
parts.push(InterpPart::Lit(lit));
}
if parts.is_empty() {
return Ok(Expr::Literal(Literal::Text(String::new())));
}
if parts.len() == 1 {
return Ok(match parts.remove(0) {
InterpPart::Lit(t) => Expr::Literal(Literal::Text(t)),
InterpPart::Var(n) => Expr::Var(n),
});
}
Ok(Expr::Interp(parts))
}
/// Parse `[^label]` after a value; label is text until `]`.
fn parse_footnote_label(&mut self) -> Result<String> {
if !self.eat("[^") {
bail!("expected [^ footnote index");
}
let start = self.i;
while let Some(c) = self.peek_char() {
if c == ']' {
break;
}
if c == '\n' || c == '\r' {
bail!("unterminated footnote index [^…]");
}
self.bump_char();
}
let label = self.src[start..self.i].trim().to_string();
if !self.eat("]") {
bail!("unterminated footnote index [^…]");
}
if label.is_empty() {
bail!("empty footnote index `[^]`");
}
Ok(label)
}
}
fn is_word_end(s: &str, len: usize) -> bool {
match s[len..].chars().next() {
None => true,
Some(c) => !(c.is_alphanumeric() || c == '_'),
}
}
/// Parse `name key=val …` / positional args; returns call + bytes consumed.
/// Callee may be a bare name, library path `time.parse`, or method `` `recv`.method ``.
/// When `prefer_var`, bare call-arg words parse as variables and bare dotted
/// callees are allowed to be method receivers.
pub fn parse_call_tail(s: &str, prefer_var: bool) -> Result<(CallExpr, usize)> {
use crate::ast::Arg;
let s = s.trim_start();
let original_len = s.len();
let callee_tok = {
let mut parts = s.split_whitespace();
parts
.next()
.ok_or_else(|| anyhow::anyhow!("missing callee"))?
.to_string()
};
let (receiver, callee, path) = if let Some((r, m)) = split_method_callee(&callee_tok) {
(Some(r), m, None)
} else if let Some(segments) = split_lib_path_callee(&callee_tok) {
let last = segments.last().cloned().unwrap_or_default();
(None, last, Some(segments))
} else {
(None, callee_tok.clone(), None)
};
let after_callee_offset = {
let idx = s.find(&callee_tok).unwrap();
idx + callee_tok.len()
};
let mut args_str = s[after_callee_offset..].trim_start();
let mut args = Vec::new();
let mut seen_named = false;
while !args_str.is_empty() {
if let Some((key, after_eq)) = try_named_arg(args_str) {
seen_named = true;
let val_end = find_next_arg_boundary(after_eq);
let val_raw = after_eq[..val_end].trim_end();
let value = if prefer_var {
parse_call_arg_value_prefer_var(val_raw)?
} else {
parse_call_arg_value(val_raw)?
};
args.push(Arg::Named {
name: key,
value,
});
args_str = after_eq[val_end..].trim_start();
} else {
if seen_named {
bail!("positional argument after named argument is not allowed");
}
let (tok, rest) = split_first_token(args_str);
if tok.is_empty() {
break;
}
let value = if prefer_var {
parse_call_arg_value_prefer_var(tok)?
} else {
parse_call_arg_value(tok)?
};
args.push(Arg::Positional(value));
args_str = rest.trim_start();
}
}
Ok((
CallExpr {
callee,
path,
receiver,
args,
},
original_len,
))
}
/// `` `recv`.method `` → (recv, method).
fn split_method_callee(tok: &str) -> Option<(String, String)> {
if !tok.starts_with('`') {
return None;
}
let rest = &tok[1..];
let end = rest.find('`')?;
let recv = rest[..end].to_string();
if recv.is_empty() {
return None;
}
let after = &rest[end + 1..];
let method = after.strip_prefix('.')?;
if method.is_empty() || method.contains('`') || method.contains('.') {
return None;
}
Some((recv, method.to_string()))
}
/// Bare `time.parse` / `agent.agent` → path segments (len ≥ 2).
fn split_lib_path_callee(tok: &str) -> Option<Vec<String>> {
if tok.starts_with('`') || !tok.contains('.') {
return None;
}
let parts: Vec<String> = tok.split('.').map(|s| s.to_string()).collect();
if parts.len() < 2 {
return None;
}
if parts.iter().any(|p| p.is_empty() || p.contains('`')) {
return None;
}
Some(parts)
}
/// If `s` begins with `ident=`, return (ident, rest_after_eq).
fn try_named_arg(s: &str) -> Option<(String, &str)> {
let s = s.trim_start();
for (i, c) in s.char_indices() {
if c == '=' {
if i == 0 {
return None;
}
let key = &s[..i];
if key.chars().any(|ch| ch.is_whitespace()) {
return None;
}
return Some((key.to_string(), &s[i + 1..]));
}
if c.is_whitespace() {
return None;
}
}
None
}
fn split_first_token(s: &str) -> (&str, &str) {
let s = s.trim_start();
if s.starts_with('"') {
if let Some(end) = end_of_quoted_string(s) {
return (&s[..end], &s[end..]);
}
}
if s.starts_with('`') {
// `` `name` `` as one token
if let Some(end) = s[1..].find('`') {
let end = end + 2; // include closing `
return (&s[..end], &s[end..]);
}
}
match s.find(char::is_whitespace) {
Some(i) => (&s[..i], &s[i..]),
None => (s, ""),
}
}
fn find_next_arg_boundary(after_eq: &str) -> usize {
// Look for ` <ident>=` pattern not inside backticks or quoted strings.
let mut in_bt = false;
let mut in_str = false;
let mut chars = after_eq.char_indices().peekable();
while let Some((i, c)) = chars.next() {
if in_str {
if c == '\\' {
chars.next();
continue;
}
if c == '"' {
in_str = false;
}
continue;
}
if in_bt {
if c == '`' {
in_bt = false;
}
continue;
}
if c == '`' {
in_bt = true;
continue;
}
if c == '"' {
in_str = true;
continue;
}
if c.is_whitespace() {
let rest = &after_eq[i..];
let trimmed = rest.trim_start();
let skipped = rest.len() - trimmed.len();
if let Some(eq_at) = trimmed.find('=') {
let key = &trimmed[..eq_at];
if !key.is_empty()
&& !key.contains(char::is_whitespace)
&& key
.chars()
.all(|ch| ch.is_alphanumeric() || ch == '_' || !ch.is_ascii())
{
return i + skipped;
}
}
}
}
after_eq.len()
}
/// Byte index after a leading `"..."` token (opening quote included in slice).
fn end_of_quoted_string(s: &str) -> Option<usize> {
if !s.starts_with('"') {
return None;
}
let mut escaped = false;
for (i, c) in s.char_indices().skip(1) {
if escaped {
escaped = false;
continue;
}
if c == '\\' {
escaped = true;
continue;
}
if c == '"' {
return Some(i + c.len_utf8());
}
}
None
}
/// Parse `> callee args` call expression/statement text (without leading `>`).
/// When `prefer_var` (inside `*…*` / `**…**`), bare call-arg words are variables
/// and a bare dotted callee may be a method receiver (resolved at eval/compile).
pub fn parse_call_after_gt(after_gt: &str, prefer_var: bool) -> Result<CallExpr> {
let (call, _) = parse_call_tail(after_gt.trim(), prefer_var)?;
Ok(call)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn bare_var_footnote_index() {
let e = parse_expr("ev[^result]").unwrap();
match e {
Expr::Index { base, label } => {
assert!(matches!(base.as_ref(), Expr::Var(n) if n == "ev"));
assert_eq!(label, "result");
}
other => panic!("expected Index, got {other:?}"),
}
let e = parse_expr("data[^choices][^1][^message]").unwrap();
assert!(matches!(e, Expr::Index { .. }));
// Without `[^`, bare word stays text literal.
let e = parse_expr("ev").unwrap();
assert!(matches!(e, Expr::Literal(Literal::Text(ref s)) if s == "ev"));
// Ticked form still works.
let e = parse_expr("`ev`[^result]").unwrap();
assert!(matches!(e, Expr::Index { .. }));
}
#[test]
fn prefer_var_bare_id_and_quotes() {
let e = parse_expr_prefer_var("answer").unwrap();
assert!(matches!(e, Expr::Var(ref n) if n == "answer"));
let e = parse_expr_prefer_var("n + 1").unwrap();
assert!(matches!(e, Expr::Binary { op: BinaryOp::Add, .. }));
let e = parse_expr_prefer_var("\"ok\"").unwrap();
assert!(matches!(e, Expr::Literal(Literal::Text(ref s)) if s == "ok"));
let e = parse_expr_prefer_var("'hi'").unwrap();
assert!(matches!(e, Expr::Literal(Literal::Text(ref s)) if s == "hi"));
let e = parse_expr_prefer_var("`answer`").unwrap();
assert!(matches!(e, Expr::Var(ref n) if n == "answer"));
}
#[test]
fn call_arg_module_path_stays_text() {
let e = parse_call_arg_value("nav.`nav`").unwrap();
assert!(matches!(
e,
Expr::Literal(Literal::Text(ref s)) if s == "nav.`nav`"
));
let e = parse_call_arg_value("articles.`articles`.title").unwrap();
assert!(matches!(
e,
Expr::Literal(Literal::Text(ref s)) if s == "articles.`articles`.title"
));
}
#[test]
fn quoted_string_escapes() {
let e = parse_expr("\"a\\nb\"").unwrap();
assert!(matches!(
e,
Expr::Literal(Literal::Text(ref s)) if s == "a\nb"
));
let e = parse_expr("\"hi `x`!\"").unwrap();
assert!(matches!(e, Expr::Interp(_)));
}
#[test]
fn call_arg_quoted_path_keeps_slashes() {
let e = parse_call_arg_value("\".marqdo/agent-runs\"").unwrap();
assert!(matches!(
e,
Expr::Literal(Literal::Text(ref s)) if s == ".marqdo/agent-runs"
));
let e = parse_value_or_interp("\".marqdo/agent-kb\"").unwrap();
assert!(matches!(
e,
Expr::Literal(Literal::Text(ref s)) if s == ".marqdo/agent-kb"
));
}
#[test]
fn call_arg_bare_path_not_division() {
let e = parse_call_arg_value("a/b/c").unwrap();
assert!(matches!(
e,
Expr::Literal(Literal::Text(ref s)) if s == "a/b/c"
));
let e = parse_call_arg_value("1/2").unwrap();
assert!(matches!(
e,
Expr::Binary {
op: BinaryOp::Div,
..
}
));
}
#[test]
fn bare_token_no_escape() {
let e = parse_expr("a\\nb").unwrap();
assert!(matches!(
e,
Expr::Literal(Literal::Text(ref s)) if s == "a\\nb"
));
}
#[test]
fn chinese_logic_and_literals() {
let e = parse_expr("`a` 且 非 `b`").unwrap();
assert!(matches!(e, Expr::Binary { op: BinaryOp::And, .. }));
assert!(matches!(
parse_expr("真").unwrap(),
Expr::Literal(Literal::Bool(true))
));
assert!(matches!(
parse_expr("空").unwrap(),
Expr::Literal(Literal::None)
));
}
}