pub struct Error<R> {
pub variant: ErrorVariant<R>,
pub location: InputLocation,
pub line_col: LineColLocation,
/* private fields */
}
Expand description
Parse-related error type.
Fields§
§variant: ErrorVariant<R>
Variant of the error
location: InputLocation
Location within the input string
line_col: LineColLocation
Line/column within the input string
Implementations§
source§impl<R: RuleType> Error<R>
impl<R: RuleType> Error<R>
sourcepub fn new_from_pos(variant: ErrorVariant<R>, pos: Position<'_>) -> Error<R>
pub fn new_from_pos(variant: ErrorVariant<R>, pos: Position<'_>) -> Error<R>
Creates Error
from ErrorVariant
and Position
.
Examples
let error = Error::new_from_pos(
ErrorVariant::ParsingError {
positives: vec![Rule::open_paren],
negatives: vec![Rule::closed_paren]
},
pos
);
println!("{}", error);
Examples found in repository?
src/parser_state.rs (lines 178-182)
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
pub fn state<'i, R: RuleType, F>(input: &'i str, f: F) -> Result<pairs::Pairs<'i, R>, Error<R>>
where
F: FnOnce(Box<ParserState<'i, R>>) -> ParseResult<Box<ParserState<'i, R>>>,
{
let state = ParserState::new(input);
match f(state) {
Ok(state) => {
let len = state.queue.len();
Ok(pairs::new(Rc::new(state.queue), input, 0, len))
}
Err(mut state) => {
let variant = if state.reached_call_limit() {
ErrorVariant::CustomError {
message: "call limit reached".to_owned(),
}
} else {
state.pos_attempts.sort();
state.pos_attempts.dedup();
state.neg_attempts.sort();
state.neg_attempts.dedup();
ErrorVariant::ParsingError {
positives: state.pos_attempts.clone(),
negatives: state.neg_attempts.clone(),
}
};
Err(Error::new_from_pos(
variant,
// TODO(performance): Guarantee state.attempt_pos is a valid position
position::Position::new(input, state.attempt_pos).unwrap(),
))
}
}
}
sourcepub fn new_from_span(variant: ErrorVariant<R>, span: Span<'_>) -> Error<R>
pub fn new_from_span(variant: ErrorVariant<R>, span: Span<'_>) -> Error<R>
Creates Error
from ErrorVariant
and Span
.
Examples
let error = Error::new_from_span(
ErrorVariant::ParsingError {
positives: vec![Rule::open_paren],
negatives: vec![Rule::closed_paren]
},
span
);
println!("{}", error);
sourcepub fn with_path(self, path: &str) -> Error<R>
pub fn with_path(self, path: &str) -> Error<R>
Returns Error
variant with path
which is shown when formatted with Display
.
Examples
Error::new_from_pos(
ErrorVariant::ParsingError {
positives: vec![Rule::open_paren],
negatives: vec![Rule::closed_paren]
},
pos
).with_path("file.rs");
sourcepub fn path(&self) -> Option<&str>
pub fn path(&self) -> Option<&str>
Returns the path set using Error::with_path()
.
Examples
let error = error.with_path("file.rs");
assert_eq!(Some("file.rs"), error.path());
sourcepub fn renamed_rules<F>(self, f: F) -> Error<R>where
F: FnMut(&R) -> String,
pub fn renamed_rules<F>(self, f: F) -> Error<R>where
F: FnMut(&R) -> String,
Renames all Rule
s if this is a ParsingError
. It does nothing when called on a
CustomError
.
Useful in order to rename verbose rules or have detailed per-Rule
formatting.
Examples
Error::new_from_pos(
ErrorVariant::ParsingError {
positives: vec![Rule::open_paren],
negatives: vec![Rule::closed_paren]
},
pos
).renamed_rules(|rule| {
match *rule {
Rule::open_paren => "(".to_owned(),
Rule::closed_paren => "closed paren".to_owned()
}
});
Trait Implementations§
source§impl<R> Error for Error<R>where
Self: Debug + Display,
impl<R> Error for Error<R>where
Self: Debug + Display,
1.30.0 · source§fn source(&self) -> Option<&(dyn Error + 'static)>
fn source(&self) -> Option<&(dyn Error + 'static)>
The lower-level source of this error, if any. Read more
1.0.0 · source§fn description(&self) -> &str
fn description(&self) -> &str
👎Deprecated since 1.42.0: use the Display impl or to_string()