1use std::{fmt, ops::Range};
2
3use logos::Span;
4use miette::{Diagnostic, NamedSource, SourceCode};
5use thiserror::Error;
6
7use crate::MAX_MESSAGE_FIELD_NUMBER;
8
9#[derive(Error, Diagnostic)]
11#[error("{}", kind)]
12#[diagnostic(forward(kind))]
13pub struct ParseError {
14 kind: Box<ParseErrorKind>,
15 #[related]
16 related: Vec<ParseErrorKind>,
17 #[source_code]
18 source_code: NamedSource<String>,
19}
20
21#[derive(Error, Debug, Diagnostic, PartialEq)]
22pub(crate) enum ParseErrorKind {
23 #[error("invalid token")]
24 InvalidToken {
25 #[label("found here")]
26 span: Span,
27 },
28 #[error("integer is too large")]
29 IntegerOutOfRange {
30 #[label("integer defined here")]
31 span: Span,
32 },
33 #[error("invalid string character")]
34 InvalidStringCharacters {
35 #[label("invalid characters")]
36 span: Span,
37 },
38 #[error("unterminated string")]
39 UnterminatedString {
40 #[label("string starts here")]
41 span: Span,
42 },
43 #[error("invalid string escape")]
44 InvalidStringEscape {
45 #[label("defined here")]
46 span: Span,
47 },
48 #[error("string is not valid utf-8")]
49 InvalidUtf8String {
50 #[label("defined here")]
51 span: Span,
52 },
53 #[error("nested block comments are not supported")]
54 NestedBlockComment {
55 #[label("defined here")]
56 span: Span,
57 },
58 #[error("unknown syntax '{syntax}'")]
59 #[diagnostic(help("possible values are 'proto2' and 'proto3'"))]
60 UnknownSyntax {
61 syntax: String,
62 #[label("defined here")]
63 span: Span,
64 },
65 #[error("invalid identifier")]
66 #[diagnostic(help("identifiers must consist of letters, numbers and underscores, and may not start with a number"))]
67 InvalidIdentifier {
68 #[label("defined here")]
69 span: Span,
70 },
71 #[error("invalid group name")]
72 #[diagnostic(help(
73 "group names must consist of a capital letter followed by letters, numbers and underscores"
74 ))]
75 InvalidGroupName {
76 #[label("defined here")]
77 span: Span,
78 },
79 #[error("invalid group name")]
80 #[diagnostic(help(
81 "imports may not contain backslashes, repeated forward slashes, '.' or '..' components"
82 ))]
83 InvalidImport {
84 #[label("defined here")]
85 span: Span,
86 },
87 #[error("multiple package names specified")]
88 DuplicatePackage {
89 #[label("defined here…")]
90 first: Span,
91 #[label("…and again here")]
92 second: Span,
93 },
94 #[error("whitespace is required between an integer literal and an identifier")]
95 NoSpaceBetweenIntAndIdent {
96 #[label("found here")]
97 span: Span,
98 },
99 #[error("'#' comments are not allowed here")]
100 HashCommentOutsideTextFormat {
101 #[label("found here")]
102 span: Span,
103 },
104 #[error("'f' suffix for float literals is not allowed")]
105 FloatSuffixOutsideTextFormat {
106 #[label("found here")]
107 span: Span,
108 },
109 #[error("expected {expected}, but found '{found}'")]
110 UnexpectedToken {
111 expected: String,
112 found: String,
113 #[label("found here")]
114 span: Span,
115 },
116 #[error("expected {expected}, but reached end of file")]
117 UnexpectedEof { expected: String },
118 #[error("identifiers may not be negative")]
119 NegativeIdentOutsideDefault {
120 #[label("found here")]
121 span: Span,
122 },
123 #[error("message numbers must be between 1 and {}", MAX_MESSAGE_FIELD_NUMBER)]
124 InvalidMessageNumber {
125 #[label("defined here")]
126 span: Span,
127 },
128 #[error("enum numbers must be between {} and {}", i32::MIN, i32::MAX)]
129 InvalidEnumNumber {
130 #[label("defined here")]
131 span: Span,
132 },
133 #[error("{kind} fields may not have default values")]
134 InvalidDefault {
135 kind: &'static str,
136 #[label("defined here")]
137 span: Span,
138 },
139 #[error("default values are not allowed in proto3")]
140 Proto3DefaultValue {
141 #[label("defined here")]
142 span: Span,
143 },
144 #[error("{kind} fields are not allowed in extensions")]
145 InvalidExtendFieldKind {
146 kind: &'static str,
147 #[label("defined here")]
148 span: Span,
149 },
150 #[error("extension fields may not be required")]
151 RequiredExtendField {
152 #[label("defined here")]
153 span: Span,
154 },
155 #[error("map fields cannot have labels")]
156 MapFieldWithLabel {
157 #[label("defined here")]
158 span: Span,
159 },
160 #[error("oneof fields cannot have labels")]
161 OneofFieldWithLabel {
162 #[label("defined here")]
163 span: Span,
164 },
165 #[error("fields must have a label with proto2 syntax (expected one of 'optional', 'repeated' or 'required')")]
166 Proto2FieldMissingLabel {
167 #[label("field defined here")]
168 span: Span,
169 },
170 #[error("groups are not allowed in proto3 syntax")]
171 Proto3GroupField {
172 #[label("defined here")]
173 span: Span,
174 },
175 #[error("required fields are not allowed in proto3 syntax")]
176 Proto3RequiredField {
177 #[label("defined here")]
178 span: Span,
179 },
180 #[error("{kind} fields are not allowed in a oneof")]
181 InvalidOneofFieldKind {
182 kind: &'static str,
183 #[label("defined here")]
184 span: Span,
185 },
186 #[error("a map field key type must be an integer, boolean or string")]
187 InvalidMapFieldKeyType {
188 #[label("defined here")]
189 span: Span,
190 },
191 #[error("expected value to be {expected}, but found '{actual}'")]
192 ValueInvalidType {
193 expected: String,
194 actual: String,
195 #[label("defined here")]
196 span: Span,
197 },
198 #[error("expected value to be {expected}, but the value {actual} is out of range")]
199 #[diagnostic(help("the value must be between {min} and {max} inclusive"))]
200 IntegerValueOutOfRange {
201 expected: String,
202 actual: String,
203 min: String,
204 max: String,
205 #[label("defined here")]
206 span: Span,
207 },
208 #[error("a oneof must have at least one field")]
209 EmptyOneof {
210 #[label("defined here")]
211 span: Span,
212 },
213 #[error("file is too large")]
214 #[diagnostic(help("the maximum file length is 2,147,483,647 bytes"))]
215 FileTooLarge,
216}
217
218impl ParseError {
219 pub(crate) fn new(mut related: Vec<ParseErrorKind>, name: &str, source: String) -> Self {
220 debug_assert!(!related.is_empty());
221 let kind = related.remove(0);
222 ParseError {
223 kind: Box::new(kind),
224 related,
225 source_code: NamedSource::new(name, source),
226 }
227 }
228
229 #[cfg(test)]
230 pub(crate) fn into_inner(mut self) -> Vec<ParseErrorKind> {
231 self.related.insert(0, *self.kind);
232 self.related
233 }
234
235 pub fn file(&self) -> &str {
237 self.source_code.name()
238 }
239
240 pub fn span(&self) -> Option<Range<usize>> {
242 match &*self.kind {
243 ParseErrorKind::InvalidToken { span } => Some(span.clone()),
244 ParseErrorKind::IntegerOutOfRange { span } => Some(span.clone()),
245 ParseErrorKind::InvalidStringCharacters { span } => Some(span.clone()),
246 ParseErrorKind::UnterminatedString { span } => Some(span.clone()),
247 ParseErrorKind::InvalidStringEscape { span } => Some(span.clone()),
248 ParseErrorKind::InvalidUtf8String { span } => Some(span.clone()),
249 ParseErrorKind::NestedBlockComment { span } => Some(span.clone()),
250 ParseErrorKind::UnknownSyntax { span, .. } => Some(span.clone()),
251 ParseErrorKind::InvalidIdentifier { span } => Some(span.clone()),
252 ParseErrorKind::InvalidGroupName { span } => Some(span.clone()),
253 ParseErrorKind::InvalidImport { span } => Some(span.clone()),
254 ParseErrorKind::DuplicatePackage { .. } => None,
255 ParseErrorKind::NoSpaceBetweenIntAndIdent { span } => Some(span.clone()),
256 ParseErrorKind::HashCommentOutsideTextFormat { span } => Some(span.clone()),
257 ParseErrorKind::FloatSuffixOutsideTextFormat { span } => Some(span.clone()),
258 ParseErrorKind::UnexpectedToken { span, .. } => Some(span.clone()),
259 ParseErrorKind::UnexpectedEof { .. } => None,
260 ParseErrorKind::NegativeIdentOutsideDefault { span } => Some(span.clone()),
261 ParseErrorKind::InvalidMessageNumber { span } => Some(span.clone()),
262 ParseErrorKind::InvalidEnumNumber { span } => Some(span.clone()),
263 ParseErrorKind::InvalidDefault { span, .. } => Some(span.clone()),
264 ParseErrorKind::Proto3DefaultValue { span } => Some(span.clone()),
265 ParseErrorKind::InvalidExtendFieldKind { span, .. } => Some(span.clone()),
266 ParseErrorKind::RequiredExtendField { span } => Some(span.clone()),
267 ParseErrorKind::MapFieldWithLabel { span } => Some(span.clone()),
268 ParseErrorKind::OneofFieldWithLabel { span } => Some(span.clone()),
269 ParseErrorKind::Proto2FieldMissingLabel { span } => Some(span.clone()),
270 ParseErrorKind::Proto3GroupField { span } => Some(span.clone()),
271 ParseErrorKind::Proto3RequiredField { span } => Some(span.clone()),
272 ParseErrorKind::InvalidOneofFieldKind { span, .. } => Some(span.clone()),
273 ParseErrorKind::InvalidMapFieldKeyType { span } => Some(span.clone()),
274 ParseErrorKind::ValueInvalidType { span, .. } => Some(span.clone()),
275 ParseErrorKind::IntegerValueOutOfRange { span, .. } => Some(span.clone()),
276 ParseErrorKind::EmptyOneof { span } => Some(span.clone()),
277 ParseErrorKind::FileTooLarge => None,
278 }
279 }
280}
281
282impl fmt::Debug for ParseError {
283 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
284 if let Some(span) = self.span() {
285 if let Ok(span_contents) = self.source_code.read_span(&span.into(), 0, 0) {
286 if let Some(file_name) = span_contents.name() {
287 write!(f, "{}:", file_name)?;
288 }
289
290 write!(
291 f,
292 "{}:{}: ",
293 span_contents.line() + 1,
294 span_contents.column() + 1
295 )?;
296 }
297 }
298
299 write!(f, "{}", self)
300 }
301}