Implement table semantic T0-T4: map/records/footnote get
- 1-col table stays a List; >=2-col becomes a column-oriented Map
(1 data row -> scalar values, >=2 -> Map of Lists).
- First header @ / 行 / row opts into row-oriented List of Maps
(marker column excluded); missing field cols is a diagnostic.
- Footnote index: `xs`[^1] (1-based list), `m`[^key] (map key), chained.
Errors for [^0], out-of-range, missing key, duplicate headers.
- foreach walks list items or map keys; Map values now display as {k: v}.
- Sync both tree and bytecode backends; new gold + error fixtures, docs
(markdown-mapping, roadmap, skill, public), and public 07/08 pages.
- Fix subtask-spawn fixture return value to child_ok (child-ok parses as
subtraction).
Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
1 parent
3463628165
commit
a23fdedfa2
37 files changed
+846
-51
No files matched your search
+39
-1
@@ -362,7 +362,20 @@ impl<'a> Parser<'a> {
|
||||
if !self.eat("`") {
|
||||
bail!("unterminated `name`");
|
||||
}
|
||||
return Ok(Expr::Var(name));
|
||||
let mut expr = Expr::Var(name);
|
||||
// Postfix footnotes: `xs`[^1] / `m`[^key] / chained `m`[^k][^1]
|
||||
loop {
|
||||
self.skip_ws();
|
||||
if !self.starts_with("[^") {
|
||||
break;
|
||||
}
|
||||
let label = self.parse_footnote_label()?;
|
||||
expr = Expr::Index {
|
||||
base: Box::new(expr),
|
||||
label,
|
||||
};
|
||||
}
|
||||
return Ok(expr);
|
||||
}
|
||||
if self.eat(">") {
|
||||
// Inline call: `> name k=v`
|
||||
@@ -484,6 +497,31 @@ impl<'a> Parser<'a> {
|
||||
}
|
||||
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 {
|
||||
|
||||
+109
-17
@@ -327,13 +327,13 @@ impl<'a> Cursor<'a> {
|
||||
return self.consume_code_fence(span);
|
||||
}
|
||||
let start_i = self.i;
|
||||
let list = self.consume_table()?;
|
||||
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((Expr::List(list), end_line));
|
||||
return Ok((table, end_line));
|
||||
}
|
||||
if let Some(expr) = try_parse_inline_formula(rhs)? {
|
||||
return Ok((expr, span.line));
|
||||
@@ -456,10 +456,15 @@ impl<'a> Cursor<'a> {
|
||||
Ok((Expr::Formula(expr), end_line))
|
||||
}
|
||||
|
||||
fn consume_table(&mut self) -> Result<Vec<Expr>> {
|
||||
/// GFM table after empty RHS:
|
||||
/// - 1-col → List
|
||||
/// - first header `@` / `行` / `row` → List of row Maps (marker col excluded)
|
||||
/// - else ≥2-col → Map (column-oriented)
|
||||
fn consume_table(&mut self) -> Result<Expr> {
|
||||
self.skip_noise();
|
||||
let mut header: Vec<String> = Vec::new();
|
||||
let mut rows: Vec<Expr> = Vec::new();
|
||||
let mut header_line: u32 = 1;
|
||||
let mut data_rows: Vec<Vec<String>> = Vec::new();
|
||||
let mut header_done = false;
|
||||
let mut sep_done = false;
|
||||
while let Some(l) = self.peek() {
|
||||
@@ -470,10 +475,12 @@ impl<'a> Cursor<'a> {
|
||||
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;
|
||||
}
|
||||
@@ -486,23 +493,59 @@ impl<'a> Cursor<'a> {
|
||||
continue;
|
||||
}
|
||||
sep_done = true;
|
||||
if header.len() <= 1 {
|
||||
if let Some(cell) = cells.first() {
|
||||
rows.push(Expr::Literal(cell_literal(cell)));
|
||||
}
|
||||
} else {
|
||||
let mut pairs = Vec::new();
|
||||
for (i, key) in header.iter().enumerate() {
|
||||
let raw = cells.get(i).map(|s| s.as_str()).unwrap_or("");
|
||||
pairs.push((key.clone(), Expr::Literal(cell_literal(raw))));
|
||||
}
|
||||
rows.push(Expr::Map(pairs));
|
||||
}
|
||||
data_rows.push(cells);
|
||||
}
|
||||
if !header_done {
|
||||
bail!("expected GFM table after empty assignment");
|
||||
}
|
||||
Ok(rows)
|
||||
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 cells in data_rows {
|
||||
if let Some(cell) = cells.first() {
|
||||
rows.push(Expr::Literal(cell_literal(cell)));
|
||||
}
|
||||
}
|
||||
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 raw = data_rows[0].get(col).map(|s| s.as_str()).unwrap_or("");
|
||||
pairs.push((key.clone(), Expr::Literal(cell_literal(raw))));
|
||||
} else {
|
||||
// 0 rows → empty lists; ≥2 rows → column lists.
|
||||
let mut col_vals = Vec::with_capacity(n_rows);
|
||||
for cells in &data_rows {
|
||||
let raw = cells.get(col).map(|s| s.as_str()).unwrap_or("");
|
||||
col_vals.push(Expr::Literal(cell_literal(raw)));
|
||||
}
|
||||
pairs.push((key.clone(), Expr::List(col_vals)));
|
||||
}
|
||||
}
|
||||
Ok(Expr::Map(pairs))
|
||||
}
|
||||
|
||||
fn parse_branch(&mut self) -> Result<Stmt> {
|
||||
@@ -899,6 +942,55 @@ fn cell_literal(raw: &str) -> Literal {
|
||||
Literal::Text(t.to_string())
|
||||
}
|
||||
|
||||
/// 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<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 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(), Expr::Literal(cell_literal(raw))));
|
||||
}
|
||||
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);
|
||||
|
||||
Reference in new issue
Block a user