3 files changed, 94 insertions, 13 deletions

diff --git a/crates/ra_syntax/src/yellow/builder.rs b/crates/ra_syntax/src/yellow/builder.rs
index d64053409..9fcebfb93 100644
--- a/crates/ra_syntax/src/yellow/builder.rs
+++ b/crates/ra_syntax/src/yellow/builder.rs
@@ -1,7 +1,7 @@
 use crate::{
     parser_impl::Sink,
     yellow::{GreenNode, RaTypes, SyntaxError},
-    SmolStr, SyntaxKind, TextUnit,
+    SmolStr, SyntaxKind,
 };
 use rowan::GreenNodeBuilder;
 
@@ -34,11 +34,7 @@ impl Sink for GreenBuilder {
         self.inner.finish_internal();
     }
 
-    fn error(&mut self, message: String, offset: TextUnit) {
-        let error = SyntaxError {
-            msg: message,
-            offset,
-        };
+    fn error(&mut self, error: SyntaxError) {
         self.errors.push(error)
     }
 
diff --git a/crates/ra_syntax/src/yellow/mod.rs b/crates/ra_syntax/src/yellow/mod.rs
index 650917214..6da948648 100644
--- a/crates/ra_syntax/src/yellow/mod.rs
+++ b/crates/ra_syntax/src/yellow/mod.rs
@@ -1,8 +1,9 @@
 mod builder;
+pub mod syntax_error;
 mod syntax_text;
 
 use self::syntax_text::SyntaxText;
-use crate::{SmolStr, SyntaxKind, TextRange, TextUnit};
+use crate::{SmolStr, SyntaxKind, TextRange};
 use rowan::Types;
 use std::{
     fmt,
@@ -10,6 +11,7 @@ use std::{
 };
 
 pub(crate) use self::builder::GreenBuilder;
+pub use self::syntax_error::{SyntaxError, SyntaxErrorKind, Location};
 pub use rowan::{TreeRoot, WalkEvent};
 
 #[derive(Debug, Clone, Copy)]
@@ -24,12 +26,6 @@ pub type RefRoot<'a> = ::rowan::RefRoot<'a, RaTypes>;
 
 pub type GreenNode = ::rowan::GreenNode<RaTypes>;
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
-pub struct SyntaxError {
-    pub msg: String,
-    pub offset: TextUnit,
-}
-
 #[derive(Clone, Copy)]
 pub struct SyntaxNode<R: TreeRoot<RaTypes> = OwnedRoot>(::rowan::SyntaxNode<RaTypes, R>);
 pub type SyntaxNodeRef<'a> = SyntaxNode<RefRoot<'a>>;
diff --git a/crates/ra_syntax/src/yellow/syntax_error.rs b/crates/ra_syntax/src/yellow/syntax_error.rs
new file mode 100644
index 000000000..f3df6bc15
--- /dev/null
+++ b/crates/ra_syntax/src/yellow/syntax_error.rs
@@ -0,0 +1,89 @@
+use std::fmt;
+
+use crate::{TextRange, TextUnit};
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SyntaxError {
+    kind: SyntaxErrorKind,
+    location: Location,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum Location {
+    Offset(TextUnit),
+    Range(TextRange),
+}
+
+impl Into<Location> for TextUnit {
+    fn into(self) -> Location {
+        Location::Offset(self)
+    }
+}
+
+impl Into<Location> for TextRange {
+    fn into(self) -> Location {
+        Location::Range(self)
+    }
+}
+
+impl SyntaxError {
+    pub fn new<L: Into<Location>>(kind: SyntaxErrorKind, loc: L) -> SyntaxError {
+        SyntaxError {
+            kind,
+            location: loc.into(),
+        }
+    }
+
+    pub fn location(&self) -> Location {
+        self.location.clone()
+    }
+
+    pub fn offset(&self) -> TextUnit {
+        match self.location {
+            Location::Offset(offset) => offset,
+            Location::Range(range) => range.start(),
+        }
+    }
+
+    pub fn add_offset(mut self, plus_offset: TextUnit) -> SyntaxError {
+        self.location = match self.location {
+            Location::Range(range) => Location::Range(range + plus_offset),
+            Location::Offset(offset) => Location::Offset(offset + plus_offset),
+        };
+
+        self
+    }
+}
+
+impl fmt::Display for SyntaxError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.kind.fmt(f)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum SyntaxErrorKind {
+    ParseError(ParseError),
+    EmptyChar,
+    UnclosedChar,
+    LongChar,
+    EmptyAsciiEscape,
+    InvalidAsciiEscape,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ParseError(pub String);
+
+impl fmt::Display for SyntaxErrorKind {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use self::SyntaxErrorKind::*;
+        match self {
+            EmptyAsciiEscape => write!(f, "Empty escape sequence"),
+            InvalidAsciiEscape => write!(f, "Invalid escape sequence"),
+            EmptyChar => write!(f, "Empty char literal"),
+            UnclosedChar => write!(f, "Unclosed char literal"),
+            LongChar => write!(f, "Char literal should be one character long"),
+            ParseError(msg) => write!(f, "{}", msg.0),
+        }
+    }
+}