use std::num::ParseIntError;
use owo_colors::Style;
use smallvec::SmallVec;
use super::{
Arg, ArmTest, CmpOp, Cond, Escape, Field, FieldOptions, FieldType, Format, Piece, RepOp,
RepSource,
};
use crate::{
colors::{parse_color, ParseColorError},
json::MarkupStyles,
};
pub(super) fn crunch_input(
pieces: &mut Vec<Piece>,
args: &mut Vec<Arg>,
input: &str,
no_color: bool,
compact: bool,
) -> Result<(), FormatError> {
let mut sc = Scanner {
b: input.as_bytes(),
i: 0,
no_color,
compact,
};
sc.scan(pieces, args, 0, Stop::Eof)?;
absorb_line_prefixes(pieces);
Ok(())
}
fn absorb_line_prefixes(pieces: &mut Vec<Piece>) {
let mut i = 0;
while i < pieces.len() {
let is_block = matches!(pieces[i], Piece::RepStart(..) | Piece::CondStart(..));
if is_block && i > 0 {
if let Piece::Literal(prev) = &pieces[i - 1] {
if let Some(cut) = line_prefix_start(prev) {
let prefix = prev[cut..].to_owned();
if let Piece::Literal(p) = &mut pieces[i - 1] {
p.truncate(cut);
}
pieces.insert(i + 1, Piece::Literal(prefix));
}
}
}
i += 1;
}
}
fn line_prefix_start(s: &str) -> Option<usize> {
let b = s.as_bytes();
let mut j = b.len();
while j > 0 && (b[j - 1] == b' ' || b[j - 1] == b'\t') {
j -= 1;
}
(j > 0 && b[j - 1] == b'\n').then(|| j - 1)
}
struct Scanner<'a> {
b: &'a [u8],
i: usize,
no_color: bool,
compact: bool,
}
#[derive(Clone, Copy, PartialEq)]
enum Stop {
Eof,
Rep,
}
#[derive(Clone, Copy)]
enum CondKind {
If,
Has,
Config,
}
impl Scanner<'_> {
fn scan(
&mut self,
pieces: &mut Vec<Piece>,
args: &mut Vec<Arg>,
rep_depth: usize,
stop: Stop,
) -> Result<(), FormatError> {
let in_rep = stop == Stop::Rep;
let mut lit = String::new();
let mut paren_depth: usize = 0;
while self.i < self.b.len() {
match self.b[self.i] {
b'\\' => self.take_escape(&mut lit)?,
b'$' => match self.b.get(self.i + 1).copied() {
Some(b'$') => {
lit.push('$');
self.i += 2;
}
Some(b'(') => {
flush_lit(pieces, &mut lit);
self.i += 2;
self.parse_rep(pieces, args, rep_depth, RepSource::Record)?;
}
Some(b'{') => {
flush_lit(pieces, &mut lit);
self.i += 2;
self.parse_brace(pieces, args, rep_depth)?;
}
Some(x) if is_ident_start(x) => {
flush_lit(pieces, &mut lit);
self.i += 1;
self.parse_bare(pieces, args, rep_depth)?;
}
_ => {
lit.push('$');
self.i += 1;
}
},
b')' if in_rep => {
if paren_depth == 0 {
flush_lit(pieces, &mut lit);
self.i += 1;
return Ok(());
}
paren_depth -= 1;
lit.push(')');
self.i += 1;
}
b'(' if in_rep => {
paren_depth += 1;
lit.push('(');
self.i += 1;
}
_ => {
let start = self.i;
while self.i < self.b.len() {
let c = self.b[self.i];
if c == b'\\' || c == b'$' || (in_rep && (c == b'(' || c == b')')) {
break;
}
self.i += 1;
}
lit.push_str(std::str::from_utf8(&self.b[start..self.i]).unwrap());
}
}
}
if in_rep {
return Err(FormatError::UnclosedRep);
}
flush_lit(pieces, &mut lit);
Ok(())
}
fn take_escape(&mut self, lit: &mut String) -> Result<(), FormatError> {
self.i += 1;
let Some(&e) = self.b.get(self.i) else {
lit.push('\\');
return Ok(());
};
self.i += 1;
lit.push(match e {
b'n' => '\n',
b'r' => '\r',
b't' => '\t',
b'\\' => '\\',
b'$' => '$',
b'(' => '(',
b')' => ')',
b'\'' => '\'',
b'"' => '"',
b'{' => '{',
b'}' => '}',
other => return Err(FormatError::UnknownCharEscape(other as char)),
});
Ok(())
}
fn parse_bare(
&mut self,
pieces: &mut Vec<Piece>,
args: &mut Vec<Arg>,
rep_depth: usize,
) -> Result<(), FormatError> {
let start = self.i;
while self.i < self.b.len() && is_path_byte(self.b[self.i]) {
self.i += 1;
}
let name = std::str::from_utf8(&self.b[start..self.i]).unwrap();
if self.b.get(self.i) == Some(&b'(') {
self.i += 1;
let src = match name {
"match" => return self.parse_match(pieces, args, rep_depth),
"if" => return self.parse_cond_chain(pieces, args, rep_depth, CondKind::If),
"has" => return self.parse_cond_chain(pieces, args, rep_depth, CondKind::Has),
"config" => {
return self.parse_cond_chain(pieces, args, rep_depth, CondKind::Config)
}
"elif" | "else" | "when" => return Err(FormatError::OrphanArm(name.to_owned())),
"cols" => RepSource::Columns,
_ => RepSource::Path(parse_field(name)?),
};
return self.parse_rep(pieces, args, rep_depth, src);
}
let mut fields = FieldOptions::new();
push_field(&mut fields, name, rep_depth)?;
args.push((fields, parse_format(None, self.no_color, self.compact)?));
pieces.push(Piece::Arg(args.len() - 1));
Ok(())
}
fn parse_match(
&mut self,
pieces: &mut Vec<Piece>,
args: &mut Vec<Arg>,
rep_depth: usize,
) -> Result<(), FormatError> {
self.skip_ws();
let start = self.i;
while self.i < self.b.len() && (is_path_byte(self.b[self.i]) || self.b[self.i] == b'|') {
self.i += 1;
}
if self.i == start {
return Err(FormatError::EmptyMatchSubject);
}
let subject = std::str::from_utf8(&self.b[start..self.i]).unwrap();
let mut fo = FieldOptions::new();
push_field(&mut fo, subject, rep_depth)?;
args.push((fo, parse_format(None, self.no_color, self.compact)?));
pieces.push(Piece::MatchStart(args.len() - 1));
let mut first = true;
loop {
self.skip_ws();
match self.b.get(self.i) {
Some(b')') => {
self.i += 1;
break;
}
Some(b'$') if self.rest_is("$when(") => {
self.i += 6;
let pat = self.read_until_arrow()?;
self.push_arm(pieces, args, rep_depth, parse_arm(&pat)?, first)?;
}
Some(b'$') if self.rest_is("$else(") => {
self.i += 6;
self.skip_hspace();
self.push_arm(pieces, args, rep_depth, Cond::Arm(Vec::new()), first)?;
}
_ => return Err(FormatError::BadMatchArm),
}
first = false;
}
pieces.push(Piece::CondEnd);
pieces.push(Piece::MatchEnd);
Ok(())
}
fn push_arm(
&mut self,
pieces: &mut Vec<Piece>,
args: &mut Vec<Arg>,
rep_depth: usize,
cond: Cond,
first: bool,
) -> Result<(), FormatError> {
let mut fo = FieldOptions::new();
fo.push(Field::ColValue);
args.push((fo, parse_format(None, self.no_color, self.compact)?));
let idx = args.len() - 1;
pieces.push(if first {
Piece::CondStart(cond, idx)
} else {
Piece::ElseCond(cond, idx)
});
let mut body = Vec::new();
self.scan(&mut body, args, rep_depth + 1, Stop::Rep)?;
trim_cond_body(&mut body);
pieces.extend(body);
Ok(())
}
fn rest_is(&self, s: &str) -> bool {
self.b[self.i..].starts_with(s.as_bytes())
}
fn read_until_arrow(&mut self) -> Result<String, FormatError> {
let start = self.i;
let mut quote = 0u8;
while self.i < self.b.len() {
let c = self.b[self.i];
match c {
q @ (b'"' | b'\'') if quote == 0 => quote = q,
q if quote == q => quote = 0,
b'=' if quote == 0 && self.b.get(self.i + 1) == Some(&b'>') => {
let pat = std::str::from_utf8(&self.b[start..self.i]).unwrap().trim().to_owned();
self.i += 2; self.skip_hspace();
return Ok(pat);
}
b')' if quote == 0 => break,
_ => {}
}
self.i += 1;
}
Err(FormatError::MissingArrow)
}
fn skip_hspace(&mut self) {
if matches!(self.b.get(self.i), Some(b' ' | b'\t')) {
self.i += 1;
}
}
fn skip_ws(&mut self) {
while matches!(self.b.get(self.i), Some(b' ' | b'\t' | b'\r' | b'\n')) {
self.i += 1;
}
}
fn parse_cond_chain(
&mut self,
pieces: &mut Vec<Piece>,
args: &mut Vec<Arg>,
rep_depth: usize,
kind: CondKind,
) -> Result<(), FormatError> {
self.push_cond_open(pieces, args, rep_depth, kind, false)?;
loop {
let save = self.i;
self.skip_ws();
if self.rest_is("$elif(") {
self.i += 6;
self.push_cond_open(pieces, args, rep_depth, CondKind::If, true)?;
} else if self.rest_is("$else(") {
self.i += 6;
self.skip_hspace();
pieces.push(Piece::Else);
let mut body = Vec::new();
self.scan(&mut body, args, rep_depth, Stop::Rep)?;
trim_cond_body(&mut body);
pieces.extend(body);
break;
} else {
self.i = save; break;
}
}
pieces.push(Piece::CondEnd);
Ok(())
}
fn push_cond_open(
&mut self,
pieces: &mut Vec<Piece>,
args: &mut Vec<Arg>,
rep_depth: usize,
kind: CondKind,
is_else: bool,
) -> Result<(), FormatError> {
let cond_text = self.read_until_arrow()?;
match kind {
CondKind::If => self.push_cond(pieces, args, &cond_text, Cond::If, is_else)?,
CondKind::Has => self.push_cond(pieces, args, &cond_text, Cond::Has, is_else)?,
CondKind::Config => {
let b = match cond_text.trim() {
"compact" => self.compact,
"no_color" => self.no_color,
other => {
return Err(FormatError::UnsupportedConfig {
config: other.to_owned(),
})
}
};
pieces.push(if is_else {
Piece::ElseCond(Cond::IfConfig(b), 0)
} else {
Piece::CondStart(Cond::IfConfig(b), 0)
});
}
}
let mut body = Vec::new();
self.scan(&mut body, args, rep_depth, Stop::Rep)?;
trim_cond_body(&mut body);
pieces.extend(body);
Ok(())
}
fn parse_brace(
&mut self,
pieces: &mut Vec<Piece>,
args: &mut Vec<Arg>,
rep_depth: usize,
) -> Result<(), FormatError> {
let start = self.i;
while self.i < self.b.len() && self.b[self.i] != b'}' {
self.i += 1;
}
if self.i >= self.b.len() {
return Err(FormatError::ClosingBrace);
}
let content = std::str::from_utf8(&self.b[start..self.i]).unwrap().trim();
self.i += 1; self.push_arg(pieces, args, content, rep_depth)
}
fn push_cond(
&self,
pieces: &mut Vec<Piece>,
args: &mut Vec<Arg>,
content: &str,
cond: Cond,
is_else: bool,
) -> Result<(), FormatError> {
let (field_str, cond) = match cond {
Cond::If => match split_comparison(content) {
Some((lhs, op, rhs)) => (lhs, Cond::Cmp(op, unquote(rhs).to_owned())),
None => (content.trim(), Cond::If),
},
other => (content.trim(), other),
};
let mut fo = FieldOptions::new();
crunch_field_options(field_str, &mut fo)?;
args.push((fo, parse_format(None, self.no_color, self.compact)?));
let idx = args.len() - 1;
pieces.push(if is_else {
Piece::ElseCond(cond, idx)
} else {
Piece::CondStart(cond, idx)
});
Ok(())
}
fn push_arg(
&self,
pieces: &mut Vec<Piece>,
args: &mut Vec<Arg>,
content: &str,
rep_depth: usize,
) -> Result<(), FormatError> {
let (name_part, mut format) = match content.split_once(':') {
Some((n, styles)) => (n.trim(), parse_format(Some(styles), self.no_color, self.compact)?),
None => (content, parse_format(None, self.no_color, self.compact)?),
};
let name_part = match name_part.strip_prefix('?') {
Some(rest) => {
format.optional = true;
rest.trim()
}
None => name_part,
};
let mut fields = FieldOptions::new();
push_field(&mut fields, name_part, rep_depth)?;
args.push((fields, format));
pieces.push(Piece::Arg(args.len() - 1));
Ok(())
}
fn parse_rep(
&mut self,
pieces: &mut Vec<Piece>,
args: &mut Vec<Arg>,
rep_depth: usize,
src: RepSource,
) -> Result<(), FormatError> {
let mut body = Vec::new();
self.scan(&mut body, args, rep_depth + 1, Stop::Rep)?;
trim_body_edges(&mut body);
let sep = self.read_separator()?;
let op = self.read_op()?;
pieces.push(Piece::RepStart(src, sep, op));
pieces.extend(body);
pieces.push(Piece::RepEnd);
Ok(())
}
fn read_separator(&mut self) -> Result<String, FormatError> {
match self.b.get(self.i) {
None | Some(b'*') | Some(b'+') | Some(b'?') => Ok(String::new()),
Some(b'"') => {
self.i += 1;
let mut bytes = Vec::new();
loop {
let Some(&c) = self.b.get(self.i) else {
return Err(FormatError::UnterminatedSep);
};
self.i += 1;
match c {
b'"' => break,
b'\\' => {
let Some(&e) = self.b.get(self.i) else {
return Err(FormatError::UnterminatedSep);
};
self.i += 1;
bytes.push(match e {
b'n' => b'\n',
b't' => b'\t',
b'r' => b'\r',
other => other,
});
}
other => bytes.push(other),
}
}
String::from_utf8(bytes).map_err(|_| FormatError::UnterminatedSep)
}
Some(_) => {
let start = self.i;
while let Some(&c) = self.b.get(self.i) {
if matches!(c, b'*' | b'+' | b'?' | b'\n' | b'\r' | b'$' | b'{') {
break;
}
self.i += 1;
}
Ok(std::str::from_utf8(&self.b[start..self.i]).unwrap().to_owned())
}
}
}
fn read_op(&mut self) -> Result<RepOp, FormatError> {
let op = match self.b.get(self.i) {
Some(b'*') => RepOp::Star,
Some(b'+') => RepOp::Plus,
Some(b'?') => RepOp::Question,
_ => return Err(FormatError::MissingRepOp),
};
self.i += 1;
Ok(op)
}
}
fn flush_lit(pieces: &mut Vec<Piece>, lit: &mut String) {
if !lit.is_empty() {
pieces.push(Piece::Literal(std::mem::take(lit)));
}
}
fn trim_body_edges(body: &mut Vec<Piece>) {
const SP: [char; 2] = [' ', '\t'];
if let Some(Piece::Literal(s)) = body.first_mut() {
let t = s.trim_start_matches(SP).to_owned();
if t.is_empty() {
body.remove(0);
} else {
*s = t;
}
}
if let Some(Piece::Literal(s)) = body.last_mut() {
let t = s.trim_end_matches(SP).to_owned();
if t.is_empty() {
body.pop();
} else {
*s = t;
}
}
}
fn trim_cond_body(body: &mut [Piece]) {
let all_ws = body
.iter()
.all(|p| matches!(p, Piece::Literal(s) if s.chars().all(char::is_whitespace)));
if all_ws {
return;
}
if let Some(Piece::Literal(s)) = body.first_mut() {
if let Some(cut) = leading_layout_ws(s) {
*s = s[cut..].to_owned();
}
}
if let Some(Piece::Literal(s)) = body.last_mut() {
if let Some(cut) = trailing_layout_ws(s) {
s.truncate(cut);
}
}
}
fn leading_layout_ws(s: &str) -> Option<usize> {
let b = s.as_bytes();
let mut i = 0;
while i < b.len() && matches!(b[i], b' ' | b'\t' | b'\r' | b'\n') {
i += 1;
}
s[..i].contains('\n').then_some(i)
}
fn trailing_layout_ws(s: &str) -> Option<usize> {
let b = s.as_bytes();
let mut i = b.len();
while i > 0 && matches!(b[i - 1], b' ' | b'\t' | b'\r' | b'\n') {
i -= 1;
}
s[i..].contains('\n').then_some(i)
}
fn is_ident_start(b: u8) -> bool {
b.is_ascii_alphabetic() || b == b'_'
}
fn is_path_byte(b: u8) -> bool {
b.is_ascii_alphanumeric() || b == b'_' || b == b'.' || b == b'[' || b == b']'
}
fn split_comparison(content: &str) -> Option<(&str, CmpOp, &str)> {
for (token, op) in CMP_OPS {
if let Some(idx) = content.find(token) {
let lhs = content[..idx].trim();
let rhs = content[idx + token.len()..].trim();
return Some((lhs, op, rhs));
}
}
None
}
fn unquote(s: &str) -> &str {
let bytes = s.as_bytes();
if bytes.len() >= 2 {
let first = bytes[0];
if (first == b'"' || first == b'\'') && bytes[bytes.len() - 1] == first {
return &s[1..s.len() - 1];
}
}
s
}
const CMP_OPS: [(&str, CmpOp); 6] = [
("==", CmpOp::Eq),
("!=", CmpOp::Ne),
(">=", CmpOp::Ge),
("<=", CmpOp::Le),
(">", CmpOp::Gt),
("<", CmpOp::Lt),
];
fn parse_arm(content: &str) -> Result<Cond, FormatError> {
let c = content.trim();
let mut tests = Vec::new();
for alt in split_top_level_pipe(c) {
tests.push(parse_arm_test(alt.trim())?);
}
Ok(Cond::Arm(tests))
}
fn parse_arm_test(s: &str) -> Result<ArmTest, FormatError> {
for (token, op) in CMP_OPS {
if let Some(rest) = s.strip_prefix(token) {
return Ok(ArmTest::Cmp(op, unquote(rest.trim()).to_owned()));
}
}
if s.contains("..") {
return parse_range(s);
}
Ok(ArmTest::Cmp(CmpOp::Eq, unquote(s).to_owned()))
}
fn parse_range(s: &str) -> Result<ArmTest, FormatError> {
let (lo_str, rest) = s.split_once("..").unwrap();
let hi_inclusive = rest.starts_with('=');
let hi_str = if hi_inclusive { &rest[1..] } else { rest };
let parse_bound = |b: &str| -> Result<Option<f64>, FormatError> {
let b = b.trim();
if b.is_empty() {
return Ok(None);
}
b.parse::<f64>()
.map(Some)
.map_err(|_| FormatError::BadRange(s.to_owned()))
};
Ok(ArmTest::Range {
lo: parse_bound(lo_str)?,
hi: parse_bound(hi_str)?,
hi_inclusive,
})
}
fn split_top_level_pipe(s: &str) -> Vec<&str> {
let mut parts = Vec::new();
let b = s.as_bytes();
let (mut start, mut quote) = (0usize, 0u8);
for i in 0..b.len() {
match b[i] {
q @ (b'"' | b'\'') if quote == 0 => quote = q,
q if quote == q => quote = 0,
b'|' if quote == 0 => {
parts.push(&s[start..i]);
start = i + 1;
}
_ => {}
}
}
parts.push(&s[start..]);
parts
}
fn push_field(fields: &mut FieldOptions, name: &str, rep_depth: usize) -> Result<(), FormatError> {
if rep_depth > 0 {
if name == "value" {
fields.push(Field::ColValue);
return Ok(());
}
if name == "key" {
fields.push(Field::ColKey);
return Ok(());
}
if let Some(rest) = name.strip_prefix("value.") {
if let Field::Names(names) = parse_field(rest)? {
fields.push(Field::ColValuePath(names));
return Ok(());
}
}
}
crunch_field_options(name, fields)
}
fn crunch_field_options(content: &str, field_options: &mut FieldOptions) -> Result<(), FormatError> {
if content.is_empty() {
return Ok(());
}
for field in content.split('|') {
if !field.is_empty() {
field_options.push(parse_field(field)?);
}
}
Ok(())
}
pub(super) fn parse_field(name: &str) -> Result<Field, FormatError> {
if name == "." {
return Ok(Field::Whole);
} else if name == ".." {
return Ok(Field::Rest);
}
let mut args = SmallVec::new();
for part in name.split('.') {
if let Some((name, index)) = part.split_once('[') {
args.push(FieldType::Name(name.to_owned()));
if index.ends_with(']') {
let index = index
.trim_end_matches(']')
.parse()
.toss_parse_index_with(|| index.to_owned())?;
args.push(FieldType::Index(index));
} else {
return Err(FormatError::IndexBracket);
}
} else {
args.push(FieldType::Name(part.to_owned()));
}
}
Ok(Field::Names(args))
}
pub fn parse_format(
input: Option<&str>,
no_color: bool,
mut compact: bool,
) -> Result<Format, FormatError> {
let mut style = (!no_color).then(Style::new);
let mut is_json = false;
let mut indent = 0;
let mut escape = Escape::None;
let mut markup_styles = MarkupStyles::default();
let Some(input) = input else {
return Ok(Format {
style,
compact,
is_json,
indent,
optional: false,
escape,
markup_styles,
});
};
for part in input.split(',') {
let part = part.trim();
if part.is_empty() {
continue;
}
let (name, value) = if let Some((name, value)) = part.split_once('=') {
(name, value)
} else {
match part {
"compact" => {
compact = true;
continue;
}
"json" => {
is_json = true;
continue;
}
"html" => {
escape = Escape::Html;
continue;
}
"csv" => {
escape = Escape::Csv;
continue;
}
"tsv" => {
escape = Escape::Tsv;
continue;
}
"md" => {
escape = Escape::Md;
continue;
}
"dimmed" => {
if let Some(s) = style.take() {
style = Some(s.dimmed());
}
continue;
}
"bold" => {
if let Some(s) = style.take() {
style = Some(s.bold());
}
continue;
}
_ => {}
}
("fg", part)
};
match name {
"fg" => {
let color = parse_color(value).toss_parse_color_with(|| value.to_owned())?;
if let Some(s) = style.take() {
style = Some(s.color(color));
}
}
"bg" => {
let color = parse_color(value).toss_parse_color_with(|| value.to_owned())?;
if let Some(s) = style.take() {
style = Some(s.on_color(color));
}
}
"indent" => {
let Ok(value) = value.parse::<usize>() else {
return Err(FormatError::ParseIndent(value.to_owned()));
};
indent = value;
}
"key" => {
let color = parse_color(value).toss_parse_color_with(|| value.to_owned())?;
markup_styles.key = markup_styles.key.color(color);
}
"value" => {
let color = parse_color(value).toss_parse_color_with(|| value.to_owned())?;
markup_styles.value = markup_styles.value.color(color);
}
"str" => {
let color = parse_color(value).toss_parse_color_with(|| value.to_owned())?;
markup_styles.str = markup_styles.str.color(color);
}
"syntax" => {
let color = parse_color(value).toss_parse_color_with(|| value.to_owned())?;
markup_styles.syntax = markup_styles.syntax.color(color);
}
_ => return Err(FormatError::InvalidModifier(name.to_owned())),
}
}
Ok(Format {
style,
compact,
is_json,
indent,
optional: false,
escape,
markup_styles,
})
}
use thiserror::Error;
use tosserror::Toss;
#[derive(Debug, Error, Toss)]
pub enum FormatError {
#[error("Failed to parse color '{value}' — if this was a style modifier, it is not one jlf knows (note: the `:level` modifier was removed; use the `${{@level}}` recipe or a `$match` to color by level)")]
ParseColor {
source: ParseColorError,
value: String,
},
#[error("Invalid indent value in format string '{0}'")]
ParseIndent(String),
#[error("Invalid modifier in format string '{0}'")]
InvalidModifier(String),
#[error("Unknown character escape in format string '\\{0}'")]
UnknownCharEscape(char),
#[error("Closing brace '}}' not found in format string")]
ClosingBrace,
#[error("Index closing bracket not found")]
IndexBracket,
#[error("Failed to parse index in format string '{value}'")]
ParseIndex {
source: ParseIntError,
value: String,
},
#[error("Unsupported config value in formatter '{config}'")]
UnsupportedConfig { config: String },
#[error("A `$( … )` block is missing its closing `)` — check your `$(`, `$path(`, `$cols(`, and `$rows(` blocks all have a matching `)`")]
UnclosedRep,
#[error("A `$( … )` repetition needs an operator (`*`, `+`, or `?`) after it — if you meant a conditional, use `$has(path => …)`, `$if(cond => …)`, or `$match(subject $when(…))` instead (note: `$key`/`$value` are loop variables, not conditionals)")]
MissingRepOp,
#[error("Unterminated quoted separator in a repetition")]
UnterminatedSep,
#[error("A `$match( … )` needs a subject, e.g. `$match(status $when(…))`")]
EmptyMatchSubject,
#[error("A `$match( … )` arm must be `$when(pattern => body)` or `$else(body)`")]
BadMatchArm,
#[error("A `$when`/`$if`/`$elif`/`$has`/`$config` block is missing its `=>` between the condition and the body")]
MissingArrow,
#[error("`$when`/`$elif`/`$else` may only appear inside `$match( … )` or an `$if`/`$has`/`$config` chain, not on their own: `${0}( … )`")]
OrphanArm(String),
#[error("Invalid numeric range in a `$when( … )` arm: '{0}'")]
BadRange(String),
}