aljaz/turso
1
0
Fork 0
mirror of https://github.com/aljazceru/turso.git synced 2026-01-26 11:24:32 +01:00
Code Issues Packages Projects Releases Wiki Activity

Nicer parse errors using miette

Browse Source 
I noticed that the parse errors were a bit hard to read - only the nearest token and the line/col offsets were printed.

I made a first attempt at improving the errors using [miette](https://github.com/zkat/miette).
- Added derive for `miette::Diagnostic` to both the parser's error type and LimboError.
- Added miette dependency to both sqlite3_parser and core. The `fancy` feature is only enabled for CLI.

Some future improvements that can be made further:
- Add spans to AST nodes so that errors can better point to the correct token. See upstream issue: https://github.com/gwenn/lemon-rs/issues/33
- Construct more errors with offset information. I noticed that most parser errors are constructed with `None` as the offset.

Comparisons.
Before:
```
❯ cargo run --package limbo --bin limbo database.db --output-mode pretty
...
limbo> selet * from a;
[2025-01-05T11:22:55Z ERROR sqlite3Parser] near "Token([115, 101, 108, 101, 116])": syntax error
Parse error: near "selet": syntax error at (1, 6)
```

After:
```
❯ cargo run --package limbo --bin limbo database.db --output-mode pretty
...
limbo> selet * from a;
[2025-01-05T12:25:52Z ERROR sqlite3Parser] near "Token([115, 101, 108, 101, 116])": syntax error

  × near "selet": syntax error at (1, 6)
   ╭────
 1 │ selet * from a
   ·     ▲
   ·     ╰── syntax error
   ╰────

```
This commit is contained in:
Samyak S Sarnayak
2025-01-05 16:44:44 +05:30
parent fdbf62d5b3
commit c09a0bcbf3
10 changed files with 224 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
vendored/sqlite3-parser/src/lexer/sql/error.rs
View File

@@ -7,57 +7,91 @@ use crate::parser::ParserError;
/// SQL lexer and parser errors
#[non_exhaustive]
#[derive(Debug)]
#[derive(Debug, miette::Diagnostic)]
#[diagnostic()]
pub enum Error {
/// I/O Error
Io(io::Error),
/// Lexer error
UnrecognizedToken(Option<(u64, usize)>),
UnrecognizedToken(
Option<(u64, usize)>,
#[label("here")] Option<miette::SourceSpan>,
),
/// Missing quote or double-quote or backtick
UnterminatedLiteral(Option<(u64, usize)>),
UnterminatedLiteral(
Option<(u64, usize)>,
#[label("here")] Option<miette::SourceSpan>,
),
/// Missing `]`
UnterminatedBracket(Option<(u64, usize)>),
UnterminatedBracket(
Option<(u64, usize)>,
#[label("here")] Option<miette::SourceSpan>,
),
/// Missing `*/`
UnterminatedBlockComment(Option<(u64, usize)>),
UnterminatedBlockComment(
Option<(u64, usize)>,
#[label("here")] Option<miette::SourceSpan>,
),
/// Invalid parameter name
BadVariableName(Option<(u64, usize)>),
BadVariableName(
Option<(u64, usize)>,
#[label("here")] Option<miette::SourceSpan>,
),
/// Invalid number format
BadNumber(Option<(u64, usize)>),
BadNumber(
Option<(u64, usize)>,
#[label("here")] Option<miette::SourceSpan>,
),
/// Invalid or missing sign after `!`
ExpectedEqualsSign(Option<(u64, usize)>),
ExpectedEqualsSign(
Option<(u64, usize)>,
#[label("here")] Option<miette::SourceSpan>,
),
/// BLOB literals are string literals containing hexadecimal data and preceded by a single "x" or "X" character.
MalformedBlobLiteral(Option<(u64, usize)>),
MalformedBlobLiteral(
Option<(u64, usize)>,
#[label("here")] Option<miette::SourceSpan>,
),
/// Hexadecimal integer literals follow the C-language notation of "0x" or "0X" followed by hexadecimal digits.
MalformedHexInteger(Option<(u64, usize)>),
MalformedHexInteger(
Option<(u64, usize)>,
#[label("here")] Option<miette::SourceSpan>,
),
/// Grammar error
ParserError(ParserError, Option<(u64, usize)>),
ParserError(
ParserError,
Option<(u64, usize)>,
#[label("syntax error")] Option<miette::SourceSpan>,
),
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
Self::Io(ref err) => err.fmt(f),
Self::UnrecognizedToken(pos) => write!(f, "unrecognized token at {:?}", pos.unwrap()),
Self::UnterminatedLiteral(pos) => {
Self::UnrecognizedToken(pos, _) => {
write!(f, "unrecognized token at {:?}", pos.unwrap())
}
Self::UnterminatedLiteral(pos, _) => {
write!(f, "non-terminated literal at {:?}", pos.unwrap())
}
Self::UnterminatedBracket(pos) => {
Self::UnterminatedBracket(pos, _) => {
write!(f, "non-terminated bracket at {:?}", pos.unwrap())
}
Self::UnterminatedBlockComment(pos) => {
Self::UnterminatedBlockComment(pos, _) => {
write!(f, "non-terminated block comment at {:?}", pos.unwrap())
}
Self::BadVariableName(pos) => write!(f, "bad variable name at {:?}", pos.unwrap()),
Self::BadNumber(pos) => write!(f, "bad number at {:?}", pos.unwrap()),
Self::ExpectedEqualsSign(pos) => write!(f, "expected = sign at {:?}", pos.unwrap()),
Self::MalformedBlobLiteral(pos) => {
Self::BadVariableName(pos, _) => write!(f, "bad variable name at {:?}", pos.unwrap()),
Self::BadNumber(pos, _) => write!(f, "bad number at {:?}", pos.unwrap()),
Self::ExpectedEqualsSign(pos, _) => write!(f, "expected = sign at {:?}", pos.unwrap()),
Self::MalformedBlobLiteral(pos, _) => {
write!(f, "malformed blob literal at {:?}", pos.unwrap())
}
Self::MalformedHexInteger(pos) => {
Self::MalformedHexInteger(pos, _) => {
write!(f, "malformed hex integer at {:?}", pos.unwrap())
}
Self::ParserError(ref msg, Some(pos)) => write!(f, "{msg} at {pos:?}"),
Self::ParserError(ref msg, _) => write!(f, "{msg}"),
Self::ParserError(ref msg, Some(pos), _) => write!(f, "{msg} at {pos:?}"),
Self::ParserError(ref msg, _, _) => write!(f, "{msg}"),
}
}
}
@@ -72,7 +106,7 @@ impl From<io::Error> for Error {
impl From<ParserError> for Error {
fn from(err: ParserError) -> Self {
Self::ParserError(err, None)
Self::ParserError(err, None, None)
}
}
@@ -80,16 +114,16 @@ impl ScanError for Error {
fn position(&mut self, line: u64, column: usize) {
match *self {
Self::Io(_) => {}
Self::UnrecognizedToken(ref mut pos) => *pos = Some((line, column)),
Self::UnterminatedLiteral(ref mut pos) => *pos = Some((line, column)),
Self::UnterminatedBracket(ref mut pos) => *pos = Some((line, column)),
Self::UnterminatedBlockComment(ref mut pos) => *pos = Some((line, column)),
Self::BadVariableName(ref mut pos) => *pos = Some((line, column)),
Self::BadNumber(ref mut pos) => *pos = Some((line, column)),
Self::ExpectedEqualsSign(ref mut pos) => *pos = Some((line, column)),
Self::MalformedBlobLiteral(ref mut pos) => *pos = Some((line, column)),
Self::MalformedHexInteger(ref mut pos) => *pos = Some((line, column)),
Self::ParserError(_, ref mut pos) => *pos = Some((line, column)),
Self::UnrecognizedToken(ref mut pos, _) => *pos = Some((line, column)),
Self::UnterminatedLiteral(ref mut pos, _) => *pos = Some((line, column)),
Self::UnterminatedBracket(ref mut pos, _) => *pos = Some((line, column)),
Self::UnterminatedBlockComment(ref mut pos, _) => *pos = Some((line, column)),
Self::BadVariableName(ref mut pos, _) => *pos = Some((line, column)),
Self::BadNumber(ref mut pos, _) => *pos = Some((line, column)),
Self::ExpectedEqualsSign(ref mut pos, _) => *pos = Some((line, column)),
Self::MalformedBlobLiteral(ref mut pos, _) => *pos = Some((line, column)),
Self::MalformedHexInteger(ref mut pos, _) => *pos = Some((line, column)),
Self::ParserError(_, ref mut pos, _) => *pos = Some((line, column)),
}
}
}