4 files changed, 103 insertions, 28 deletions

diff --git a/src/parser/event.rs b/src/parser/event.rs
index fd6bdc086..e97350c89 100644
--- a/src/parser/event.rs
+++ b/src/parser/event.rs
@@ -1,4 +1,4 @@
-use {File, FileBuilder, Sink, SyntaxKind, Token};
+use {File, FileBuilder, Sink, SyntaxKind, TextUnit, Token};
 use syntax_kinds::TOMBSTONE;
 use super::is_insignificant;
 
@@ -120,19 +120,26 @@ pub(super) fn to_file(text: String, tokens: &[Token], events: Vec<Event>) -> Fil
                 builder.finish_internal()
             }
             &Event::Token {
-                kind: _,
+                kind,
                 mut n_raw_tokens,
-            } => loop {
-                let token = tokens[idx];
-                if !is_insignificant(token.kind) {
-                    n_raw_tokens -= 1;
+            } => {
+                // FIXME: currently, we attach whitespace to some random node
+                // this should be done in a sensible manner instead
+                loop {
+                    let token = tokens[idx];
+                    if !is_insignificant(token.kind) {
+                        break;
+                    }
+                    builder.leaf(token.kind, token.len);
+                    idx += 1
                 }
-                idx += 1;
-                builder.leaf(token.kind, token.len);
-                if n_raw_tokens == 0 {
-                    break;
+                let mut len = TextUnit::new(0);
+                for _ in 0..n_raw_tokens {
+                    len += tokens[idx].len;
+                    idx += 1;
                 }
-            },
+                builder.leaf(kind, len);
+            }
             &Event::Error { ref message } => builder.error().message(message.clone()).emit(),
         }
     }
diff --git a/src/parser/grammar/items/mod.rs b/src/parser/grammar/items/mod.rs
index 3612802e1..37f2ab132 100644
--- a/src/parser/grammar/items/mod.rs
+++ b/src/parser/grammar/items/mod.rs
@@ -81,22 +81,76 @@ fn item(p: &mut Parser) {
                 CONST_ITEM
             }
         },
-        // TODO: auto trait
-        // test unsafe_trait
-        // unsafe trait T {}
-        UNSAFE_KW if la == TRAIT_KW => {
+        UNSAFE_KW => {
             p.bump();
-            traits::trait_item(p);
-            TRAIT_ITEM
-        }
-        // TODO: default impl
-        // test unsafe_impl
-        // unsafe impl Foo {}
-        UNSAFE_KW if la == IMPL_KW => {
-            p.bump();
-            traits::impl_item(p);
-            IMPL_ITEM
+            let la = p.nth(1);
+            match p.current() {
+                // test unsafe_trait
+                // unsafe trait T {}
+                TRAIT_KW => {
+                    traits::trait_item(p);
+                    TRAIT_ITEM
+                }
+
+                // test unsafe_auto_trait
+                // unsafe auto trait T {}
+                IDENT if p.at_kw("auto") && la == TRAIT_KW => {
+                    p.bump_remap(AUTO_KW);
+                    traits::trait_item(p);
+                    TRAIT_ITEM
+                }
+
+                // test unsafe_impl
+                // unsafe impl Foo {}
+                IMPL_KW => {
+                    traits::impl_item(p);
+                    IMPL_ITEM
+                }
+
+                // test unsafe_default_impl
+                // unsafe default impl Foo {}
+                IDENT if p.at_kw("default") && la == IMPL_KW => {
+                    p.bump_remap(DEFAULT_KW);
+                    traits::impl_item(p);
+                    IMPL_ITEM
+                }
+
+                // test unsafe_extern_fn
+                // unsafe extern "C" fn foo() {}
+                EXTERN_KW => {
+                    abi(p);
+                    if !p.at(FN_KW) {
+                        item.abandon(p);
+                        p.error().message("expected function").emit();
+                        return;
+                    }
+                    fn_item(p);
+                    FN_ITEM
+                }
+
+                // test unsafe_fn
+                // unsafe fn foo() {}
+                FN_KW => {
+                    fn_item(p);
+                    FN_ITEM
+                }
+
+                t => {
+                    item.abandon(p);
+                    let message = "expected `trait`, `impl` or `fn`";
+
+                    // test unsafe_block_in_mod
+                    // fn foo(){} unsafe { } fn bar(){}
+                    if t == L_CURLY {
+                        error_block(p, message);
+                    } else {
+                        p.error().message(message).emit();
+                    }
+                    return;
+                }
+            }
         }
+
         MOD_KW => {
             mod_item(p);
             MOD_ITEM
diff --git a/src/parser/input.rs b/src/parser/input.rs
index 162b9ef5f..4d74ac1b1 100644
--- a/src/parser/input.rs
+++ b/src/parser/input.rs
@@ -46,9 +46,7 @@ impl<'t> ParserInput<'t> {
         if !(idx < self.tokens.len()) {
             return "";
         }
-        let start_offset = self.start_offsets[idx];
-        let end_offset = self.tokens[idx].len;
-        let range = TextRange::from_to(start_offset, end_offset);
+        let range = TextRange::from_len(self.start_offsets[idx], self.tokens[idx].len);
         &self.text[range]
     }
 }
diff --git a/src/parser/parser.rs b/src/parser/parser.rs
index bb775c4a5..752d532d0 100644
--- a/src/parser/parser.rs
+++ b/src/parser/parser.rs
@@ -145,10 +145,26 @@ impl<'t> Parser<'t> {
         });
     }
 
+    pub(crate) fn bump_remap(&mut self, kind: SyntaxKind) {
+        if self.current() == EOF {
+            // TODO: panic!?
+            return;
+        }
+        self.pos += 1;
+        self.event(Event::Token {
+            kind,
+            n_raw_tokens: 1,
+        });
+    }
+
     pub(crate) fn nth(&self, n: u32) -> SyntaxKind {
         self.inp.kind(self.pos + n)
     }
 
+    pub(crate) fn at_kw(&self, t: &str) -> bool {
+        self.inp.text(self.pos) == t
+    }
+
     pub(crate) fn current(&self) -> SyntaxKind {
         self.nth(0)
     }