128 lines
5.4 KiB
Rust
128 lines
5.4 KiB
Rust
//use codespan_reporting::diagnostic::{Diagnostic, Label};
|
|
use crate::syntax::tokens::Token;
|
|
use std::ops::Range;
|
|
use thiserror::Error;
|
|
|
|
#[derive(Debug, Error)]
|
|
pub enum ParserError {
|
|
#[error("Lexer error at {file_id}: {error}")]
|
|
LexerError { file_id: usize, error: LexerError },
|
|
|
|
#[error("Unacceptable end of file at {file_id} while {place}")]
|
|
UnacceptableEof { file_id: usize, place: &'static str },
|
|
|
|
#[error("Unexpected token at {file_id}: expected {expected}, saw {token}")]
|
|
UnexpectedToken {
|
|
file_id: usize,
|
|
span: Range<usize>,
|
|
token: Token,
|
|
expected: &'static str,
|
|
},
|
|
}
|
|
|
|
#[derive(Clone, Debug, Error, PartialEq)]
|
|
pub enum LexerError {
|
|
#[error("Illegal control character in input stream at offset {offset}")]
|
|
IllegalControlCharacter { offset: usize },
|
|
|
|
#[error("Illegal primitive value/type; it cut off before we could determine which at {span:?}")]
|
|
IllegalPrimitive { span: Range<usize> },
|
|
|
|
#[error("Illegal character in primitive ({char:?}) at {span:?}")]
|
|
IllegalPrimitiveCharacter { span: Range<usize>, char: char },
|
|
|
|
#[error("Unfinished character constant found at {span:?}")]
|
|
UnfinishedCharacter { span: Range<usize> },
|
|
|
|
#[error("Unfinished string constant found at {span:?}")]
|
|
UnfinishedString { span: Range<usize> },
|
|
|
|
#[error("Character {char:?} has some extra bits at the end at {span:?}")]
|
|
OverlongCharacter { char: char, span: Range<usize> },
|
|
|
|
#[error("Unknown escaped character {escaped_char:?} at {span:?}")]
|
|
UnknownEscapeCharacter {
|
|
escaped_char: char,
|
|
span: Range<usize>,
|
|
},
|
|
|
|
#[error("Invalid unicode escape sequence at {span:?}")]
|
|
InvalidUnicode { span: Range<usize> },
|
|
}
|
|
|
|
impl LexerError {
|
|
pub fn to_triple(&self) -> (usize, Result<Token, LexerError>, usize) {
|
|
match self {
|
|
LexerError::IllegalControlCharacter { offset } => (*offset, Err(self.clone()), *offset),
|
|
LexerError::IllegalPrimitive { span } => (span.start, Err(self.clone()), span.end),
|
|
LexerError::IllegalPrimitiveCharacter { span, .. } => {
|
|
(span.start, Err(self.clone()), span.end)
|
|
}
|
|
LexerError::UnfinishedCharacter { span, .. } => {
|
|
(span.start, Err(self.clone()), span.end)
|
|
}
|
|
LexerError::UnfinishedString { span, .. } => (span.start, Err(self.clone()), span.end),
|
|
LexerError::OverlongCharacter { span, .. } => (span.start, Err(self.clone()), span.end),
|
|
LexerError::UnknownEscapeCharacter { span, .. } => {
|
|
(span.start, Err(self.clone()), span.end)
|
|
}
|
|
LexerError::InvalidUnicode { span, .. } => (span.start, Err(self.clone()), span.end),
|
|
}
|
|
}
|
|
}
|
|
|
|
//impl<F> From<LexerError> for Diagnostic<F> {
|
|
// fn from(value: LexerError) -> Self {
|
|
// match value {
|
|
// LexerError::IllegalControlCharacter { file, offset } => Diagnostic::error()
|
|
// .with_code("E1001")
|
|
// .with_message("Illegal control character in input stream")
|
|
// .with_label(Label::primary(file, offset..offset).with_message("illegal character")),
|
|
//
|
|
// LexerError::IllegalPrimitive { file, span } => Diagnostic::error()
|
|
// .with_code("E1002")
|
|
// .with_message("Illegal primitive; it cut off before it could finish")
|
|
// .with_label(
|
|
// Label::primary(file, span)
|
|
// .with_message("should be at least one character after the %"),
|
|
// ),
|
|
//
|
|
// LexerError::IllegalPrimitiveCharacter { file, span, char } => Diagnostic::error()
|
|
// .with_code("E1003")
|
|
// .with_message(format!("Illegal character {char:?} in primitive"))
|
|
// .with_label(Label::primary(file, span).with_message("illegal character")),
|
|
//
|
|
// LexerError::UnfinishedCharacter { file, span } => Diagnostic::error()
|
|
// .with_code("E1004")
|
|
// .with_message("Unfinished character in input stream.")
|
|
// .with_label(Label::primary(file, span).with_message("unfinished character")),
|
|
//
|
|
// LexerError::UnfinishedString { file, span } => Diagnostic::error()
|
|
// .with_code("E1005")
|
|
// .with_message("Unfinished string in input stream.")
|
|
// .with_label(Label::primary(file, span).with_message("unfinished string")),
|
|
//
|
|
// LexerError::OverlongCharacter { file, char, span } => Diagnostic::error()
|
|
// .with_code("E1006")
|
|
// .with_message(format!(
|
|
// "Character {char:?} has some extra bits at the end of it."
|
|
// ))
|
|
// .with_label(Label::primary(file, span).with_message("overlong character")),
|
|
//
|
|
// LexerError::UnknownEscapeCharacter {
|
|
// file,
|
|
// escaped_char,
|
|
// span,
|
|
// } => Diagnostic::error()
|
|
// .with_code("E1007")
|
|
// .with_message(format!("Unknown escape character {escaped_char:?}."))
|
|
// .with_label(Label::primary(file, span).with_message("unknown character")),
|
|
//
|
|
// LexerError::InvalidUnicode { file, span } => Diagnostic::error()
|
|
// .with_code("E1008")
|
|
// .with_message("Unknown or invalid unicode escape sequence.")
|
|
// .with_label(Label::primary(file, span).with_message("escape sequence")),
|
|
// }
|
|
// }
|
|
//}
|