26 files changed, 435 insertions, 608 deletions

diff --git a/crates/gen_lsp_server/Cargo.toml b/crates/gen_lsp_server/Cargo.toml
index 36a29265c..d0ca19f52 100644
--- a/crates/gen_lsp_server/Cargo.toml
+++ b/crates/gen_lsp_server/Cargo.toml
@@ -15,4 +15,4 @@ serde = { version = "1.0.83", features = ["derive"] }
 crossbeam-channel = "0.3.5"
 
 [dev-dependencies]
-flexi_logger = "0.13.0"
+flexi_logger = "0.14.0"
diff --git a/crates/ra_cli/Cargo.toml b/crates/ra_cli/Cargo.toml
index 4d9c41ae9..970cb1f82 100644
--- a/crates/ra_cli/Cargo.toml
+++ b/crates/ra_cli/Cargo.toml
@@ -7,7 +7,7 @@ publish = false
 
 [dependencies]
 clap = "2.32.0"
-flexi_logger = "0.13.0"
+flexi_logger = "0.14.0"
 indicatif = "0.11.0"
 
 ra_syntax = { path = "../ra_syntax" }
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index fc9bc33d2..c2c6921cb 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -256,6 +256,14 @@ impl SourceAnalyzer {
         Some(self.infer.as_ref()?[pat_id].clone())
     }
 
+    pub fn type_of_pat_by_id(
+        &self,
+        _db: &impl HirDatabase,
+        pat_id: expr::PatId,
+    ) -> Option<crate::Ty> {
+        Some(self.infer.as_ref()?[pat_id].clone())
+    }
+
     pub fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<Function> {
         let expr_id = self.body_source_map.as_ref()?.node_expr(&call.clone().into())?;
         self.infer.as_ref()?.method_resolution(expr_id)
diff --git a/crates/ra_ide_api/src/completion/presentation.rs b/crates/ra_ide_api/src/completion/presentation.rs
index 98060947a..5cf55a496 100644
--- a/crates/ra_ide_api/src/completion/presentation.rs
+++ b/crates/ra_ide_api/src/completion/presentation.rs
@@ -1,5 +1,5 @@
 //! This modules takes care of rendering various defenitions as completion items.
-use hir::{Docs, HasSource, HirDisplay, PerNs, Resolution};
+use hir::{Docs, HasSource, HirDisplay, PerNs, Resolution, Ty};
 use join_to_string::join;
 use ra_syntax::ast::NameOwner;
 use test_utils::tested_by;
@@ -80,10 +80,18 @@ impl Completions {
                 None,
             ),
         };
-        CompletionItem::new(completion_kind, ctx.source_range(), local_name)
-            .kind(kind)
-            .set_documentation(docs)
-            .add_to(self)
+
+        let mut completion_item =
+            CompletionItem::new(completion_kind, ctx.source_range(), local_name);
+        if let Resolution::LocalBinding(pat_id) = def {
+            let ty = ctx
+                .analyzer
+                .type_of_pat_by_id(ctx.db, pat_id.clone())
+                .filter(|t| t != &Ty::Unknown)
+                .map(|t| t.display(ctx.db).to_string());
+            completion_item = completion_item.set_detail(ty);
+        };
+        completion_item.kind(kind).set_documentation(docs).add_to(self)
     }
 
     pub(crate) fn add_function(&mut self, ctx: &CompletionContext, func: hir::Function) {
diff --git a/crates/ra_ide_api/src/completion/snapshots/completion_item__bindings_from_if_let.snap b/crates/ra_ide_api/src/completion/snapshots/completion_item__bindings_from_if_let.snap
index 2a22201ad..f94477b43 100644
--- a/crates/ra_ide_api/src/completion/snapshots/completion_item__bindings_from_if_let.snap
+++ b/crates/ra_ide_api/src/completion/snapshots/completion_item__bindings_from_if_let.snap
@@ -1,5 +1,5 @@
 ---
-created: "2019-05-23T22:23:35.122168608Z"
+created: "2019-07-23T16:11:48.828805910Z"
 creator: [email protected]
 source: crates/ra_ide_api/src/completion/completion_item.rs
 expression: kind_completions
@@ -18,6 +18,7 @@ expression: kind_completions
         delete: [214; 214),
         insert: "b",
         kind: Binding,
+        detail: "i32",
     },
     CompletionItem {
         label: "quux",
diff --git a/crates/ra_ide_api/src/completion/snapshots/completion_item__bindings_from_let.snap b/crates/ra_ide_api/src/completion/snapshots/completion_item__bindings_from_let.snap
index b9a5dc9c8..590e2a820 100644
--- a/crates/ra_ide_api/src/completion/snapshots/completion_item__bindings_from_let.snap
+++ b/crates/ra_ide_api/src/completion/snapshots/completion_item__bindings_from_let.snap
@@ -1,5 +1,5 @@
 ---
-created: "2019-05-23T22:23:35.122797188Z"
+created: "2019-07-23T16:11:48.828811567Z"
 creator: [email protected]
 source: crates/ra_ide_api/src/completion/completion_item.rs
 expression: kind_completions
@@ -19,6 +19,7 @@ expression: kind_completions
         delete: [79; 79),
         insert: "x",
         kind: Binding,
+        detail: "i32",
     },
     CompletionItem {
         label: "y",
@@ -26,5 +27,6 @@ expression: kind_completions
         delete: [79; 79),
         insert: "y",
         kind: Binding,
+        detail: "i32",
     },
 ]
diff --git a/crates/ra_ide_api/src/completion/snapshots/completion_item__dont_show_both_completions_for_shadowing.snap b/crates/ra_ide_api/src/completion/snapshots/completion_item__dont_show_both_completions_for_shadowing.snap
index 57434210d..158a2e5b9 100644
--- a/crates/ra_ide_api/src/completion/snapshots/completion_item__dont_show_both_completions_for_shadowing.snap
+++ b/crates/ra_ide_api/src/completion/snapshots/completion_item__dont_show_both_completions_for_shadowing.snap
@@ -1,5 +1,5 @@
 ---
-created: "2019-05-23T22:23:35.142044205Z"
+created: "2019-07-23T16:11:48.860949870Z"
 creator: [email protected]
 source: crates/ra_ide_api/src/completion/completion_item.rs
 expression: kind_completions
@@ -11,6 +11,7 @@ expression: kind_completions
         delete: [126; 126),
         insert: "bar",
         kind: Binding,
+        detail: "i32",
     },
     CompletionItem {
         label: "foo",
diff --git a/crates/ra_ide_api/src/completion/snapshots/completion_item__self_in_methods.snap b/crates/ra_ide_api/src/completion/snapshots/completion_item__self_in_methods.snap
index e1af94870..b7bcbe864 100644
--- a/crates/ra_ide_api/src/completion/snapshots/completion_item__self_in_methods.snap
+++ b/crates/ra_ide_api/src/completion/snapshots/completion_item__self_in_methods.snap
@@ -1,5 +1,5 @@
 ---
-created: "2019-05-23T22:23:35.141900902Z"
+created: "2019-07-23T16:11:48.859812318Z"
 creator: [email protected]
 source: crates/ra_ide_api/src/completion/completion_item.rs
 expression: kind_completions
@@ -18,5 +18,6 @@ expression: kind_completions
         delete: [25; 25),
         insert: "self",
         kind: Binding,
+        detail: "&{unknown}",
     },
 ]
diff --git a/crates/ra_ide_api/src/inlay_hints.rs b/crates/ra_ide_api/src/inlay_hints.rs
new file mode 100644
index 000000000..174662beb
--- /dev/null
+++ b/crates/ra_ide_api/src/inlay_hints.rs
@@ -0,0 +1,180 @@
+use crate::{db::RootDatabase, FileId};
+use hir::{HirDisplay, Ty};
+use ra_syntax::ast::Pat;
+use ra_syntax::{
+    algo::visit::{visitor, Visitor},
+    ast::{self, PatKind, TypeAscriptionOwner},
+    AstNode, SmolStr, SourceFile, SyntaxNode, TextRange,
+};
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum InlayKind {
+    LetBindingType,
+    ClosureParameterType,
+}
+
+#[derive(Debug)]
+pub struct InlayHint {
+    pub range: TextRange,
+    pub kind: InlayKind,
+    pub label: SmolStr,
+}
+
+pub(crate) fn inlay_hints(db: &RootDatabase, file_id: FileId, file: &SourceFile) -> Vec<InlayHint> {
+    file.syntax()
+        .descendants()
+        .map(|node| get_inlay_hints(db, file_id, &node).unwrap_or_default())
+        .flatten()
+        .collect()
+}
+
+fn get_inlay_hints(
+    db: &RootDatabase,
+    file_id: FileId,
+    node: &SyntaxNode,
+) -> Option<Vec<InlayHint>> {
+    visitor()
+        .visit(|let_statement: ast::LetStmt| {
+            let let_syntax = let_statement.syntax();
+
+            if let_statement.ascribed_type().is_some() {
+                return None;
+            }
+
+            let let_pat = let_statement.pat()?;
+            let inlay_type_string = get_node_displayable_type(db, file_id, let_syntax, &let_pat)?
+                .display(db)
+                .to_string()
+                .into();
+
+            let pat_range = match let_pat.kind() {
+                PatKind::BindPat(bind_pat) => bind_pat.syntax().text_range(),
+                PatKind::TuplePat(tuple_pat) => tuple_pat.syntax().text_range(),
+                _ => return None,
+            };
+
+            Some(vec![InlayHint {
+                range: pat_range,
+                kind: InlayKind::LetBindingType,
+                label: inlay_type_string,
+            }])
+        })
+        .visit(|closure_parameter: ast::LambdaExpr| match closure_parameter.param_list() {
+            Some(param_list) => Some(
+                param_list
+                    .params()
+                    .filter(|closure_param| closure_param.ascribed_type().is_none())
+                    .filter_map(|closure_param| {
+                        let closure_param_syntax = closure_param.syntax();
+                        let inlay_type_string = get_node_displayable_type(
+                            db,
+                            file_id,
+                            closure_param_syntax,
+                            &closure_param.pat()?,
+                        )?
+                        .display(db)
+                        .to_string()
+                        .into();
+
+                        Some(InlayHint {
+                            range: closure_param_syntax.text_range(),
+                            kind: InlayKind::ClosureParameterType,
+                            label: inlay_type_string,
+                        })
+                    })
+                    .collect(),
+            ),
+            None => None,
+        })
+        .accept(&node)?
+}
+
+fn get_node_displayable_type(
+    db: &RootDatabase,
+    file_id: FileId,
+    node_syntax: &SyntaxNode,
+    node_pat: &Pat,
+) -> Option<Ty> {
+    let analyzer = hir::SourceAnalyzer::new(db, file_id, node_syntax, None);
+    analyzer.type_of_pat(db, node_pat).and_then(|resolved_type| {
+        if let Ty::Apply(_) = resolved_type {
+            Some(resolved_type)
+        } else {
+            None
+        }
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::mock_analysis::single_file;
+    use insta::assert_debug_snapshot_matches;
+
+    #[test]
+    fn test_inlay_hints() {
+        let (analysis, file_id) = single_file(
+            r#"
+struct OuterStruct {}
+
+fn main() {
+    struct InnerStruct {}
+
+    let test = 54;
+    let test = InnerStruct {};
+    let test = OuterStruct {};
+    let test = vec![222];
+    let mut test = Vec::new();
+    test.push(333);
+    let test = test.into_iter().map(|i| i * i).collect::<Vec<_>>();
+    let mut test = 33;
+    let _ = 22;
+    let test: Vec<_> = (0..3).collect();
+
+    let _ = (0..23).map(|i: u32| {
+        let i_squared = i * i;
+        i_squared
+    });
+
+    let test: i32 = 33;
+
+    let (x, c) = (42, 'a');
+    let test = (42, 'a');
+}
+"#,
+        );
+
+        assert_debug_snapshot_matches!(analysis.inlay_hints(file_id).unwrap(), @r#"[
+    InlayHint {
+        range: [71; 75),
+        kind: LetBindingType,
+        label: "i32",
+    },
+    InlayHint {
+        range: [121; 125),
+        kind: LetBindingType,
+        label: "OuterStruct",
+    },
+    InlayHint {
+        range: [297; 305),
+        kind: LetBindingType,
+        label: "i32",
+    },
+    InlayHint {
+        range: [417; 426),
+        kind: LetBindingType,
+        label: "u32",
+    },
+    InlayHint {
+        range: [496; 502),
+        kind: LetBindingType,
+        label: "(i32, char)",
+    },
+    InlayHint {
+        range: [524; 528),
+        kind: LetBindingType,
+        label: "(i32, char)",
+    },
+]"#
+        );
+    }
+}
diff --git a/crates/ra_ide_api/src/lib.rs b/crates/ra_ide_api/src/lib.rs
index c54d574bc..16ffb03ce 100644
--- a/crates/ra_ide_api/src/lib.rs
+++ b/crates/ra_ide_api/src/lib.rs
@@ -38,6 +38,7 @@ mod join_lines;
 mod typing;
 mod matching_brace;
 mod display;
+mod inlay_hints;
 
 #[cfg(test)]
 mod marks;
@@ -64,6 +65,7 @@ pub use crate::{
     display::{file_structure, FunctionSignature, NavigationTarget, StructureNode},
     folding_ranges::{Fold, FoldKind},
     hover::HoverResult,
+    inlay_hints::{InlayHint, InlayKind},
     line_index::{LineCol, LineIndex},
     line_index_utils::translate_offset_with_edit,
     references::ReferenceSearchResult,
@@ -396,6 +398,11 @@ impl Analysis {
         file_structure(&parse.tree())
     }
 
+    /// Returns a list of the places in the file where type hints can be displayed.
+    pub fn inlay_hints(&self, file_id: FileId) -> Cancelable<Vec<InlayHint>> {
+        self.with_db(|db| inlay_hints::inlay_hints(db, file_id, &db.parse(file_id).tree()))
+    }
+
     /// Returns the set of folding ranges.
     pub fn folding_ranges(&self, file_id: FileId) -> Vec<Fold> {
         let parse = self.db.parse(file_id);
diff --git a/crates/ra_lsp_server/Cargo.toml b/crates/ra_lsp_server/Cargo.toml
index e73e0b419..cec360667 100644
--- a/crates/ra_lsp_server/Cargo.toml
+++ b/crates/ra_lsp_server/Cargo.toml
@@ -10,7 +10,7 @@ relative-path = "0.4.0"
 serde_json = "1.0.34"
 serde = { version = "1.0.83", features = ["derive"] }
 crossbeam-channel = "0.3.5"
-flexi_logger = "0.13.0"
+flexi_logger = "0.14.0"
 log = "0.4.3"
 url_serde = "0.2.0"
 lsp-types = { version = "0.59.0", features = ["proposed"] }
diff --git a/crates/ra_lsp_server/src/main_loop.rs b/crates/ra_lsp_server/src/main_loop.rs
index 668d2fd72..8e830c8b8 100644
--- a/crates/ra_lsp_server/src/main_loop.rs
+++ b/crates/ra_lsp_server/src/main_loop.rs
@@ -362,6 +362,7 @@ fn on_request(
         .on::<req::References>(handlers::handle_references)?
         .on::<req::Formatting>(handlers::handle_formatting)?
         .on::<req::DocumentHighlightRequest>(handlers::handle_document_highlight)?
+        .on::<req::InlayHints>(handlers::handle_inlay_hints)?
         .finish();
     Ok(())
 }
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index 68865b755..5bf950a53 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -21,7 +21,7 @@ use url_serde::Ser;
 use crate::{
     cargo_target_spec::{runnable_args, CargoTargetSpec},
     conv::{to_location, Conv, ConvWith, MapConvWith, TryConvWith, TryConvWithToVec},
-    req::{self, Decoration},
+    req::{self, Decoration, InlayHint, InlayHintsParams, InlayKind},
     world::WorldSnapshot,
     LspError, Result,
 };
@@ -874,3 +874,24 @@ fn to_diagnostic_severity(severity: Severity) -> DiagnosticSeverity {
         WeakWarning => DiagnosticSeverity::Hint,
     }
 }
+
+pub fn handle_inlay_hints(
+    world: WorldSnapshot,
+    params: InlayHintsParams,
+) -> Result<Vec<InlayHint>> {
+    let file_id = params.text_document.try_conv_with(&world)?;
+    let analysis = world.analysis();
+    let line_index = analysis.file_line_index(file_id);
+    Ok(analysis
+        .inlay_hints(file_id)?
+        .into_iter()
+        .map(|api_type| InlayHint {
+            label: api_type.label.to_string(),
+            range: api_type.range.conv_with(&line_index),
+            kind: match api_type.kind {
+                ra_ide_api::InlayKind::LetBindingType => InlayKind::LetBindingType,
+                ra_ide_api::InlayKind::ClosureParameterType => InlayKind::ClosureParameterType,
+            },
+        })
+        .collect())
+}
diff --git a/crates/ra_lsp_server/src/req.rs b/crates/ra_lsp_server/src/req.rs
index 8d39b04a7..916185f99 100644
--- a/crates/ra_lsp_server/src/req.rs
+++ b/crates/ra_lsp_server/src/req.rs
@@ -196,3 +196,30 @@ pub struct SourceChange {
     pub workspace_edit: WorkspaceEdit,
     pub cursor_position: Option<TextDocumentPositionParams>,
 }
+
+pub enum InlayHints {}
+
+impl Request for InlayHints {
+    type Params = InlayHintsParams;
+    type Result = Vec<InlayHint>;
+    const METHOD: &'static str = "rust-analyzer/inlayHints";
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct InlayHintsParams {
+    pub text_document: TextDocumentIdentifier,
+}
+
+#[derive(Debug, PartialEq, Eq, Deserialize, Serialize)]
+pub enum InlayKind {
+    LetBindingType,
+    ClosureParameterType,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct InlayHint {
+    pub range: Range,
+    pub kind: InlayKind,
+    pub label: String,
+}
diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index 97b6b047f..9ef8dee5d 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -11,6 +11,7 @@ repository = "https://github.com/rust-analyzer/rust-analyzer"
 unicode-xid = "0.1.0"
 itertools = "0.8.0"
 rowan = "0.6.0-pre.1"
+ra_rustc_lexer = { version = "0.1.0-pre.1", features = [ "unicode-xid" ] }
 
 # ideally, `serde` should be enabled by `ra_lsp_server`, but we enable it here
 # to reduce number of compilations
diff --git a/crates/ra_syntax/src/parsing/lexer.rs b/crates/ra_syntax/src/parsing/lexer.rs
index 60cf37047..2a4343b0a 100644
--- a/crates/ra_syntax/src/parsing/lexer.rs
+++ b/crates/ra_syntax/src/parsing/lexer.rs
@@ -1,22 +1,6 @@
-mod classes;
-mod comments;
-mod numbers;
-mod ptr;
-mod strings;
-
 use crate::{
     SyntaxKind::{self, *},
-    TextUnit, T,
-};
-
-use self::{
-    classes::*,
-    comments::{scan_comment, scan_shebang},
-    numbers::scan_number,
-    ptr::Ptr,
-    strings::{
-        is_string_literal_start, scan_byte_char_or_string, scan_char, scan_raw_string, scan_string,
-    },
+    TextUnit,
 };
 
 /// A token of Rust source.
@@ -30,149 +14,134 @@ pub struct Token {
 
 /// Break a string up into its component tokens
 pub fn tokenize(text: &str) -> Vec<Token> {
+    if text.is_empty() {
+        return vec![];
+    }
     let mut text = text;
     let mut acc = Vec::new();
-    while !text.is_empty() {
-        let token = next_token(text);
-        acc.push(token);
-        let len: u32 = token.len.into();
-        text = &text[len as usize..];
-    }
-    acc
-}
-
-/// Get the next token from a string
-pub fn next_token(text: &str) -> Token {
-    assert!(!text.is_empty());
-    let mut ptr = Ptr::new(text);
-    let c = ptr.bump().unwrap();
-    let kind = next_token_inner(c, &mut ptr);
-    let len = ptr.into_len();
-    Token { kind, len }
-}
-
-fn next_token_inner(c: char, ptr: &mut Ptr) -> SyntaxKind {
-    if is_whitespace(c) {
-        ptr.bump_while(is_whitespace);
-        return WHITESPACE;
+    if let Some(len) = ra_rustc_lexer::strip_shebang(text) {
+        acc.push(Token { kind: SHEBANG, len: TextUnit::from_usize(len) });
+        text = &text[len..];
     }
-
-    match c {
-        '#' => {
-            if scan_shebang(ptr) {
-                return SHEBANG;
-            }
-        }
-        '/' => {
-            if let Some(kind) = scan_comment(ptr) {
-                return kind;
-            }
+    while !text.is_empty() {
+        let rustc_token = ra_rustc_lexer::first_token(text);
+        macro_rules! decompose {
+            ($t1:expr, $t2:expr) => {{
+                acc.push(Token { kind: $t1, len: 1.into() });
+                acc.push(Token { kind: $t2, len: 1.into() });
+                text = &text[2..];
+                continue;
+            }};
+            ($t1:expr, $t2:expr, $t3:expr) => {{
+                acc.push(Token { kind: $t1, len: 1.into() });
+                acc.push(Token { kind: $t2, len: 1.into() });
+                acc.push(Token { kind: $t3, len: 1.into() });
+                text = &text[3..];
+                continue;
+            }};
         }
-        _ => (),
-    }
-
-    let ident_start = is_ident_start(c) && !is_string_literal_start(c, ptr.current(), ptr.nth(1));
-    if ident_start {
-        return scan_ident(c, ptr);
-    }
-
-    if is_dec_digit(c) {
-        let kind = scan_number(c, ptr);
-        scan_literal_suffix(ptr);
-        return kind;
-    }
-
-    // One-byte tokens.
-    if let Some(kind) = SyntaxKind::from_char(c) {
-        return kind;
-    }
-
-    match c {
-        // Possiblily multi-byte tokens,
-        // but we only produce single byte token now
-        // T![...], T![..], T![..=], T![.]
-        '.' => return T![.],
-        // T![::] T![:]
-        ':' => return T![:],
-        // T![==] FATARROW T![=]
-        '=' => return T![=],
-        // T![!=] T![!]
-        '!' => return T![!],
-        // T![->] T![-]
-        '-' => return T![-],
-
-        // If the character is an ident start not followed by another single
-        // quote, then this is a lifetime name:
-        '\'' => {
-            return if ptr.at_p(is_ident_start) && !ptr.at_str("''") {
-                ptr.bump();
-                while ptr.at_p(is_ident_continue) {
-                    ptr.bump();
+        let kind = match rustc_token.kind {
+            ra_rustc_lexer::TokenKind::LineComment => COMMENT,
+            ra_rustc_lexer::TokenKind::BlockComment { .. } => COMMENT,
+            ra_rustc_lexer::TokenKind::Whitespace => WHITESPACE,
+            ra_rustc_lexer::TokenKind::Ident => {
+                let token_text = &text[..rustc_token.len];
+                if token_text == "_" {
+                    UNDERSCORE
+                } else {
+                    SyntaxKind::from_keyword(&text[..rustc_token.len]).unwrap_or(IDENT)
                 }
-                // lifetimes shouldn't end with a single quote
-                // if we find one, then this is an invalid character literal
-                if ptr.at('\'') {
-                    ptr.bump();
-                    return CHAR;
-                }
-                LIFETIME
-            } else {
-                scan_char(ptr);
-                scan_literal_suffix(ptr);
-                CHAR
-            };
-        }
-        'b' => {
-            let kind = scan_byte_char_or_string(ptr);
-            scan_literal_suffix(ptr);
-            return kind;
-        }
-        '"' => {
-            scan_string(ptr);
-            scan_literal_suffix(ptr);
-            return STRING;
-        }
-        'r' => {
-            scan_raw_string(ptr);
-            scan_literal_suffix(ptr);
-            return RAW_STRING;
-        }
-        _ => (),
-    }
-    ERROR
-}
-
-fn scan_ident(c: char, ptr: &mut Ptr) -> SyntaxKind {
-    let is_raw = match (c, ptr.current()) {
-        ('r', Some('#')) => {
-            ptr.bump();
-            true
-        }
-        ('_', None) => return T![_],
-        ('_', Some(c)) if !is_ident_continue(c) => return T![_],
-        _ => false,
-    };
-    ptr.bump_while(is_ident_continue);
-    if !is_raw {
-        if let Some(kind) = SyntaxKind::from_keyword(ptr.current_token_text()) {
-            return kind;
-        }
-    }
-    IDENT
-}
-
-fn scan_literal_suffix(ptr: &mut Ptr) {
-    if ptr.at_p(is_ident_start) {
-        ptr.bump();
+            }
+            ra_rustc_lexer::TokenKind::RawIdent => IDENT,
+            ra_rustc_lexer::TokenKind::Literal { kind, .. } => match kind {
+                ra_rustc_lexer::LiteralKind::Int { .. } => INT_NUMBER,
+                ra_rustc_lexer::LiteralKind::Float { .. } => FLOAT_NUMBER,
+                ra_rustc_lexer::LiteralKind::Char { .. } => CHAR,
+                ra_rustc_lexer::LiteralKind::Byte { .. } => BYTE,
+                ra_rustc_lexer::LiteralKind::Str { .. } => STRING,
+                ra_rustc_lexer::LiteralKind::ByteStr { .. } => BYTE_STRING,
+                ra_rustc_lexer::LiteralKind::RawStr { .. } => RAW_STRING,
+                ra_rustc_lexer::LiteralKind::RawByteStr { .. } => RAW_BYTE_STRING,
+            },
+            ra_rustc_lexer::TokenKind::Lifetime { .. } => LIFETIME,
+            ra_rustc_lexer::TokenKind::Semi => SEMI,
+            ra_rustc_lexer::TokenKind::Comma => COMMA,
+            ra_rustc_lexer::TokenKind::DotDotDot => decompose!(DOT, DOT, DOT),
+            ra_rustc_lexer::TokenKind::DotDotEq => decompose!(DOT, DOT, EQ),
+            ra_rustc_lexer::TokenKind::DotDot => decompose!(DOT, DOT),
+            ra_rustc_lexer::TokenKind::Dot => DOT,
+            ra_rustc_lexer::TokenKind::OpenParen => L_PAREN,
+            ra_rustc_lexer::TokenKind::CloseParen => R_PAREN,
+            ra_rustc_lexer::TokenKind::OpenBrace => L_CURLY,
+            ra_rustc_lexer::TokenKind::CloseBrace => R_CURLY,
+            ra_rustc_lexer::TokenKind::OpenBracket => L_BRACK,
+            ra_rustc_lexer::TokenKind::CloseBracket => R_BRACK,
+            ra_rustc_lexer::TokenKind::At => AT,
+            ra_rustc_lexer::TokenKind::Pound => POUND,
+            ra_rustc_lexer::TokenKind::Tilde => TILDE,
+            ra_rustc_lexer::TokenKind::Question => QUESTION,
+            ra_rustc_lexer::TokenKind::ColonColon => decompose!(COLON, COLON),
+            ra_rustc_lexer::TokenKind::Colon => COLON,
+            ra_rustc_lexer::TokenKind::Dollar => DOLLAR,
+            ra_rustc_lexer::TokenKind::EqEq => decompose!(EQ, EQ),
+            ra_rustc_lexer::TokenKind::Eq => EQ,
+            ra_rustc_lexer::TokenKind::FatArrow => decompose!(EQ, R_ANGLE),
+            ra_rustc_lexer::TokenKind::Ne => decompose!(EXCL, EQ),
+            ra_rustc_lexer::TokenKind::Not => EXCL,
+            ra_rustc_lexer::TokenKind::Le => decompose!(L_ANGLE, EQ),
+            ra_rustc_lexer::TokenKind::LArrow => decompose!(COLON, MINUS),
+            ra_rustc_lexer::TokenKind::Lt => L_ANGLE,
+            ra_rustc_lexer::TokenKind::ShlEq => decompose!(L_ANGLE, L_ANGLE, EQ),
+            ra_rustc_lexer::TokenKind::Shl => decompose!(L_ANGLE, L_ANGLE),
+            ra_rustc_lexer::TokenKind::Ge => decompose!(R_ANGLE, EQ),
+            ra_rustc_lexer::TokenKind::Gt => R_ANGLE,
+            ra_rustc_lexer::TokenKind::ShrEq => decompose!(R_ANGLE, R_ANGLE, EQ),
+            ra_rustc_lexer::TokenKind::Shr => decompose!(R_ANGLE, R_ANGLE),
+            ra_rustc_lexer::TokenKind::RArrow => decompose!(MINUS, R_ANGLE),
+            ra_rustc_lexer::TokenKind::Minus => MINUS,
+            ra_rustc_lexer::TokenKind::MinusEq => decompose!(MINUS, EQ),
+            ra_rustc_lexer::TokenKind::And => AMP,
+            ra_rustc_lexer::TokenKind::AndAnd => decompose!(AMP, AMP),
+            ra_rustc_lexer::TokenKind::AndEq => decompose!(AMP, EQ),
+            ra_rustc_lexer::TokenKind::Or => PIPE,
+            ra_rustc_lexer::TokenKind::OrOr => decompose!(PIPE, PIPE),
+            ra_rustc_lexer::TokenKind::OrEq => decompose!(PIPE, EQ),
+            ra_rustc_lexer::TokenKind::PlusEq => decompose!(PLUS, EQ),
+            ra_rustc_lexer::TokenKind::Plus => PLUS,
+            ra_rustc_lexer::TokenKind::StarEq => decompose!(STAR, EQ),
+            ra_rustc_lexer::TokenKind::Star => STAR,
+            ra_rustc_lexer::TokenKind::SlashEq => decompose!(SLASH, EQ),
+            ra_rustc_lexer::TokenKind::Slash => SLASH,
+            ra_rustc_lexer::TokenKind::CaretEq => decompose!(CARET, EQ),
+            ra_rustc_lexer::TokenKind::Caret => CARET,
+            ra_rustc_lexer::TokenKind::PercentEq => decompose!(PERCENT, EQ),
+            ra_rustc_lexer::TokenKind::Percent => PERCENT,
+            ra_rustc_lexer::TokenKind::Unknown => ERROR,
+        };
+        let token = Token { kind, len: TextUnit::from_usize(rustc_token.len) };
+        acc.push(token);
+        text = &text[rustc_token.len..];
     }
-    ptr.bump_while(is_ident_continue);
+    acc
 }
 
 pub fn classify_literal(text: &str) -> Option<Token> {
-    let tkn = next_token(text);
-    if !tkn.kind.is_literal() || tkn.len.to_usize() != text.len() {
+    let t = ra_rustc_lexer::first_token(text);
+    if t.len != text.len() {
         return None;
     }
-
-    Some(tkn)
+    let kind = match t.kind {
+        ra_rustc_lexer::TokenKind::Literal { kind, .. } => match kind {
+            ra_rustc_lexer::LiteralKind::Int { .. } => INT_NUMBER,
+            ra_rustc_lexer::LiteralKind::Float { .. } => FLOAT_NUMBER,
+            ra_rustc_lexer::LiteralKind::Char { .. } => CHAR,
+            ra_rustc_lexer::LiteralKind::Byte { .. } => BYTE,
+            ra_rustc_lexer::LiteralKind::Str { .. } => STRING,
+            ra_rustc_lexer::LiteralKind::ByteStr { .. } => BYTE_STRING,
+            ra_rustc_lexer::LiteralKind::RawStr { .. } => RAW_STRING,
+            ra_rustc_lexer::LiteralKind::RawByteStr { .. } => RAW_BYTE_STRING,
+        },
+        _ => return None,
+    };
+    Some(Token { kind, len: TextUnit::from_usize(t.len) })
 }
diff --git a/crates/ra_syntax/src/parsing/lexer/classes.rs b/crates/ra_syntax/src/parsing/lexer/classes.rs
deleted file mode 100644
index 4235d2648..000000000
--- a/crates/ra_syntax/src/parsing/lexer/classes.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-use unicode_xid::UnicodeXID;
-
-pub fn is_ident_start(c: char) -> bool {
-    (c >= 'a' && c <= 'z')
-        || (c >= 'A' && c <= 'Z')
-        || c == '_'
-        || (c > '\x7f' && UnicodeXID::is_xid_start(c))
-}
-
-pub fn is_ident_continue(c: char) -> bool {
-    (c >= 'a' && c <= 'z')
-        || (c >= 'A' && c <= 'Z')
-        || (c >= '0' && c <= '9')
-        || c == '_'
-        || (c > '\x7f' && UnicodeXID::is_xid_continue(c))
-}
-
-pub fn is_whitespace(c: char) -> bool {
-    //FIXME: use is_pattern_whitespace
-    //https://github.com/behnam/rust-unic/issues/192
-    c.is_whitespace()
-}
-
-pub fn is_dec_digit(c: char) -> bool {
-    '0' <= c && c <= '9'
-}
diff --git a/crates/ra_syntax/src/parsing/lexer/comments.rs b/crates/ra_syntax/src/parsing/lexer/comments.rs
deleted file mode 100644
index 8bbbe659b..000000000
--- a/crates/ra_syntax/src/parsing/lexer/comments.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-use crate::parsing::lexer::ptr::Ptr;
-
-use crate::SyntaxKind::{self, *};
-
-pub(crate) fn scan_shebang(ptr: &mut Ptr) -> bool {
-    if ptr.at_str("!/") {
-        ptr.bump();
-        ptr.bump();
-        bump_until_eol(ptr);
-        true
-    } else {
-        false
-    }
-}
-
-fn scan_block_comment(ptr: &mut Ptr) -> Option<SyntaxKind> {
-    if ptr.at('*') {
-        ptr.bump();
-        let mut depth: u32 = 1;
-        while depth > 0 {
-            if ptr.at_str("*/") {
-                depth -= 1;
-                ptr.bump();
-                ptr.bump();
-            } else if ptr.at_str("/*") {
-                depth += 1;
-                ptr.bump();
-                ptr.bump();
-            } else if ptr.bump().is_none() {
-                break;
-            }
-        }
-        Some(COMMENT)
-    } else {
-        None
-    }
-}
-
-pub(crate) fn scan_comment(ptr: &mut Ptr) -> Option<SyntaxKind> {
-    if ptr.at('/') {
-        bump_until_eol(ptr);
-        Some(COMMENT)
-    } else {
-        scan_block_comment(ptr)
-    }
-}
-
-fn bump_until_eol(ptr: &mut Ptr) {
-    loop {
-        if ptr.at('\n') || ptr.at_str("\r\n") {
-            return;
-        }
-        if ptr.bump().is_none() {
-            break;
-        }
-    }
-}
diff --git a/crates/ra_syntax/src/parsing/lexer/numbers.rs b/crates/ra_syntax/src/parsing/lexer/numbers.rs
deleted file mode 100644
index e53ae231b..000000000
--- a/crates/ra_syntax/src/parsing/lexer/numbers.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-use crate::parsing::lexer::{classes::*, ptr::Ptr};
-
-use crate::SyntaxKind::{self, *};
-
-pub(crate) fn scan_number(c: char, ptr: &mut Ptr) -> SyntaxKind {
-    if c == '0' {
-        match ptr.current().unwrap_or('\0') {
-            'b' | 'o' => {
-                ptr.bump();
-                scan_digits(ptr, false);
-            }
-            'x' => {
-                ptr.bump();
-                scan_digits(ptr, true);
-            }
-            '0'..='9' | '_' | '.' | 'e' | 'E' => {
-                scan_digits(ptr, true);
-            }
-            _ => return INT_NUMBER,
-        }
-    } else {
-        scan_digits(ptr, false);
-    }
-
-    // might be a float, but don't be greedy if this is actually an
-    // integer literal followed by field/method access or a range pattern
-    // (`0..2` and `12.foo()`)
-    if ptr.at('.') && !(ptr.at_str("..") || ptr.nth_is_p(1, is_ident_start)) {
-        // might have stuff after the ., and if it does, it needs to start
-        // with a number
-        ptr.bump();
-        scan_digits(ptr, false);
-        scan_float_exponent(ptr);
-        return FLOAT_NUMBER;
-    }
-    // it might be a float if it has an exponent
-    if ptr.at('e') || ptr.at('E') {
-        scan_float_exponent(ptr);
-        return FLOAT_NUMBER;
-    }
-    INT_NUMBER
-}
-
-fn scan_digits(ptr: &mut Ptr, allow_hex: bool) {
-    while let Some(c) = ptr.current() {
-        match c {
-            '_' | '0'..='9' => {
-                ptr.bump();
-            }
-            'a'..='f' | 'A'..='F' if allow_hex => {
-                ptr.bump();
-            }
-            _ => return,
-        }
-    }
-}
-
-fn scan_float_exponent(ptr: &mut Ptr) {
-    if ptr.at('e') || ptr.at('E') {
-        ptr.bump();
-        if ptr.at('-') || ptr.at('+') {
-            ptr.bump();
-        }
-        scan_digits(ptr, false);
-    }
-}
diff --git a/crates/ra_syntax/src/parsing/lexer/ptr.rs b/crates/ra_syntax/src/parsing/lexer/ptr.rs
deleted file mode 100644
index c341c4176..000000000
--- a/crates/ra_syntax/src/parsing/lexer/ptr.rs
+++ /dev/null
@@ -1,162 +0,0 @@
-use crate::TextUnit;
-
-use std::str::Chars;
-
-/// A simple view into the characters of a string.
-pub(crate) struct Ptr<'s> {
-    text: &'s str,
-    len: TextUnit,
-}
-
-impl<'s> Ptr<'s> {
-    /// Creates a new `Ptr` from a string.
-    pub fn new(text: &'s str) -> Ptr<'s> {
-        Ptr { text, len: 0.into() }
-    }
-
-    /// Gets the length of the remaining string.
-    pub fn into_len(self) -> TextUnit {
-        self.len
-    }
-
-    /// Gets the current character, if one exists.
-    pub fn current(&self) -> Option<char> {
-        self.chars().next()
-    }
-
-    /// Gets the nth character from the current.
-    /// For example, 0 will return the current character, 1 will return the next, etc.
-    pub fn nth(&self, n: u32) -> Option<char> {
-        self.chars().nth(n as usize)
-    }
-
-    /// Checks whether the current character is `c`.
-    pub fn at(&self, c: char) -> bool {
-        self.current() == Some(c)
-    }
-
-    /// Checks whether the next characters match `s`.
-    pub fn at_str(&self, s: &str) -> bool {
-        let chars = self.chars();
-        chars.as_str().starts_with(s)
-    }
-
-    /// Checks whether the current character satisfies the predicate `p`.
-    pub fn at_p<P: Fn(char) -> bool>(&self, p: P) -> bool {
-        self.current().map(p) == Some(true)
-    }
-
-    /// Checks whether the nth character satisfies the predicate `p`.
-    pub fn nth_is_p<P: Fn(char) -> bool>(&self, n: u32, p: P) -> bool {
-        self.nth(n).map(p) == Some(true)
-    }
-
-    /// Moves to the next character.
-    pub fn bump(&mut self) -> Option<char> {
-        let ch = self.chars().next()?;
-        self.len += TextUnit::of_char(ch);
-        Some(ch)
-    }
-
-    /// Moves to the next character as long as `pred` is satisfied.
-    pub fn bump_while<F: Fn(char) -> bool>(&mut self, pred: F) {
-        loop {
-            match self.current() {
-                Some(c) if pred(c) => {
-                    self.bump();
-                }
-                _ => return,
-            }
-        }
-    }
-
-    /// Returns the text up to the current point.
-    pub fn current_token_text(&self) -> &str {
-        let len: u32 = self.len.into();
-        &self.text[..len as usize]
-    }
-
-    /// Returns an iterator over the remaining characters.
-    fn chars(&self) -> Chars {
-        let len: u32 = self.len.into();
-        self.text[len as usize..].chars()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_current() {
-        let ptr = Ptr::new("test");
-        assert_eq!(ptr.current(), Some('t'));
-    }
-
-    #[test]
-    fn test_nth() {
-        let ptr = Ptr::new("test");
-        assert_eq!(ptr.nth(0), Some('t'));
-        assert_eq!(ptr.nth(1), Some('e'));
-        assert_eq!(ptr.nth(2), Some('s'));
-        assert_eq!(ptr.nth(3), Some('t'));
-        assert_eq!(ptr.nth(4), None);
-    }
-
-    #[test]
-    fn test_at() {
-        let ptr = Ptr::new("test");
-        assert!(ptr.at('t'));
-        assert!(!ptr.at('a'));
-    }
-
-    #[test]
-    fn test_at_str() {
-        let ptr = Ptr::new("test");
-        assert!(ptr.at_str("t"));
-        assert!(ptr.at_str("te"));
-        assert!(ptr.at_str("test"));
-        assert!(!ptr.at_str("tests"));
-        assert!(!ptr.at_str("rust"));
-    }
-
-    #[test]
-    fn test_at_p() {
-        let ptr = Ptr::new("test");
-        assert!(ptr.at_p(|c| c == 't'));
-        assert!(!ptr.at_p(|c| c == 'e'));
-    }
-
-    #[test]
-    fn test_nth_is_p() {
-        let ptr = Ptr::new("test");
-        assert!(ptr.nth_is_p(0, |c| c == 't'));
-        assert!(!ptr.nth_is_p(1, |c| c == 't'));
-        assert!(ptr.nth_is_p(3, |c| c == 't'));
-        assert!(!ptr.nth_is_p(150, |c| c == 't'));
-    }
-
-    #[test]
-    fn test_bump() {
-        let mut ptr = Ptr::new("test");
-        assert_eq!(ptr.current(), Some('t'));
-        ptr.bump();
-        assert_eq!(ptr.current(), Some('e'));
-        ptr.bump();
-        assert_eq!(ptr.current(), Some('s'));
-        ptr.bump();
-        assert_eq!(ptr.current(), Some('t'));
-        ptr.bump();
-        assert_eq!(ptr.current(), None);
-        ptr.bump();
-        assert_eq!(ptr.current(), None);
-    }
-
-    #[test]
-    fn test_bump_while() {
-        let mut ptr = Ptr::new("test");
-        assert_eq!(ptr.current(), Some('t'));
-        ptr.bump_while(|c| c != 's');
-        assert_eq!(ptr.current(), Some('s'));
-    }
-}
diff --git a/crates/ra_syntax/src/parsing/lexer/strings.rs b/crates/ra_syntax/src/parsing/lexer/strings.rs
deleted file mode 100644
index f74acff9e..000000000
--- a/crates/ra_syntax/src/parsing/lexer/strings.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-use crate::{
-    parsing::lexer::ptr::Ptr,
-    SyntaxKind::{self, *},
-};
-
-pub(crate) fn is_string_literal_start(c: char, c1: Option<char>, c2: Option<char>) -> bool {
-    match (c, c1, c2) {
-        ('r', Some('"'), _)
-        | ('r', Some('#'), Some('"'))
-        | ('r', Some('#'), Some('#'))
-        | ('b', Some('"'), _)
-        | ('b', Some('\''), _)
-        | ('b', Some('r'), Some('"'))
-        | ('b', Some('r'), Some('#')) => true,
-        _ => false,
-    }
-}
-
-pub(crate) fn scan_char(ptr: &mut Ptr) {
-    while let Some(c) = ptr.current() {
-        match c {
-            '\\' => {
-                ptr.bump();
-                if ptr.at('\\') || ptr.at('\'') {
-                    ptr.bump();
-                }
-            }
-            '\'' => {
-                ptr.bump();
-                return;
-            }
-            '\n' => return,
-            _ => {
-                ptr.bump();
-            }
-        }
-    }
-}
-
-pub(crate) fn scan_byte_char_or_string(ptr: &mut Ptr) -> SyntaxKind {
-    // unwrapping and not-exhaustive match are ok
-    // because of string_literal_start
-    let c = ptr.bump().unwrap();
-    match c {
-        '\'' => {
-            scan_byte(ptr);
-            BYTE
-        }
-        '"' => {
-            scan_byte_string(ptr);
-            BYTE_STRING
-        }
-        'r' => {
-            scan_raw_string(ptr);
-            RAW_BYTE_STRING
-        }
-        _ => unreachable!(),
-    }
-}
-
-pub(crate) fn scan_string(ptr: &mut Ptr) {
-    while let Some(c) = ptr.current() {
-        match c {
-            '\\' => {
-                ptr.bump();
-                if ptr.at('\\') || ptr.at('"') {
-                    ptr.bump();
-                }
-            }
-            '"' => {
-                ptr.bump();
-                return;
-            }
-            _ => {
-                ptr.bump();
-            }
-        }
-    }
-}
-
-pub(crate) fn scan_raw_string(ptr: &mut Ptr) {
-    let mut hashes = 0;
-    while ptr.at('#') {
-        hashes += 1;
-        ptr.bump();
-    }
-    if !ptr.at('"') {
-        return;
-    }
-    ptr.bump();
-
-    while let Some(c) = ptr.bump() {
-        if c == '"' {
-            let mut hashes_left = hashes;
-            while ptr.at('#') && hashes_left > 0 {
-                hashes_left -= 1;
-                ptr.bump();
-            }
-            if hashes_left == 0 {
-                return;
-            }
-        }
-    }
-}
-
-fn scan_byte(ptr: &mut Ptr) {
-    scan_char(ptr)
-}
-
-fn scan_byte_string(ptr: &mut Ptr) {
-    scan_string(ptr)
-}
diff --git a/crates/ra_syntax/tests/data/lexer/0004_numbers.txt b/crates/ra_syntax/tests/data/lexer/0004_numbers.txt
index 39988aedc..7bb89b8ae 100644
--- a/crates/ra_syntax/tests/data/lexer/0004_numbers.txt
+++ b/crates/ra_syntax/tests/data/lexer/0004_numbers.txt
@@ -12,9 +12,9 @@ INT_NUMBER 2 "0_"
 WHITESPACE 1 " "
 FLOAT_NUMBER 2 "0."
 WHITESPACE 1 " "
-INT_NUMBER 2 "0e"
+FLOAT_NUMBER 2 "0e"
 WHITESPACE 1 " "
-INT_NUMBER 2 "0E"
+FLOAT_NUMBER 2 "0E"
 WHITESPACE 1 " "
 INT_NUMBER 2 "0z"
 WHITESPACE 1 "\n"
@@ -32,9 +32,9 @@ INT_NUMBER 6 "0_1279"
 WHITESPACE 1 " "
 FLOAT_NUMBER 6 "0.1279"
 WHITESPACE 1 " "
-INT_NUMBER 6 "0e1279"
+FLOAT_NUMBER 6 "0e1279"
 WHITESPACE 1 " "
-INT_NUMBER 6 "0E1279"
+FLOAT_NUMBER 6 "0E1279"
 WHITESPACE 1 "\n"
 INT_NUMBER 1 "0"
 DOT 1 "."
@@ -47,9 +47,7 @@ IDENT 3 "foo"
 L_PAREN 1 "("
 R_PAREN 1 ")"
 WHITESPACE 1 "\n"
-INT_NUMBER 2 "0e"
-PLUS 1 "+"
-INT_NUMBER 1 "1"
+FLOAT_NUMBER 4 "0e+1"
 WHITESPACE 1 "\n"
 INT_NUMBER 1 "0"
 DOT 1 "."
diff --git a/crates/ra_syntax/tests/data/lexer/0014_unclosed_char.txt b/crates/ra_syntax/tests/data/lexer/0014_unclosed_char.txt
index 812dfbc18..737a300ee 100644
--- a/crates/ra_syntax/tests/data/lexer/0014_unclosed_char.txt
+++ b/crates/ra_syntax/tests/data/lexer/0014_unclosed_char.txt
@@ -1 +1 @@
-CHAR 2 "\'1"
+LIFETIME 2 "\'1"
diff --git a/crates/ra_syntax/tests/data/parser/err/0002_duplicate_shebang.txt b/crates/ra_syntax/tests/data/parser/err/0002_duplicate_shebang.txt
index 76d186a3c..84867026f 100644
--- a/crates/ra_syntax/tests/data/parser/err/0002_duplicate_shebang.txt
+++ b/crates/ra_syntax/tests/data/parser/err/0002_duplicate_shebang.txt
@@ -1,7 +1,39 @@
 SOURCE_FILE@[0; 42)
   SHEBANG@[0; 20) "#!/use/bin/env rusti"
   WHITESPACE@[20; 21) "\n"
-  ERROR@[21; 41)
-    SHEBANG@[21; 41) "#!/use/bin/env rusti"
+  ATTR@[21; 23)
+    POUND@[21; 22) "#"
+    EXCL@[22; 23) "!"
+  ERROR@[23; 24)
+    SLASH@[23; 24) "/"
+  USE_ITEM@[24; 28)
+    USE_KW@[24; 27) "use"
+    ERROR@[27; 28)
+      SLASH@[27; 28) "/"
+  MACRO_CALL@[28; 31)
+    PATH@[28; 31)
+      PATH_SEGMENT@[28; 31)
+        NAME_REF@[28; 31)
+          IDENT@[28; 31) "bin"
+  ERROR@[31; 32)
+    SLASH@[31; 32) "/"
+  MACRO_CALL@[32; 41)
+    PATH@[32; 35)
+      PATH_SEGMENT@[32; 35)
+        NAME_REF@[32; 35)
+          IDENT@[32; 35) "env"
+    WHITESPACE@[35; 36) " "
+    NAME@[36; 41)
+      IDENT@[36; 41) "rusti"
   WHITESPACE@[41; 42) "\n"
-error 21: expected an item
+error 23: expected `[`
+error 23: expected an item
+error 27: expected one of `*`, `::`, `{`, `self`, `super` or an indentifier
+error 28: expected SEMI
+error 31: expected EXCL
+error 31: expected `{`, `[`, `(`
+error 31: expected SEMI
+error 31: expected an item
+error 35: expected EXCL
+error 41: expected `{`, `[`, `(`
+error 41: expected SEMI
diff --git a/crates/ra_syntax/tests/data/parser/err/0030_string_suffixes.rs b/crates/ra_syntax/tests/data/parser/ok/0030_string_suffixes.rs
index 261aad1fb..261aad1fb 100644
--- a/crates/ra_syntax/tests/data/parser/err/0030_string_suffixes.rs
+++ b/crates/ra_syntax/tests/data/parser/ok/0030_string_suffixes.rs
diff --git a/crates/ra_syntax/tests/data/parser/err/0030_string_suffixes.txt b/crates/ra_syntax/tests/data/parser/ok/0030_string_suffixes.txt
index b0acfa5d2..4f7e809c5 100644
--- a/crates/ra_syntax/tests/data/parser/err/0030_string_suffixes.txt
+++ b/crates/ra_syntax/tests/data/parser/ok/0030_string_suffixes.txt
@@ -11,7 +11,7 @@ SOURCE_FILE@[0; 112)
     BLOCK@[10; 111)
       L_CURLY@[10; 11) "{"
       WHITESPACE@[11; 16) "\n    "
-      LET_STMT@[16; 27)
+      LET_STMT@[16; 31)
         LET_KW@[16; 19) "let"
         WHITESPACE@[19; 20) " "
         PLACEHOLDER_PAT@[20; 21)
@@ -19,14 +19,8 @@ SOURCE_FILE@[0; 112)
         WHITESPACE@[21; 22) " "
         EQ@[22; 23) "="
         WHITESPACE@[23; 24) " "
-        LITERAL@[24; 27)
-          CHAR@[24; 27) "\'c\'"
-      EXPR_STMT@[27; 31)
-        PATH_EXPR@[27; 30)
-          PATH@[27; 30)
-            PATH_SEGMENT@[27; 30)
-              NAME_REF@[27; 30)
-                IDENT@[27; 30) "u32"
+        LITERAL@[24; 30)
+          CHAR@[24; 30) "\'c\'u32"
         SEMI@[30; 31) ";"
       WHITESPACE@[31; 36) "\n    "
       LET_STMT@[36; 60)
@@ -67,4 +61,3 @@ SOURCE_FILE@[0; 112)
       WHITESPACE@[109; 110) "\n"
       R_CURLY@[110; 111) "}"
   WHITESPACE@[111; 112) "\n"
-error 27: expected SEMI