The design language that makes your AI harness better at design.
JavaScript
//! V8's `JSON.parse` SyntaxError messages, reproduced by a small scanner so
//! `config_invalid` reports read like Node's. Covers the message shapes V8
//! emits for structural mistakes; anything the scanner cannot classify falls
//! back to the generic `Unexpected token` form.
fn pos_suffix(text: &str, pos: usize) -> String {
let mut line = 1;
let mut col = 1;
for (i, c) in text.char_indices() {
if i >= pos {
break;
}
if c == '\n' {
line += 1;
col = 1;
} else {
col += 1;
}
}
format!(
" in JSON at position {} (line {} column {})",
pos, line, col
)
}
fn unexpected_token(text: &str, ch: char) -> String {
let preview: String = text.chars().take(30).collect();
format!(
"Unexpected token '{}', \"{}\" is not valid JSON",
ch, preview
)
}
struct Scanner<'a> {
b: &'a [u8],
text: &'a str,
i: usize,
}
const EOF_MSG: &str = "Unexpected end of JSON input";
impl<'a> Scanner<'a> {
fn ws(&mut self) {
while self.i < self.b.len() && matches!(self.b[self.i], b' ' | b'\t' | b'\n' | b'\r') {
self.i += 1;
}
}
fn peek(&self) -> Option<u8> {
self.b.get(self.i).copied()
}
fn ch_at(&self, i: usize) -> char {
self.text[i..].chars().next().unwrap_or(' ')
}
fn value(&mut self) -> Result<(), String> {
self.ws();
let Some(c) = self.peek() else {
return Err(EOF_MSG.to_string());
};
match c {
b'{' => self.object(),
b'[' => self.array(),
b'"' => self.string(),
b't' => self.literal("true"),
b'f' => self.literal("false"),
b'n' => self.literal("null"),
b'-' | b'0'..=b'9' => self.number(),
_ => Err(unexpected_token(self.text, self.ch_at(self.i))),
}
}
fn literal(&mut self, word: &str) -> Result<(), String> {
for (k, wb) in word.bytes().enumerate() {
match self.b.get(self.i + k) {
None => return Err(EOF_MSG.to_string()),
Some(&x) if x == wb => {}
Some(_) => return Err(unexpected_token(self.text, self.ch_at(self.i + k))),
}
}
self.i += word.len();
Ok(())
}
fn number(&mut self) -> Result<(), String> {
if self.peek() == Some(b'-') {
self.i += 1;
if !matches!(self.peek(), Some(b'0'..=b'9')) {
return Err(format!(
"No number after minus sign{}",
pos_suffix(self.text, self.i)
));
}
}
while matches!(self.peek(), Some(b'0'..=b'9')) {
self.i += 1;
}
if self.peek() == Some(b'.') {
self.i += 1;
if !matches!(self.peek(), Some(b'0'..=b'9')) {
return Err(format!(
"Unterminated fractional number{}",
pos_suffix(self.text, self.i)
));
}
while matches!(self.peek(), Some(b'0'..=b'9')) {
self.i += 1;
}
}
if matches!(self.peek(), Some(b'e') | Some(b'E')) {
self.i += 1;
if matches!(self.peek(), Some(b'+') | Some(b'-')) {
self.i += 1;
}
if !matches!(self.peek(), Some(b'0'..=b'9')) {
return Err(format!(
"Exponent part is missing a number{}",
pos_suffix(self.text, self.i)
));
}
while matches!(self.peek(), Some(b'0'..=b'9')) {
self.i += 1;
}
}
Ok(())
}
fn string(&mut self) -> Result<(), String> {
self.i += 1;
loop {
match self.peek() {
None => {
return Err(format!(
"Unterminated string{}",
pos_suffix(self.text, self.i)
))
}
Some(b'"') => {
self.i += 1;
return Ok(());
}
Some(b'\\') => {
self.i += 1;
match self.peek() {
None => {
return Err(format!(
"Unterminated string{}",
pos_suffix(self.text, self.i)
))
}
Some(b'u') => {
for k in 1..=4 {
if !self
.b
.get(self.i + k)
.map(|x| x.is_ascii_hexdigit())
.unwrap_or(false)
{
return Err(format!(
"Bad Unicode escape{}",
pos_suffix(self.text, self.i + k)
));
}
}
self.i += 5;
}
Some(b'"' | b'\\' | b'/' | b'b' | b'f' | b'n' | b'r' | b't') => self.i += 1,
Some(_) => {
return Err(format!(
"Bad escaped character{}",
pos_suffix(self.text, self.i)
))
}
}
}
Some(c) if c < 0x20 => {
return Err(format!(
"Bad control character in string literal{}",
pos_suffix(self.text, self.i)
))
}
Some(_) => self.i += 1,
}
}
}
fn array(&mut self) -> Result<(), String> {
self.i += 1;
self.ws();
if self.peek() == Some(b']') {
self.i += 1;
return Ok(());
}
loop {
self.value()?;
self.ws();
match self.peek() {
Some(b',') => {
self.i += 1;
self.ws();
}
Some(b']') => {
self.i += 1;
return Ok(());
}
_ => {
return Err(format!(
"Expected ',' or ']' after array element{}",
pos_suffix(self.text, self.i)
))
}
}
}
}
fn object(&mut self) -> Result<(), String> {
self.i += 1;
self.ws();
if self.peek() == Some(b'}') {
self.i += 1;
return Ok(());
}
if self.peek() != Some(b'"') {
return Err(format!(
"Expected property name or '}}'{}",
pos_suffix(self.text, self.i)
));
}
loop {
if self.peek() != Some(b'"') {
return Err(format!(
"Expected double-quoted property name{}",
pos_suffix(self.text, self.i)
));
}
self.string()?;
self.ws();
if self.peek() != Some(b':') {
return Err(format!(
"Expected ':' after property name{}",
pos_suffix(self.text, self.i)
));
}
self.i += 1;
self.value()?;
self.ws();
match self.peek() {
Some(b',') => {
self.i += 1;
self.ws();
}
Some(b'}') => {
self.i += 1;
return Ok(());
}
_ => {
return Err(format!(
"Expected ',' or '}}' after property value{}",
pos_suffix(self.text, self.i)
))
}
}
}
}
}
/// The message `JSON.parse(text)` throws in Node, or None when the text
/// parses.
pub fn json_parse_error(text: &str) -> Option<String> {
let mut s = Scanner {
b: text.as_bytes(),
text,
i: 0,
};
if let Err(e) = s.value() {
return Some(e);
}
s.ws();
if s.i < s.b.len() {
return Some(format!(
"Unexpected non-whitespace character after JSON{}",
pos_suffix(text, s.i).replacen(" in JSON", "", 1)
));
}
None
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn shapes() {
assert_eq!(
json_parse_error("{ nope").unwrap(),
"Expected property name or '}' in JSON at position 2 (line 1 column 3)"
);
assert_eq!(
json_parse_error("[1").unwrap(),
"Expected ',' or ']' after array element in JSON at position 2 (line 1 column 3)"
);
assert_eq!(
json_parse_error("").unwrap(),
"Unexpected end of JSON input"
);
assert_eq!(
json_parse_error("[1,]").unwrap(),
"Unexpected token ']', \"[1,]\" is not valid JSON"
);
assert_eq!(
json_parse_error("{\"a\":1} x").unwrap(),
"Unexpected non-whitespace character after JSON at position 8 (line 1 column 9)"
);
assert!(json_parse_error("{\"a\":[1,2,{\"b\":null}]}").is_none());
}
}