move syntax error to parser

crates/ra_syntax/src/parsing.rs

@@ -9,7 +9,7 @@ mod grammar;
 mod reparsing;
 
 use crate::{
-    SyntaxError, SyntaxKind, SmolStr,
+    SyntaxKind, SmolStr, SyntaxError,
     parsing::{
         builder::GreenBuilder,
         input::ParserInput,
@@ -21,11 +21,14 @@ use crate::{
 
 pub use self::lexer::{tokenize, Token};
 
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ParseError(pub String);
+
 pub(crate) use self::reparsing::incremental_reparse;
 
 pub(crate) fn parse_text(text: &str) -> (GreenNode, Vec<SyntaxError>) {
     let tokens = tokenize(&text);
-    parse_with(GreenBuilder::new(), text, &tokens, grammar::root)
+    parse_with(GreenBuilder::default(), text, &tokens, grammar::root)
 }
 
 fn parse_with<S: TreeSink>(
@@ -57,7 +60,7 @@ trait TreeSink {
     /// branch as current.
     fn finish_branch(&mut self);
 
-    fn error(&mut self, error: SyntaxError);
+    fn error(&mut self, error: ParseError);
 
     /// Complete tree building. Make sure that
     /// `start_branch` and `finish_branch` calls

crates/ra_syntax/src/parsing/builder.rs

@@ -1,19 +1,24 @@
 use crate::{
-    parsing::TreeSink,
+    SmolStr, SyntaxKind, SyntaxError, SyntaxErrorKind, TextUnit,
+    parsing::{TreeSink, ParseError},
     syntax_node::{GreenNode, RaTypes},
-    SmolStr, SyntaxKind, SyntaxError,
 };
 
 use rowan::GreenNodeBuilder;
 
 pub(crate) struct GreenBuilder {
+    text_pos: TextUnit,
     errors: Vec<SyntaxError>,
     inner: GreenNodeBuilder<RaTypes>,
 }
 
-impl GreenBuilder {
-    pub(crate) fn new() -> GreenBuilder {
-        GreenBuilder { errors: Vec::new(), inner: GreenNodeBuilder::new() }
+impl Default for GreenBuilder {
+    fn default() -> GreenBuilder {
+        GreenBuilder {
+            text_pos: TextUnit::default(),
+            errors: Vec::new(),
+            inner: GreenNodeBuilder::new(),
+        }
     }
 }
 
@@ -21,6 +26,7 @@ impl TreeSink for GreenBuilder {
     type Tree = (GreenNode, Vec<SyntaxError>);
 
     fn leaf(&mut self, kind: SyntaxKind, text: SmolStr) {
+        self.text_pos += TextUnit::of_str(text.as_str());
         self.inner.leaf(kind, text);
     }
 
@@ -32,7 +38,8 @@ impl TreeSink for GreenBuilder {
         self.inner.finish_internal();
     }
 
-    fn error(&mut self, error: SyntaxError) {
+    fn error(&mut self, error: ParseError) {
+        let error = SyntaxError::new(SyntaxErrorKind::ParseError(error), self.text_pos);
         self.errors.push(error)
     }
 

crates/ra_syntax/src/parsing/event.rs

@@ -13,14 +13,9 @@ use crate::{
     SmolStr,
     SyntaxKind::{self, *},
     TextRange, TextUnit,
-    syntax_error::{
-        ParseError,
-        SyntaxError,
-        SyntaxErrorKind,
-    },
     parsing::{
+        ParseError, TreeSink,
         lexer::Token,
-        TreeSink,
     },
 };
 
@@ -159,9 +154,7 @@ impl<'a, S: TreeSink> EventProcessor<'a, S> {
                         .sum::<TextUnit>();
                     self.leaf(kind, len, n_raw_tokens);
                 }
-                Event::Error { msg } => self
-                    .sink
-                    .error(SyntaxError::new(SyntaxErrorKind::ParseError(msg), self.text_pos)),
+                Event::Error { msg } => self.sink.error(msg),
             }
         }
         self.sink

crates/ra_syntax/src/parsing/parser.rs

@@ -3,10 +3,9 @@ use std::cell::Cell;
 use drop_bomb::DropBomb;
 
 use crate::{
-    syntax_error::ParseError,
     SyntaxKind::{self, ERROR, EOF, TOMBSTONE},
     parsing::{
-        TokenSource,
+        TokenSource, ParseError,
         token_set::TokenSet,
         event::Event,
     },

crates/ra_syntax/src/parsing/reparsing.rs

@@ -61,7 +61,7 @@ fn reparse_block<'node>(
     if !is_balanced(&tokens) {
         return None;
     }
-    let (green, new_errors) = parse_with(GreenBuilder::new(), &text, &tokens, reparser);
+    let (green, new_errors) = parse_with(GreenBuilder::default(), &text, &tokens, reparser);
     Some((node, green, new_errors))
 }
 

crates/ra_syntax/src/syntax_error.rs

@@ -1,6 +1,6 @@
 use std::fmt;
 
-use crate::{TextRange, TextUnit};
+use crate::{TextRange, TextUnit, parsing::ParseError};
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct SyntaxError {
@@ -95,9 +95,6 @@ pub enum SyntaxErrorKind {
     InvalidMatchInnerAttr,
 }
 
-#[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::*;