organizize

372 files changed, 15286 insertions, 0 deletions

diff --git a/crates/cli/Cargo.toml b/crates/cli/Cargo.toml
new file mode 100644
index 000000000..ac89a48d3
--- /dev/null
+++ b/crates/cli/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "cli"
+version = "0.1.0"
+authors = ["Aleksey Kladov <[email protected]>"]
+publish = false
+
+[dependencies]
+clap = "2.32.0"
+failure = "0.1.1"
+libeditor = { path = "../libeditor" }
+tools = { path = "../tools" }
diff --git a/crates/cli/src/main.rs b/crates/cli/src/main.rs
new file mode 100644
index 000000000..45e0a1e4f
--- /dev/null
+++ b/crates/cli/src/main.rs
@@ -0,0 +1,95 @@
+extern crate clap;
+#[macro_use]
+extern crate failure;
+extern crate libeditor;
+extern crate tools;
+
+use std::{
+    fs, io::Read, path::Path,
+    time::Instant
+};
+use clap::{App, Arg, SubCommand};
+use tools::collect_tests;
+use libeditor::{ast, syntax_tree, symbols};
+
+type Result<T> = ::std::result::Result<T, failure::Error>;
+
+fn main() -> Result<()> {
+    let matches = App::new("libsyntax2-cli")
+        .setting(clap::AppSettings::SubcommandRequiredElseHelp)
+        .subcommand(
+            SubCommand::with_name("render-test")
+                .arg(
+                    Arg::with_name("line")
+                        .long("--line")
+                        .required(true)
+                        .takes_value(true),
+                )
+                .arg(
+                    Arg::with_name("file")
+                        .long("--file")
+                        .required(true)
+                        .takes_value(true),
+                ),
+        )
+        .subcommand(
+            SubCommand::with_name("parse")
+                .arg(Arg::with_name("no-dump").long("--no-dump"))
+        )
+        .subcommand(SubCommand::with_name("symbols"))
+        .get_matches();
+    match matches.subcommand() {
+        ("parse", Some(matches)) => {
+            let start = Instant::now();
+            let file = file()?;
+            let elapsed = start.elapsed();
+            if !matches.is_present("no-dump") {
+                println!("{}", syntax_tree(&file));
+            }
+            eprintln!("parsing: {:?}", elapsed);
+            ::std::mem::forget(file);
+        }
+        ("symbols", _) => {
+            let file = file()?;
+            for s in symbols(&file) {
+                println!("{:?}", s);
+            }
+        }
+        ("render-test", Some(matches)) => {
+            let file = matches.value_of("file").unwrap();
+            let file = Path::new(file);
+            let line: usize = matches.value_of("line").unwrap().parse()?;
+            let line = line - 1;
+            let (test, tree) = render_test(file, line)?;
+            println!("{}\n{}", test, tree);
+        }
+        _ => unreachable!(),
+    }
+    Ok(())
+}
+
+fn file() -> Result<ast::File> {
+    let text = read_stdin()?;
+    Ok(ast::File::parse(&text))
+}
+
+fn read_stdin() -> Result<String> {
+    let mut buff = String::new();
+    ::std::io::stdin().read_to_string(&mut buff)?;
+    Ok(buff)
+}
+
+fn render_test(file: &Path, line: usize) -> Result<(String, String)> {
+    let text = fs::read_to_string(file)?;
+    let tests = collect_tests(&text);
+    let test = tests.into_iter().find(|(start_line, t)| {
+        *start_line <= line && line <= *start_line + t.text.lines().count()
+    });
+    let test = match test {
+        None => bail!("No test found at line {} at {}", line, file.display()),
+        Some((_start_line, test)) => test,
+    };
+    let file = ast::File::parse(&test.text);
+    let tree = syntax_tree(&file);
+    Ok((test.text, tree))
+}
diff --git a/crates/libanalysis/Cargo.toml b/crates/libanalysis/Cargo.toml
new file mode 100644
index 000000000..c773f4211
--- /dev/null
+++ b/crates/libanalysis/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "libanalysis"
+version = "0.1.0"
+authors = ["Aleksey Kladov <[email protected]>"]
+
+[dependencies]
+log = "0.4.2"
+failure = "0.1.2"
+parking_lot = "0.6.3"
+once_cell = "0.1.4"
+libsyntax2 = { path = "../libsyntax2" }
+libeditor = { path = "../libeditor" }
diff --git a/crates/libanalysis/src/lib.rs b/crates/libanalysis/src/lib.rs
new file mode 100644
index 000000000..6a946a0b0
--- /dev/null
+++ b/crates/libanalysis/src/lib.rs
@@ -0,0 +1,132 @@
+extern crate failure;
+extern crate parking_lot;
+#[macro_use]
+extern crate log;
+extern crate once_cell;
+extern crate libsyntax2;
+extern crate libeditor;
+
+use once_cell::sync::OnceCell;
+
+use std::{
+    fs,
+    sync::Arc,
+    collections::hash_map::HashMap,
+    path::{PathBuf, Path},
+};
+use parking_lot::RwLock;
+use libsyntax2::ast;
+use libeditor::LineIndex;
+
+pub type Result<T> = ::std::result::Result<T, ::failure::Error>;
+
+pub struct WorldState {
+    data: Arc<WorldData>
+}
+
+pub struct World {
+    data: Arc<WorldData>,
+}
+
+impl WorldState {
+    pub fn new() -> WorldState {
+        WorldState {
+            data: Arc::new(WorldData::default())
+        }
+    }
+
+    pub fn snapshot(&self) -> World {
+        World { data: self.data.clone() }
+    }
+
+    pub fn change_overlay(&mut self, path: PathBuf, text: Option<String>) {
+        let data = self.data_mut();
+        data.file_map.get_mut().remove(&path);
+        if let Some(text) = text {
+            data.mem_map.insert(path, Arc::new(text));
+        } else {
+            data.mem_map.remove(&path);
+        }
+    }
+
+    fn data_mut(&mut self) -> &mut WorldData {
+        if Arc::get_mut(&mut self.data).is_none() {
+            let file_map = self.data.file_map.read().clone();
+            self.data = Arc::new(WorldData {
+                mem_map: self.data.mem_map.clone(),
+                file_map: RwLock::new(file_map),
+            });
+        }
+        Arc::get_mut(&mut self.data).unwrap()
+    }
+}
+
+
+impl World {
+    pub fn file_syntax(&self, path: &Path) -> Result<ast::File> {
+        let data = self.file_data(path)?;
+        let syntax = data.syntax
+            .get_or_init(|| {
+                trace!("parsing: {}", path.display());
+                ast::File::parse(self.file_text(path, &data))
+            }).clone();
+        Ok(syntax)
+    }
+
+    pub fn file_line_index(&self, path: &Path) -> Result<LineIndex> {
+        let data = self.file_data(path)?;
+        let index = data.lines
+            .get_or_init(|| {
+                trace!("calc line index: {}", path.display());
+                LineIndex::new(self.file_text(path, &data))
+            });
+        Ok(index.clone())
+    }
+
+    fn file_text<'a>(&'a self, path: &Path, file_data: &'a FileData) -> &'a str {
+        match file_data.text.as_ref() {
+            Some(text) => text.as_str(),
+            None => self.data.mem_map[path].as_str()
+        }
+    }
+
+    fn file_data(&self, path: &Path) -> Result<Arc<FileData>> {
+        {
+            let guard = self.data.file_map.read();
+            if let Some(data) = guard.get(path) {
+                return Ok(data.clone());
+            }
+        }
+
+        let text = if self.data.mem_map.contains_key(path) {
+            None
+        } else {
+            trace!("loading file from disk: {}", path.display());
+            Some(fs::read_to_string(path)?)
+        };
+        let res = {
+            let mut guard = self.data.file_map.write();
+            guard.entry(path.to_owned())
+                .or_insert_with(|| Arc::new(FileData {
+                    text,
+                    syntax: OnceCell::new(),
+                    lines: OnceCell::new(),
+                }))
+                .clone()
+        };
+        Ok(res)
+    }
+}
+
+
+#[derive(Default)]
+struct WorldData {
+    mem_map: HashMap<PathBuf, Arc<String>>,
+    file_map: RwLock<HashMap<PathBuf, Arc<FileData>>>,
+}
+
+struct FileData {
+    text: Option<String>,
+    syntax: OnceCell<ast::File>,
+    lines: OnceCell<LineIndex>,
+}
diff --git a/crates/libeditor/Cargo.toml b/crates/libeditor/Cargo.toml
new file mode 100644
index 000000000..d6423979b
--- /dev/null
+++ b/crates/libeditor/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "libeditor"
+version = "0.1.0"
+authors = ["Aleksey Kladov <[email protected]>"]
+publish = false
+
+[dependencies]
+itertools = "0.7.8"
+superslice = "0.1.0"
+libsyntax2 = { path = "../libsyntax2" }
diff --git a/crates/libeditor/src/extend_selection.rs b/crates/libeditor/src/extend_selection.rs
new file mode 100644
index 000000000..16d4bc084
--- /dev/null
+++ b/crates/libeditor/src/extend_selection.rs
@@ -0,0 +1,36 @@
+use libsyntax2::{
+    TextRange, SyntaxNodeRef,
+    SyntaxKind::WHITESPACE,
+    algo::{find_leaf_at_offset, find_covering_node, ancestors},
+};
+
+
+pub(crate) fn extend_selection(root: SyntaxNodeRef, range: TextRange) -> Option<TextRange> {
+    if range.is_empty() {
+        let offset = range.start();
+        let mut leaves = find_leaf_at_offset(root, offset);
+        if let Some(leaf) = leaves.clone().find(|node| node.kind() != WHITESPACE) {
+            return Some(leaf.range());
+        }
+        let ws = leaves.next()?;
+//        let ws_suffix = file.text().slice(
+//            TextRange::from_to(offset, ws.range().end())
+//        );
+//        if ws.text().contains("\n") && !ws_suffix.contains("\n") {
+//            if let Some(line_end) = file.text()
+//                .slice(TextSuffix::from(ws.range().end()))
+//                .find("\n")
+//            {
+//                let range = TextRange::from_len(ws.range().end(), line_end);
+//                return Some(find_covering_node(file.root(), range).range());
+//            }
+//        }
+        return Some(ws.range());
+    };
+    let node = find_covering_node(root, range);
+
+    match ancestors(node).skip_while(|n| n.range() == range).next() {
+        None => None,
+        Some(parent) => Some(parent.range()),
+    }
+}
diff --git a/crates/libeditor/src/lib.rs b/crates/libeditor/src/lib.rs
new file mode 100644
index 000000000..f77647338
--- /dev/null
+++ b/crates/libeditor/src/lib.rs
@@ -0,0 +1,155 @@
+extern crate libsyntax2;
+extern crate superslice;
+
+mod extend_selection;
+mod line_index;
+
+use libsyntax2::{
+    SyntaxNodeRef, AstNode,
+    algo::walk,
+    SyntaxKind::*,
+};
+pub use libsyntax2::{TextRange, TextUnit, ast};
+pub use self::line_index::{LineIndex, LineCol};
+
+#[derive(Debug)]
+pub struct HighlightedRange {
+    pub range: TextRange,
+    pub tag: &'static str,
+}
+
+#[derive(Debug)]
+pub struct Diagnostic {
+    pub range: TextRange,
+    pub msg: String,
+}
+
+#[derive(Debug)]
+pub struct Symbol {
+    // pub parent: ???,
+    pub name: String,
+    pub range: TextRange,
+}
+
+#[derive(Debug)]
+pub struct Runnable {
+    pub range: TextRange,
+    pub kind: RunnableKind,
+}
+
+#[derive(Debug)]
+pub enum RunnableKind {
+    Test { name: String },
+    Bin,
+}
+
+pub fn highlight(file: &ast::File) -> Vec<HighlightedRange> {
+    let syntax = file.syntax();
+    let mut res = Vec::new();
+    for node in walk::preorder(syntax.as_ref()) {
+        let tag = match node.kind() {
+            ERROR => "error",
+            COMMENT | DOC_COMMENT => "comment",
+            STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => "string",
+            ATTR => "attribute",
+            NAME_REF => "text",
+            NAME => "function",
+            INT_NUMBER | FLOAT_NUMBER | CHAR | BYTE => "literal",
+            LIFETIME => "parameter",
+            k if k.is_keyword() => "keyword",
+            _ => continue,
+        };
+        res.push(HighlightedRange {
+            range: node.range(),
+            tag,
+        })
+    }
+    res
+}
+
+pub fn diagnostics(file: &ast::File) -> Vec<Diagnostic> {
+    let syntax = file.syntax();
+    let mut res = Vec::new();
+
+    for node in walk::preorder(syntax.as_ref()) {
+        if node.kind() == ERROR {
+            res.push(Diagnostic {
+                range: node.range(),
+                msg: "Syntax Error".to_string(),
+            });
+        }
+    }
+    res.extend(file.errors().into_iter().map(|err| Diagnostic {
+        range: TextRange::offset_len(err.offset, 1.into()),
+        msg: err.msg,
+    }));
+    res
+}
+
+pub fn syntax_tree(file: &ast::File) -> String {
+    ::libsyntax2::utils::dump_tree(&file.syntax())
+}
+
+pub fn symbols(file: &ast::File) -> Vec<Symbol> {
+    let syntax = file.syntax();
+    let res: Vec<Symbol> = walk::preorder(syntax.as_ref())
+        .filter_map(Declaration::cast)
+        .filter_map(|decl| {
+            let name = decl.name()?;
+            let range = decl.range();
+            Some(Symbol { name, range })
+        })
+        .collect();
+    res // NLL :-(
+}
+
+pub fn extend_selection(file: &ast::File, range: TextRange) -> Option<TextRange> {
+    let syntax = file.syntax();
+    extend_selection::extend_selection(syntax.as_ref(), range)
+}
+
+pub fn runnables(file: &ast::File) -> Vec<Runnable> {
+    file
+        .functions()
+        .filter_map(|f| {
+            let name = f.name()?.text();
+            let kind = if name == "main" {
+                RunnableKind::Bin
+            } else if f.has_atom_attr("test") {
+                RunnableKind::Test {
+                    name: name.to_string()
+                }
+            } else {
+                return None;
+            };
+            Some(Runnable {
+                range: f.syntax().range(),
+                kind,
+            })
+        })
+        .collect()
+}
+
+
+struct Declaration<'f> (SyntaxNodeRef<'f>);
+
+impl<'f> Declaration<'f> {
+    fn cast(node: SyntaxNodeRef<'f>) -> Option<Declaration<'f>> {
+        match node.kind() {
+            | STRUCT_ITEM | ENUM_ITEM | FUNCTION | TRAIT_ITEM
+            | CONST_ITEM | STATIC_ITEM | MOD_ITEM | NAMED_FIELD
+            | TYPE_ITEM => Some(Declaration(node)),
+            _ => None
+        }
+    }
+
+    fn name(&self) -> Option<String> {
+        let name = self.0.children()
+            .find(|child| child.kind() == NAME)?;
+        Some(name.text())
+    }
+
+    fn range(&self) -> TextRange {
+        self.0.range()
+    }
+}
diff --git a/crates/libeditor/src/line_index.rs b/crates/libeditor/src/line_index.rs
new file mode 100644
index 000000000..801726aa5
--- /dev/null
+++ b/crates/libeditor/src/line_index.rs
@@ -0,0 +1,62 @@
+use superslice::Ext;
+use ::TextUnit;
+
+#[derive(Clone, Debug)]
+pub struct LineIndex {
+    newlines: Vec<TextUnit>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct LineCol {
+    pub line: u32,
+    pub col: TextUnit,
+}
+
+impl LineIndex {
+    pub fn new(text: &str) -> LineIndex {
+        let mut newlines = vec![0.into()];
+        let mut curr = 0.into();
+        for c in text.chars() {
+            curr += TextUnit::of_char(c);
+            if c == '\n' {
+                newlines.push(curr);
+            }
+        }
+        LineIndex { newlines }
+    }
+
+    pub fn line_col(&self, offset: TextUnit) -> LineCol {
+        let line = self.newlines.upper_bound(&offset) - 1;
+        let line_start_offset = self.newlines[line];
+        let col = offset - line_start_offset;
+        return LineCol { line: line as u32, col };
+    }
+
+    pub fn offset(&self, line_col: LineCol) -> TextUnit {
+        //TODO: return Result
+        self.newlines[line_col.line as usize] + line_col.col
+    }
+}
+
+#[test]
+fn test_line_index() {
+    let text = "hello\nworld";
+    let index = LineIndex::new(text);
+    assert_eq!(index.line_col(0.into()), LineCol { line: 0, col: 0.into() });
+    assert_eq!(index.line_col(1.into()), LineCol { line: 0, col: 1.into() });
+    assert_eq!(index.line_col(5.into()), LineCol { line: 0, col: 5.into() });
+    assert_eq!(index.line_col(6.into()), LineCol { line: 1, col: 0.into() });
+    assert_eq!(index.line_col(7.into()), LineCol { line: 1, col: 1.into() });
+    assert_eq!(index.line_col(8.into()), LineCol { line: 1, col: 2.into() });
+    assert_eq!(index.line_col(10.into()), LineCol { line: 1, col: 4.into() });
+    assert_eq!(index.line_col(11.into()), LineCol { line: 1, col: 5.into() });
+    assert_eq!(index.line_col(12.into()), LineCol { line: 1, col: 6.into() });
+
+    let text = "\nhello\nworld";
+    let index = LineIndex::new(text);
+    assert_eq!(index.line_col(0.into()), LineCol { line: 0, col: 0.into() });
+    assert_eq!(index.line_col(1.into()), LineCol { line: 1, col: 0.into() });
+    assert_eq!(index.line_col(2.into()), LineCol { line: 1, col: 1.into() });
+    assert_eq!(index.line_col(6.into()), LineCol { line: 1, col: 5.into() });
+    assert_eq!(index.line_col(7.into()), LineCol { line: 2, col: 0.into() });
+}
diff --git a/crates/libeditor/tests/test.rs b/crates/libeditor/tests/test.rs
new file mode 100644
index 000000000..2a84c5080
--- /dev/null
+++ b/crates/libeditor/tests/test.rs
@@ -0,0 +1,69 @@
+extern crate libeditor;
+extern crate itertools;
+
+use std::fmt;
+use itertools::Itertools;
+use libeditor::{ast, highlight, runnables, extend_selection, TextRange};
+
+#[test]
+fn test_extend_selection() {
+    let file = file(r#"fn foo() {
+    1 + 1
+}
+"#);
+    let range = TextRange::offset_len(18.into(), 0.into());
+    let range = extend_selection(&file, range).unwrap();
+    assert_eq!(range, TextRange::from_to(17.into(), 18.into()));
+    let range = extend_selection(&file, range).unwrap();
+    assert_eq!(range, TextRange::from_to(15.into(), 20.into()));
+}
+
+#[test]
+fn test_highlighting() {
+    let file = file(r#"
+// comment
+fn main() {}
+    println!("Hello, {}!", 92);
+"#);
+    let hls = highlight(&file);
+    dbg_eq(
+        &hls,
+        r#"[HighlightedRange { range: [1; 11), tag: "comment" },
+            HighlightedRange { range: [12; 14), tag: "keyword" },
+            HighlightedRange { range: [15; 19), tag: "function" },
+            HighlightedRange { range: [29; 36), tag: "text" },
+            HighlightedRange { range: [38; 50), tag: "string" },
+            HighlightedRange { range: [52; 54), tag: "literal" }]"#
+    );
+}
+
+#[test]
+fn test_runnables() {
+    let file = file(r#"
+fn main() {}
+
+#[test]
+fn test_foo() {}
+
+#[test]
+#[ignore]
+fn test_foo() {}
+"#);
+    let runnables = runnables(&file);
+    dbg_eq(
+        &runnables,
+        r#"[Runnable { range: [1; 13), kind: Bin },
+            Runnable { range: [15; 39), kind: Test { name: "test_foo" } },
+            Runnable { range: [41; 75), kind: Test { name: "test_foo" } }]"#,
+    )
+}
+
+fn file(text: &str) -> ast::File {
+    ast::File::parse(text)
+}
+
+fn dbg_eq(actual: &impl fmt::Debug, expected: &str) {
+    let actual = format!("{:?}", actual);
+    let expected = expected.lines().map(|l| l.trim()).join(" ");
+    assert_eq!(actual, expected);
+}
diff --git a/crates/libsyntax2/Cargo.toml b/crates/libsyntax2/Cargo.toml
new file mode 100644
index 000000000..f67735540
--- /dev/null
+++ b/crates/libsyntax2/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "libsyntax2"
+version = "0.1.0"
+authors = ["Aleksey Kladov <[email protected]>"]
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+unicode-xid = "0.1.0"
+text_unit = "0.1.2"
+itertools = "0.7.5"
+drop_bomb = "0.1.4"
+parking_lot = "0.6.0"
+
+[dev-dependencies]
+testutils = { path = "./tests/testutils" }
diff --git a/crates/libsyntax2/src/algo/mod.rs b/crates/libsyntax2/src/algo/mod.rs
new file mode 100644
index 000000000..d2de70fd4
--- /dev/null
+++ b/crates/libsyntax2/src/algo/mod.rs
@@ -0,0 +1,123 @@
+pub mod walk;
+
+use {SyntaxNodeRef, TextUnit, TextRange};
+
+pub fn find_leaf_at_offset(node: SyntaxNodeRef, offset: TextUnit) -> LeafAtOffset {
+    let range = node.range();
+    assert!(
+        contains_offset_nonstrict(range, offset),
+        "Bad offset: range {:?} offset {:?}", range, offset
+    );
+    if range.is_empty() {
+        return LeafAtOffset::None;
+    }
+
+    if node.is_leaf() {
+        return LeafAtOffset::Single(node);
+    }
+
+    let mut children = node.children()
+        .filter(|child| {
+            let child_range = child.range();
+            !child_range.is_empty() && contains_offset_nonstrict(child_range, offset)
+        });
+
+    let left = children.next().unwrap();
+    let right = children.next();
+    assert!(children.next().is_none());
+    return if let Some(right) = right {
+        match (find_leaf_at_offset(left, offset), find_leaf_at_offset(right, offset)) {
+            (LeafAtOffset::Single(left), LeafAtOffset::Single(right)) =>
+                LeafAtOffset::Between(left, right),
+            _ => unreachable!()
+        }
+    } else {
+        find_leaf_at_offset(left, offset)
+    };
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum LeafAtOffset<'a> {
+    None,
+    Single(SyntaxNodeRef<'a>),
+    Between(SyntaxNodeRef<'a>, SyntaxNodeRef<'a>)
+}
+
+impl<'a> LeafAtOffset<'a> {
+    pub fn right_biased(self) -> Option<SyntaxNodeRef<'a>> {
+        match self {
+            LeafAtOffset::None => None,
+            LeafAtOffset::Single(node) => Some(node),
+            LeafAtOffset::Between(_, right) => Some(right)
+        }
+    }
+
+    pub fn left_biased(self) -> Option<SyntaxNodeRef<'a>> {
+        match self {
+            LeafAtOffset::None => None,
+            LeafAtOffset::Single(node) => Some(node),
+            LeafAtOffset::Between(left, _) => Some(left)
+        }
+    }
+}
+
+impl<'f> Iterator for LeafAtOffset<'f> {
+    type Item = SyntaxNodeRef<'f>;
+
+    fn next(&mut self) -> Option<SyntaxNodeRef<'f>> {
+        match *self {
+            LeafAtOffset::None => None,
+            LeafAtOffset::Single(node) => { *self = LeafAtOffset::None; Some(node) }
+            LeafAtOffset::Between(left, right) => { *self = LeafAtOffset::Single(right); Some(left) }
+        }
+    }
+}
+
+
+pub fn find_covering_node(root: SyntaxNodeRef, range: TextRange) -> SyntaxNodeRef {
+    assert!(is_subrange(root.range(), range));
+    let (left, right) = match (
+        find_leaf_at_offset(root, range.start()).right_biased(),
+        find_leaf_at_offset(root, range.end()).left_biased()
+    ) {
+        (Some(l), Some(r)) => (l, r),
+        _ => return root
+    };
+
+    common_ancestor(left, right)
+}
+
+fn common_ancestor<'a>(n1: SyntaxNodeRef<'a>, n2: SyntaxNodeRef<'a>) -> SyntaxNodeRef<'a> {
+    for p in ancestors(n1) {
+        if ancestors(n2).any(|a| a == p) {
+            return p;
+        }
+    }
+    panic!("Can't find common ancestor of {:?} and {:?}", n1, n2)
+}
+
+pub fn ancestors<'a>(node: SyntaxNodeRef<'a>) -> impl Iterator<Item=SyntaxNodeRef<'a>> {
+    Ancestors(Some(node))
+}
+
+#[derive(Debug)]
+struct Ancestors<'a>(Option<SyntaxNodeRef<'a>>);
+
+impl<'a> Iterator for Ancestors<'a> {
+    type Item = SyntaxNodeRef<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.0.take().map(|n| {
+            self.0 = n.parent();
+            n
+        })
+    }
+}
+
+fn contains_offset_nonstrict(range: TextRange, offset: TextUnit) -> bool {
+    range.start() <= offset && offset <= range.end()
+}
+
+fn is_subrange(range: TextRange, subrange: TextRange) -> bool {
+    range.start() <= subrange.start() && subrange.end() <= range.end()
+}
diff --git a/crates/libsyntax2/src/algo/search.rs b/crates/libsyntax2/src/algo/search.rs
new file mode 100644
index 000000000..46404f537
--- /dev/null
+++ b/crates/libsyntax2/src/algo/search.rs
@@ -0,0 +1,136 @@
+use {Node, NodeType, TextUnit, TextRange};
+use ::visitor::{visitor, process_subtree_bottom_up};
+
+pub fn child_of_type(node: Node, ty: NodeType) -> Option<Node> {
+    node.children().find(|n| n.ty() == ty)
+}
+
+pub fn children_of_type<'f>(node: Node<'f>, ty: NodeType) -> Box<Iterator<Item=Node<'f>> + 'f> {
+    Box::new(node.children().filter(move |n| n.ty() == ty))
+}
+
+pub fn subtree<'f>(node: Node<'f>) -> Box<Iterator<Item=Node<'f>> + 'f> {
+    Box::new(node.children().flat_map(subtree).chain(::std::iter::once(node)))
+}
+
+pub fn descendants_of_type<'f>(node: Node<'f>, ty: NodeType) -> Vec<Node<'f>> {
+    process_subtree_bottom_up(
+        node,
+        visitor(Vec::new())
+            .visit_nodes(&[ty], |node, nodes| nodes.push(node))
+    )
+}
+
+pub fn child_of_type_exn(node: Node, ty: NodeType) -> Node {
+    child_of_type(node, ty).unwrap_or_else(|| {
+        panic!("No child of type {:?} for {:?}\
+                ----\
+                {}\
+                ----", ty, node.ty(), node.text())
+    })
+}
+
+
+pub fn ancestors(node: Node) -> Ancestors {
+    Ancestors(Some(node))
+}
+
+pub struct Ancestors<'f>(Option<Node<'f>>);
+
+impl<'f> Iterator for Ancestors<'f> {
+    type Item = Node<'f>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let current = self.0;
+        self.0 = current.and_then(|n| n.parent());
+        current
+    }
+}
+
+pub fn is_leaf(node: Node) -> bool {
+    node.children().next().is_none() && !node.range().is_empty()
+}
+
+
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+pub enum Direction {
+    Left, Right
+}
+
+pub fn sibling(node: Node, dir: Direction) -> Option<Node> {
+    let (parent, idx) = child_position(node)?;
+    let idx = match dir {
+        Direction::Left => idx.checked_sub(1)?,
+        Direction::Right => idx + 1,
+    };
+    parent.children().nth(idx)
+}
+
+pub mod ast {
+    use {Node, AstNode, TextUnit, AstChildren};
+    use visitor::{visitor, process_subtree_bottom_up};
+    use super::{ancestors, find_leaf_at_offset, LeafAtOffset};
+
+    pub fn ancestor<'f, T: AstNode<'f>>(node: Node<'f>) -> Option<T> {
+        ancestors(node)
+            .filter_map(T::wrap)
+            .next()
+    }
+
+    pub fn ancestor_exn<'f, T: AstNode<'f>>(node: Node<'f>) -> T {
+        ancestor(node).unwrap()
+    }
+
+    pub fn children_of_type<'f, N: AstNode<'f>>(node: Node<'f>) -> AstChildren<N> {
+        AstChildren::new(node.children())
+    }
+
+    pub fn descendants_of_type<'f, N: AstNode<'f>>(node: Node<'f>) -> Vec<N> {
+        process_subtree_bottom_up(
+            node,
+            visitor(Vec::new())
+                .visit::<N, _>(|node, acc| acc.push(node))
+        )
+    }
+
+    pub fn node_at_offset<'f, T: AstNode<'f>>(node: Node<'f>, offset: TextUnit) -> Option<T> {
+        match find_leaf_at_offset(node, offset) {
+            LeafAtOffset::None => None,
+            LeafAtOffset::Single(node) => ancestor(node),
+            LeafAtOffset::Between(left, right) => ancestor(left).or_else(|| ancestor(right)),
+        }
+    }
+}
+
+pub mod traversal {
+    use {Node};
+
+    pub fn bottom_up<'f, F: FnMut(Node<'f>)>(node: Node<'f>, mut f: F)
+    {
+        go(node, &mut f);
+
+        fn go<'f, F: FnMut(Node<'f>)>(node: Node<'f>, f: &mut F) {
+            for child in node.children() {
+                go(child, f)
+            }
+            f(node);
+        }
+    }
+}
+
+fn child_position(child: Node) -> Option<(Node, usize)> {
+    child.parent()
+        .map(|parent| {
+            (parent, parent.children().position(|n| n == child).unwrap())
+        })
+}
+
+fn common_ancestor<'f>(n1: Node<'f>, n2: Node<'f>) -> Node<'f> {
+    for p in ancestors(n1) {
+        if ancestors(n2).any(|a| a == p) {
+            return p;
+        }
+    }
+    panic!("Can't find common ancestor of {:?} and {:?}", n1, n2)
+}
+
diff --git a/crates/libsyntax2/src/algo/walk.rs b/crates/libsyntax2/src/algo/walk.rs
new file mode 100644
index 000000000..a50ec2a09
--- /dev/null
+++ b/crates/libsyntax2/src/algo/walk.rs
@@ -0,0 +1,45 @@
+use SyntaxNodeRef;
+
+pub fn preorder<'a>(root: SyntaxNodeRef<'a>) -> impl Iterator<Item = SyntaxNodeRef<'a>> {
+    walk(root).filter_map(|event| match event {
+        WalkEvent::Enter(node) => Some(node),
+        WalkEvent::Exit(_) => None,
+    })
+}
+
+#[derive(Debug, Copy, Clone)]
+pub enum WalkEvent<'a> {
+    Enter(SyntaxNodeRef<'a>),
+    Exit(SyntaxNodeRef<'a>),
+}
+
+pub fn walk<'a>(root: SyntaxNodeRef<'a>) -> impl Iterator<Item = WalkEvent<'a>> {
+    let mut done = false;
+    ::itertools::unfold(WalkEvent::Enter(root), move |pos| {
+        if done {
+            return None;
+        }
+        let res = *pos;
+        *pos = match *pos {
+            WalkEvent::Enter(node) => match node.first_child() {
+                Some(child) => WalkEvent::Enter(child),
+                None => WalkEvent::Exit(node),
+            },
+            WalkEvent::Exit(node) => {
+                if node == root {
+                    done = true;
+                    WalkEvent::Exit(node)
+                } else {
+                    match node.next_sibling() {
+                        Some(sibling) => WalkEvent::Enter(sibling),
+                        None => match node.parent() {
+                            Some(node) => WalkEvent::Exit(node),
+                            None => WalkEvent::Exit(node),
+                        },
+                    }
+                }
+            }
+        };
+        Some(res)
+    })
+}
diff --git a/crates/libsyntax2/src/ast/generated.rs b/crates/libsyntax2/src/ast/generated.rs
new file mode 100644
index 000000000..2f813050a
--- /dev/null
+++ b/crates/libsyntax2/src/ast/generated.rs
@@ -0,0 +1,54 @@
+use std::sync::Arc;
+use {
+    SyntaxNode, SyntaxRoot, TreeRoot, AstNode,
+    SyntaxKind::*,
+};
+
+
+#[derive(Debug, Clone, Copy)]
+pub struct File<R: TreeRoot = Arc<SyntaxRoot>> {
+    syntax: SyntaxNode<R>,
+}
+
+impl<R: TreeRoot> AstNode<R> for File<R> {
+    fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
+        match syntax.kind() {
+            FILE => Some(File { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
+}
+
+
+#[derive(Debug, Clone, Copy)]
+pub struct Function<R: TreeRoot = Arc<SyntaxRoot>> {
+    syntax: SyntaxNode<R>,
+}
+
+impl<R: TreeRoot> AstNode<R> for Function<R> {
+    fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
+        match syntax.kind() {
+            FUNCTION => Some(Function { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
+}
+
+
+#[derive(Debug, Clone, Copy)]
+pub struct Name<R: TreeRoot = Arc<SyntaxRoot>> {
+    syntax: SyntaxNode<R>,
+}
+
+impl<R: TreeRoot> AstNode<R> for Name<R> {
+    fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
+        match syntax.kind() {
+            NAME => Some(Name { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
+}
+
diff --git a/crates/libsyntax2/src/ast/generated.rs.tera b/crates/libsyntax2/src/ast/generated.rs.tera
new file mode 100644
index 000000000..242837801
--- /dev/null
+++ b/crates/libsyntax2/src/ast/generated.rs.tera
@@ -0,0 +1,22 @@
+use std::sync::Arc;
+use {
+    SyntaxNode, SyntaxRoot, TreeRoot, AstNode,
+    SyntaxKind::*,
+};
+{% for node in ast %}
+{% set Name = node.kind | camel  %}
+#[derive(Debug, Clone, Copy)]
+pub struct {{ Name }}<R: TreeRoot = Arc<SyntaxRoot>> {
+    syntax: SyntaxNode<R>,
+}
+
+impl<R: TreeRoot> AstNode<R> for {{ Name }}<R> {
+    fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
+        match syntax.kind() {
+            {{ node.kind }} => Some({{ Name }} { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
+}
+{% endfor %}
diff --git a/crates/libsyntax2/src/ast/mod.rs b/crates/libsyntax2/src/ast/mod.rs
new file mode 100644
index 000000000..eeb7ae6f6
--- /dev/null
+++ b/crates/libsyntax2/src/ast/mod.rs
@@ -0,0 +1,74 @@
+mod generated;
+
+use std::sync::Arc;
+use {
+    SyntaxNode, SyntaxRoot, TreeRoot, SyntaxError,
+    SyntaxKind::*,
+};
+pub use self::generated::*;
+
+pub trait AstNode<R: TreeRoot>: Sized {
+    fn cast(syntax: SyntaxNode<R>) -> Option<Self>;
+    fn syntax(&self) -> &SyntaxNode<R>;
+}
+
+impl File<Arc<SyntaxRoot>> {
+    pub fn parse(text: &str) -> Self {
+        File::cast(::parse(text)).unwrap()
+    }
+}
+
+impl<R: TreeRoot> File<R> {
+    pub fn errors(&self) -> Vec<SyntaxError> {
+        self.syntax().root.errors.clone()
+    }
+
+    pub fn functions<'a>(&'a self) -> impl Iterator<Item = Function<R>> + 'a {
+        self.syntax()
+            .children()
+            .filter_map(Function::cast)
+    }
+}
+
+impl<R: TreeRoot> Function<R> {
+    pub fn name(&self) -> Option<Name<R>> {
+        self.syntax()
+            .children()
+            .filter_map(Name::cast)
+            .next()
+    }
+
+    pub fn has_atom_attr(&self, atom: &str) -> bool {
+        self.syntax()
+            .children()
+            .filter(|node| node.kind() == ATTR)
+            .any(|attr| {
+                let mut metas = attr.children().filter(|node| node.kind() == META_ITEM);
+                let meta = match metas.next() {
+                    None => return false,
+                    Some(meta) => {
+                        if metas.next().is_some() {
+                            return false;
+                        }
+                        meta
+                    }
+                };
+                let mut children = meta.children();
+                match children.next() {
+                    None => false,
+                    Some(child) => {
+                        if children.next().is_some() {
+                            return false;
+                        }
+                        child.kind() == IDENT && child.text() == atom
+                    }
+                }
+            })
+    }
+}
+
+impl<R: TreeRoot> Name<R> {
+    pub fn text(&self) -> String {
+        self.syntax().text()
+    }
+}
diff --git a/crates/libsyntax2/src/grammar.ron b/crates/libsyntax2/src/grammar.ron
new file mode 100644
index 000000000..bcc79843a
--- /dev/null
+++ b/crates/libsyntax2/src/grammar.ron
@@ -0,0 +1,227 @@
+Grammar(
+    single_byte_tokens: [
+        [";", "SEMI"],
+        [",", "COMMA"],
+        ["(", "L_PAREN"],
+        [")", "R_PAREN"],
+        ["{", "L_CURLY"],
+        ["}", "R_CURLY"],
+        ["[", "L_BRACK"],
+        ["]", "R_BRACK"],
+        ["<", "L_ANGLE"],
+        [">", "R_ANGLE"],
+        ["@", "AT"],
+        ["#", "POUND"],
+        ["~", "TILDE"],
+        ["?", "QUESTION"],
+        ["$", "DOLLAR"],
+        ["&", "AMP"],
+        ["|", "PIPE"],
+        ["+", "PLUS"],
+        ["*", "STAR"],
+        ["/", "SLASH"],
+        ["^", "CARET"],
+        ["%", "PERCENT"],
+    ],
+    multi_byte_tokens: [
+        [".", "DOT"],
+        ["..", "DOTDOT"],
+        ["...", "DOTDOTDOT"],
+        ["..=", "DOTDOTEQ"],
+        [":", "COLON"],
+        ["::", "COLONCOLON"],
+        ["=", "EQ"],
+        ["==", "EQEQ"],
+        ["=>", "FAT_ARROW"],
+        ["!", "EXCL"],
+        ["!=", "NEQ"],
+        ["-", "MINUS"],
+        ["->", "THIN_ARROW"],
+        ["<=", "LTEQ"],
+        [">=", "GTEQ"],
+        ["+=", "PLUSEQ"],
+        ["-=", "MINUSEQ"],
+        ["&&", "AMPAMP"],
+        ["||", "PIPEPIPE"],
+        ["<<", "SHL"],
+        [">>", "SHR"],
+        ["<<=", "SHLEQ"],
+        [">>=", "SHREQ"],
+    ],
+    keywords: [
+        "use",
+        "fn",
+        "struct",
+        "enum",
+        "trait",
+        "impl",
+        "true",
+        "false",
+        "as",
+        "extern",
+        "crate",
+        "mod",
+        "pub",
+        "self",
+        "super",
+        "in",
+        "where",
+        "for",
+        "loop",
+        "while",
+        "if",
+        "else",
+        "match",
+        "const",
+        "static",
+        "mut",
+        "unsafe",
+        "type",
+        "ref",
+        "let",
+        "move",
+        "return",
+    ],
+    contextual_keywords: [
+        "auto",
+        "default",
+        "union",
+    ],
+    tokens: [
+        "ERROR",
+        "IDENT",
+        "UNDERSCORE",
+        "WHITESPACE",
+        "INT_NUMBER",
+        "FLOAT_NUMBER",
+        "LIFETIME",
+        "CHAR",
+        "BYTE",
+        "STRING",
+        "RAW_STRING",
+        "BYTE_STRING",
+        "RAW_BYTE_STRING",
+        "COMMENT",
+        "DOC_COMMENT",
+        "SHEBANG",
+    ],
+    nodes: [
+        "FILE",
+
+        "STRUCT_ITEM",
+        "ENUM_ITEM",
+        "FUNCTION",
+        "EXTERN_CRATE_ITEM",
+        "MOD_ITEM",
+        "USE_ITEM",
+        "STATIC_ITEM",
+        "CONST_ITEM",
+        "TRAIT_ITEM",
+        "IMPL_ITEM",
+        "TYPE_ITEM",
+        "MACRO_CALL",
+        "TOKEN_TREE",
+
+        "PAREN_TYPE",
+        "TUPLE_TYPE",
+        "NEVER_TYPE",
+        "PATH_TYPE",
+        "POINTER_TYPE",
+        "ARRAY_TYPE",
+        "SLICE_TYPE",
+        "REFERENCE_TYPE",
+        "PLACEHOLDER_TYPE",
+        "FN_POINTER_TYPE",
+        "FOR_TYPE",
+        "IMPL_TRAIT_TYPE",
+
+        "REF_PAT",
+        "BIND_PAT",
+        "PLACEHOLDER_PAT",
+        "PATH_PAT",
+        "STRUCT_PAT",
+        "TUPLE_STRUCT_PAT",
+        "TUPLE_PAT",
+        "SLICE_PAT",
+        "RANGE_PAT",
+
+        // atoms
+        "TUPLE_EXPR",
+        "ARRAY_EXPR",
+        "PAREN_EXPR",
+        "PATH_EXPR",
+        "LAMBDA_EXPR",
+        "IF_EXPR",
+        "WHILE_EXPR",
+        "LOOP_EXPR",
+        "FOR_EXPR",
+        "BLOCK_EXPR",
+        "RETURN_EXPR",
+        "MATCH_EXPR",
+        "MATCH_ARM",
+        "MATCH_GUARD",
+        "STRUCT_LIT",
+        "STRUCT_LIT_FIELD",
+
+        // postfix
+        "CALL_EXPR",
+        "INDEX_EXPR",
+        "METHOD_CALL_EXPR",
+        "FIELD_EXPR",
+        "TRY_EXPR",
+        "CAST_EXPR",
+
+        // unary
+        "REF_EXPR",
+        "PREFIX_EXPR",
+
+        "RANGE_EXPR", // just weird
+        "BIN_EXPR",
+
+
+        "EXTERN_BLOCK_EXPR",
+        "ENUM_VARIANT",
+        "NAMED_FIELD",
+        "POS_FIELD",
+        "ATTR",
+        "META_ITEM", // not an item actually
+        "USE_TREE",
+        "PATH",
+        "PATH_SEGMENT",
+        "LITERAL",
+        "ALIAS",
+        "VISIBILITY",
+        "WHERE_CLAUSE",
+        "WHERE_PRED",
+        "ABI",
+        "NAME",
+        "NAME_REF",
+
+        "LET_STMT",
+        "EXPR_STMT",
+
+        "TYPE_PARAM_LIST",
+        "LIFETIME_PARAM",
+        "TYPE_PARAM",
+        "TYPE_ARG_LIST",
+        "LIFETIME_ARG",
+        "TYPE_ARG",
+        "ASSOC_TYPE_ARG",
+
+        "PARAM_LIST",
+        "PARAM",
+        "SELF_PARAM",
+        "ARG_LIST",
+    ],
+    ast: [
+        (
+            kind: "FILE"
+        ),
+        (
+            kind: "FUNCTION"
+        ),
+        (
+            kind: "NAME"
+        ),
+    ]
+)
diff --git a/crates/libsyntax2/src/grammar/attributes.rs b/crates/libsyntax2/src/grammar/attributes.rs
new file mode 100644
index 000000000..c411d4d7f
--- /dev/null
+++ b/crates/libsyntax2/src/grammar/attributes.rs
@@ -0,0 +1,79 @@
+use super::*;
+
+pub(super) fn inner_attributes(p: &mut Parser) {
+    while p.current() == POUND && p.nth(1) == EXCL {
+        attribute(p, true)
+    }
+}
+
+pub(super) fn outer_attributes(p: &mut Parser) {
+    while p.at(POUND) {
+        attribute(p, false)
+    }
+}
+
+fn attribute(p: &mut Parser, inner: bool) {
+    let attr = p.start();
+    assert!(p.at(POUND));
+    p.bump();
+
+    if inner {
+        assert!(p.at(EXCL));
+        p.bump();
+    }
+
+    if p.expect(L_BRACK) {
+        meta_item(p);
+        p.expect(R_BRACK);
+    }
+    attr.complete(p, ATTR);
+}
+
+fn meta_item(p: &mut Parser) {
+    if p.at(IDENT) {
+        let meta_item = p.start();
+        p.bump();
+        match p.current() {
+            EQ => {
+                p.bump();
+                if expressions::literal(p).is_none() {
+                    p.error("expected literal");
+                }
+            }
+            L_PAREN => meta_item_arg_list(p),
+            _ => (),
+        }
+        meta_item.complete(p, META_ITEM);
+    } else {
+        p.error("expected attribute value");
+    }
+}
+
+fn meta_item_arg_list(p: &mut Parser) {
+    assert!(p.at(L_PAREN));
+    p.bump();
+    loop {
+        match p.current() {
+            EOF | R_PAREN => break,
+            IDENT => meta_item(p),
+            c => if expressions::literal(p).is_none() {
+                let message = "expected attribute";
+
+                if items::ITEM_FIRST.contains(c) {
+                    p.error(message);
+                    return;
+                }
+
+                let err = p.start();
+                p.error(message);
+                p.bump();
+                err.complete(p, ERROR);
+                continue;
+            },
+        }
+        if !p.at(R_PAREN) {
+            p.expect(COMMA);
+        }
+    }
+    p.expect(R_PAREN);
+}
diff --git a/crates/libsyntax2/src/grammar/expressions/atom.rs b/crates/libsyntax2/src/grammar/expressions/atom.rs
new file mode 100644
index 000000000..af9f47c5e
--- /dev/null
+++ b/crates/libsyntax2/src/grammar/expressions/atom.rs
@@ -0,0 +1,348 @@
+use super::*;
+
+// test expr_literals
+// fn foo() {
+//     let _ = true;
+//     let _ = false;
+//     let _ = 1;
+//     let _ = 2.0;
+//     let _ = b'a';
+//     let _ = 'b';
+//     let _ = "c";
+//     let _ = r"d";
+//     let _ = b"e";
+//     let _ = br"f";
+// }
+const LITERAL_FIRST: TokenSet =
+    token_set![TRUE_KW, FALSE_KW, INT_NUMBER, FLOAT_NUMBER, BYTE, CHAR,
+               STRING, RAW_STRING, BYTE_STRING, RAW_BYTE_STRING];
+
+pub(crate) fn literal(p: &mut Parser) -> Option<CompletedMarker> {
+    if !LITERAL_FIRST.contains(p.current()) {
+        return None;
+    }
+    let m = p.start();
+    p.bump();
+    Some(m.complete(p, LITERAL))
+}
+
+pub(super) const ATOM_EXPR_FIRST: TokenSet =
+    token_set_union![
+        LITERAL_FIRST,
+        token_set![L_PAREN, PIPE, MOVE_KW, IF_KW, WHILE_KW, MATCH_KW, UNSAFE_KW, L_CURLY, RETURN_KW,
+                   IDENT, SELF_KW, SUPER_KW, COLONCOLON ],
+    ];
+
+pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<CompletedMarker> {
+    match literal(p) {
+        Some(m) => return Some(m),
+        None => (),
+    }
+    if paths::is_path_start(p) {
+        return Some(path_expr(p, r));
+    }
+    let la = p.nth(1);
+    let done = match p.current() {
+        L_PAREN => tuple_expr(p),
+        L_BRACK => array_expr(p),
+        PIPE => lambda_expr(p),
+        MOVE_KW if la == PIPE => lambda_expr(p),
+        IF_KW => if_expr(p),
+        WHILE_KW => while_expr(p),
+        LOOP_KW => loop_expr(p),
+        FOR_KW => for_expr(p),
+        MATCH_KW => match_expr(p),
+        UNSAFE_KW if la == L_CURLY => block_expr(p),
+        L_CURLY => block_expr(p),
+        RETURN_KW => return_expr(p),
+        _ => {
+            p.err_and_bump("expected expression");
+            return None;
+        }
+    };
+    Some(done)
+}
+
+// test tuple_expr
+// fn foo() {
+//     ();
+//     (1);
+//     (1,);
+// }
+fn tuple_expr(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(L_PAREN));
+    let m = p.start();
+    p.expect(L_PAREN);
+
+    let mut saw_comma = false;
+    let mut saw_expr = false;
+    while !p.at(EOF) && !p.at(R_PAREN) {
+        saw_expr = true;
+        expr(p);
+        if !p.at(R_PAREN) {
+            saw_comma = true;
+            p.expect(COMMA);
+        }
+    }
+    p.expect(R_PAREN);
+    m.complete(p, if saw_expr && !saw_comma { PAREN_EXPR } else { TUPLE_EXPR })
+}
+
+// test array_expr
+// fn foo() {
+//     [];
+//     [1];
+//     [1, 2,];
+//     [1; 2];
+// }
+fn array_expr(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(L_BRACK));
+    let m = p.start();
+    p.bump();
+    if p.eat(R_BRACK) {
+        return m.complete(p, ARRAY_EXPR);
+    }
+    expr(p);
+    if p.eat(SEMI) {
+        expr(p);
+        p.expect(R_BRACK);
+        return m.complete(p, ARRAY_EXPR);
+    }
+    while !p.at(EOF) && !p.at(R_BRACK) {
+        p.expect(COMMA);
+        if !p.at(R_BRACK) {
+            expr(p);
+        }
+    }
+    p.expect(R_BRACK);
+    m.complete(p, ARRAY_EXPR)
+}
+
+// test lambda_expr
+// fn foo() {
+//     || ();
+//     || -> i32 { 92 };
+//     |x| x;
+//     move |x: i32,| x;
+// }
+fn lambda_expr(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(PIPE) || (p.at(MOVE_KW) && p.nth(1) == PIPE));
+    let m = p.start();
+    p.eat(MOVE_KW);
+    params::param_list_opt_types(p);
+    if fn_ret_type(p) {
+        block(p);
+    } else {
+        expr(p);
+    }
+    m.complete(p, LAMBDA_EXPR)
+}
+
+// test if_expr
+// fn foo() {
+//     if true {};
+//     if true {} else {};
+//     if true {} else if false {} else {};
+//     if S {};
+// }
+fn if_expr(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(IF_KW));
+    let m = p.start();
+    p.bump();
+    cond(p);
+    block(p);
+    if p.at(ELSE_KW) {
+        p.bump();
+        if p.at(IF_KW) {
+            if_expr(p);
+        } else {
+            block(p);
+        }
+    }
+    m.complete(p, IF_EXPR)
+}
+
+// test while_expr
+// fn foo() {
+//     while true {};
+//     while let Some(x) = it.next() {};
+// }
+fn while_expr(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(WHILE_KW));
+    let m = p.start();
+    p.bump();
+    cond(p);
+    block(p);
+    m.complete(p, WHILE_EXPR)
+}
+
+// test loop_expr
+// fn foo() {
+//     loop {};
+// }
+fn loop_expr(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(LOOP_KW));
+    let m = p.start();
+    p.bump();
+    block(p);
+    m.complete(p, LOOP_EXPR)
+}
+
+// test for_expr
+// fn foo() {
+//     for x in [] {};
+// }
+fn for_expr(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(FOR_KW));
+    let m = p.start();
+    p.bump();
+    patterns::pattern(p);
+    p.expect(IN_KW);
+    expr_no_struct(p);
+    block(p);
+    m.complete(p, FOR_EXPR)
+}
+
+// test cond
+// fn foo() { if let Some(_) = None {} }
+fn cond(p: &mut Parser) {
+    if p.eat(LET_KW) {
+        patterns::pattern(p);
+        p.expect(EQ);
+    }
+    expr_no_struct(p)
+}
+
+// test match_expr
+// fn foo() {
+//     match () { };
+//     match S {};
+// }
+fn match_expr(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(MATCH_KW));
+    let m = p.start();
+    p.bump();
+    expr_no_struct(p);
+    p.eat(L_CURLY);
+    while !p.at(EOF) && !p.at(R_CURLY) {
+        // test match_arms_commas
+        // fn foo() {
+        //     match () {
+        //         _ => (),
+        //         _ => {}
+        //         _ => ()
+        //     }
+        // }
+        if match_arm(p).is_block() {
+            p.eat(COMMA);
+        } else if !p.at(R_CURLY) {
+            p.expect(COMMA);
+        }
+    }
+    p.expect(R_CURLY);
+    m.complete(p, MATCH_EXPR)
+}
+
+// test match_arm
+// fn foo() {
+//     match () {
+//         _ => (),
+//         X | Y if Z => (),
+//     };
+// }
+fn match_arm(p: &mut Parser) -> BlockLike {
+    let m = p.start();
+    loop {
+        patterns::pattern(p);
+        if !p.eat(PIPE) {
+            break;
+        }
+    }
+    if p.eat(IF_KW) {
+        expr_no_struct(p);
+    }
+    p.expect(FAT_ARROW);
+    let ret = expr_stmt(p);
+    m.complete(p, MATCH_ARM);
+    ret
+}
+
+// test block_expr
+// fn foo() {
+//     {};
+//     unsafe {};
+// }
+pub(super) fn block_expr(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(L_CURLY) || p.at(UNSAFE_KW) && p.nth(1) == L_CURLY);
+    let m = p.start();
+    p.eat(UNSAFE_KW);
+    p.bump();
+    while !p.at(EOF) && !p.at(R_CURLY) {
+        match p.current() {
+            LET_KW => let_stmt(p),
+            _ => {
+                // test block_items
+                // fn a() { fn b() {} }
+                let m = p.start();
+                match items::maybe_item(p) {
+                    items::MaybeItem::Item(kind) => {
+                        m.complete(p, kind);
+                    }
+                    items::MaybeItem::Modifiers => {
+                        m.abandon(p);
+                        p.error("expected an item");
+                    }
+                    // test pub_expr
+                    // fn foo() { pub 92; } //FIXME
+                    items::MaybeItem::None => {
+                        let is_blocklike = expressions::expr_stmt(p) == BlockLike::Block;
+                        if p.eat(SEMI) || (is_blocklike && !p.at(R_CURLY)) {
+                            m.complete(p, EXPR_STMT);
+                        } else {
+                            m.abandon(p);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    p.expect(R_CURLY);
+    m.complete(p, BLOCK_EXPR)
+}
+
+// test let_stmt;
+// fn foo() {
+//     let a;
+//     let b: i32;
+//     let c = 92;
+//     let d: i32 = 92;
+// }
+fn let_stmt(p: &mut Parser) {
+    assert!(p.at(LET_KW));
+    let m = p.start();
+    p.bump();
+    patterns::pattern(p);
+    if p.at(COLON) {
+        types::ascription(p);
+    }
+    if p.eat(EQ) {
+        expressions::expr(p);
+    }
+    p.expect(SEMI);
+    m.complete(p, LET_STMT);
+}
+
+// test return_expr
+// fn foo() {
+//     return;
+//     return 92;
+// }
+fn return_expr(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(RETURN_KW));
+    let m = p.start();
+    p.bump();
+    if EXPR_FIRST.contains(p.current()) {
+        expr(p);
+    }
+    m.complete(p, RETURN_EXPR)
+}
diff --git a/crates/libsyntax2/src/grammar/expressions/mod.rs b/crates/libsyntax2/src/grammar/expressions/mod.rs
new file mode 100644
index 000000000..dcbb1e2a8
--- /dev/null
+++ b/crates/libsyntax2/src/grammar/expressions/mod.rs
@@ -0,0 +1,379 @@
+mod atom;
+
+use super::*;
+pub(super) use self::atom::literal;
+
+const EXPR_FIRST: TokenSet = LHS_FIRST;
+
+pub(super) fn expr(p: &mut Parser) -> BlockLike {
+    let r = Restrictions { forbid_structs: false, prefer_stmt: false };
+    expr_bp(p, r, 1)
+}
+
+pub(super) fn expr_stmt(p: &mut Parser) -> BlockLike {
+    let r = Restrictions { forbid_structs: false, prefer_stmt: true };
+    expr_bp(p, r, 1)
+}
+
+fn expr_no_struct(p: &mut Parser) {
+    let r = Restrictions { forbid_structs: true, prefer_stmt: false };
+    expr_bp(p, r, 1);
+}
+
+// test block
+// fn a() {}
+// fn b() { let _ = 1; }
+// fn c() { 1; 2; }
+// fn d() { 1; 2 }
+pub(super) fn block(p: &mut Parser) {
+    if !p.at(L_CURLY) {
+        p.error("expected block");
+        return;
+    }
+    atom::block_expr(p);
+}
+
+#[derive(Clone, Copy)]
+struct Restrictions {
+    forbid_structs: bool,
+    prefer_stmt: bool,
+}
+
+enum Op {
+    Simple,
+    Composite(SyntaxKind, u8),
+}
+
+fn current_op(p: &Parser) -> (u8, Op) {
+    if p.at_compound2(PLUS, EQ) {
+        return (1, Op::Composite(PLUSEQ, 2));
+    }
+    if p.at_compound2(MINUS, EQ) {
+        return (1, Op::Composite(MINUSEQ, 2));
+    }
+    if p.at_compound3(L_ANGLE, L_ANGLE, EQ) {
+        return (1, Op::Composite(SHLEQ, 3));
+    }
+    if p.at_compound3(R_ANGLE, R_ANGLE, EQ) {
+        return (1, Op::Composite(SHREQ, 3));
+    }
+    if p.at_compound2(PIPE, PIPE) {
+        return (3, Op::Composite(PIPEPIPE, 2));
+    }
+    if p.at_compound2(AMP, AMP) {
+        return (4, Op::Composite(AMPAMP, 2));
+    }
+    if p.at_compound2(L_ANGLE, EQ) {
+        return (5, Op::Composite(LTEQ, 2));
+    }
+    if p.at_compound2(R_ANGLE, EQ) {
+        return (5, Op::Composite(GTEQ, 2));
+    }
+    if p.at_compound2(L_ANGLE, L_ANGLE) {
+        return (9, Op::Composite(SHL, 2));
+    }
+    if p.at_compound2(R_ANGLE, R_ANGLE) {
+        return (9, Op::Composite(SHR, 2));
+    }
+
+    let bp = match p.current() {
+        EQ => 1,
+        DOTDOT => 2,
+        EQEQ | NEQ | L_ANGLE | R_ANGLE => 5,
+        PIPE => 6,
+        CARET => 7,
+        AMP => 8,
+        MINUS | PLUS => 10,
+        STAR | SLASH | PERCENT => 11,
+        _ => 0,
+    };
+    (bp, Op::Simple)
+}
+
+// Parses expression with binding power of at least bp.
+fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> BlockLike {
+    let mut lhs = match lhs(p, r) {
+        Some(lhs) => {
+            // test stmt_bin_expr_ambiguity
+            // fn foo() {
+            //     let _ = {1} & 2;
+            //     {1} &2;
+            // }
+            if r.prefer_stmt && is_block(lhs.kind()) {
+                return BlockLike::Block;
+            }
+            lhs
+        }
+        None => return BlockLike::NotBlock,
+    };
+
+    loop {
+        let is_range = p.current() == DOTDOT;
+        let (op_bp, op) = current_op(p);
+        if op_bp < bp {
+            break;
+        }
+        let m = lhs.precede(p);
+        match op {
+            Op::Simple => p.bump(),
+            Op::Composite(kind, n) => {
+                p.bump_compound(kind, n);
+            }
+        }
+        expr_bp(p, r, op_bp + 1);
+        lhs = m.complete(p, if is_range { RANGE_EXPR } else { BIN_EXPR });
+    }
+    BlockLike::NotBlock
+}
+
+// test no_semi_after_block
+// fn foo() {
+//     if true {}
+//     loop {}
+//     match () {}
+//     while true {}
+//     for _ in () {}
+//     {}
+//     {}
+// }
+fn is_block(kind: SyntaxKind) -> bool {
+    match kind {
+        IF_EXPR | WHILE_EXPR | FOR_EXPR | LOOP_EXPR | MATCH_EXPR | BLOCK_EXPR => true,
+        _ => false,
+    }
+}
+
+const LHS_FIRST: TokenSet =
+    token_set_union![
+        token_set![AMP, STAR, EXCL, DOTDOT, MINUS],
+        atom::ATOM_EXPR_FIRST,
+    ];
+
+fn lhs(p: &mut Parser, r: Restrictions) -> Option<CompletedMarker> {
+    let m;
+    let kind = match p.current() {
+        // test ref_expr
+        // fn foo() {
+        //     let _ = &1;
+        //     let _ = &mut &f();
+        // }
+        AMP => {
+            m = p.start();
+            p.bump();
+            p.eat(MUT_KW);
+            REF_EXPR
+        }
+        // test unary_expr
+        // fn foo() {
+        //     **&1;
+        //     !!true;
+        //     --1;
+        // }
+        STAR | EXCL | MINUS => {
+            m = p.start();
+            p.bump();
+            PREFIX_EXPR
+        }
+        DOTDOT => {
+            m = p.start();
+            p.bump();
+            expr_bp(p, r, 2);
+            return Some(m.complete(p, RANGE_EXPR));
+        }
+        _ => {
+            let lhs = atom::atom_expr(p, r)?;
+            return Some(postfix_expr(p, r, lhs));
+        }
+    };
+    expr_bp(p, r, 255);
+    Some(m.complete(p, kind))
+}
+
+fn postfix_expr(p: &mut Parser, r: Restrictions, mut lhs: CompletedMarker) -> CompletedMarker {
+    let mut allow_calls = !r.prefer_stmt || !is_block(lhs.kind());
+    loop {
+        lhs = match p.current() {
+            // test stmt_postfix_expr_ambiguity
+            // fn foo() {
+            //     match () {
+            //         _ => {}
+            //         () => {}
+            //         [] => {}
+            //     }
+            // }
+            L_PAREN if allow_calls => call_expr(p, lhs),
+            L_BRACK if allow_calls => index_expr(p, lhs),
+            DOT if p.nth(1) == IDENT => if p.nth(2) == L_PAREN || p.nth(2) == COLONCOLON {
+                method_call_expr(p, lhs)
+            } else {
+                field_expr(p, lhs)
+            },
+            DOT if p.nth(1) == INT_NUMBER => field_expr(p, lhs),
+            // test postfix_range
+            // fn foo() { let x = 1..; }
+            DOTDOT if !EXPR_FIRST.contains(p.nth(1)) => {
+                let m = lhs.precede(p);
+                p.bump();
+                m.complete(p, RANGE_EXPR)
+            }
+            QUESTION => try_expr(p, lhs),
+            AS_KW => cast_expr(p, lhs),
+            _ => break,
+        };
+        allow_calls = true
+    }
+    lhs
+}
+
+// test call_expr
+// fn foo() {
+//     let _ = f();
+//     let _ = f()(1)(1, 2,);
+// }
+fn call_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
+    assert!(p.at(L_PAREN));
+    let m = lhs.precede(p);
+    arg_list(p);
+    m.complete(p, CALL_EXPR)
+}
+
+// test index_expr
+// fn foo() {
+//     x[1][2];
+// }
+fn index_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
+    assert!(p.at(L_BRACK));
+    let m = lhs.precede(p);
+    p.bump();
+    expr(p);
+    p.expect(R_BRACK);
+    m.complete(p, INDEX_EXPR)
+}
+
+// test method_call_expr
+// fn foo() {
+//     x.foo();
+//     y.bar::<T>(1, 2,);
+// }
+fn method_call_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
+    assert!(
+        p.at(DOT) && p.nth(1) == IDENT
+            && (p.nth(2) == L_PAREN || p.nth(2) == COLONCOLON)
+    );
+    let m = lhs.precede(p);
+    p.bump();
+    name_ref(p);
+    type_args::type_arg_list(p, true);
+    arg_list(p);
+    m.complete(p, METHOD_CALL_EXPR)
+}
+
+// test field_expr
+// fn foo() {
+//     x.foo;
+//     x.0.bar;
+// }
+fn field_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
+    assert!(p.at(DOT) && (p.nth(1) == IDENT || p.nth(1) == INT_NUMBER));
+    let m = lhs.precede(p);
+    p.bump();
+    if p.at(IDENT) {
+        name_ref(p)
+    } else {
+        p.bump()
+    }
+    m.complete(p, FIELD_EXPR)
+}
+
+// test try_expr
+// fn foo() {
+//     x?;
+// }
+fn try_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
+    assert!(p.at(QUESTION));
+    let m = lhs.precede(p);
+    p.bump();
+    m.complete(p, TRY_EXPR)
+}
+
+// test cast_expr
+// fn foo() {
+//     82 as i32;
+// }
+fn cast_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
+    assert!(p.at(AS_KW));
+    let m = lhs.precede(p);
+    p.bump();
+    types::type_(p);
+    m.complete(p, CAST_EXPR)
+}
+
+fn arg_list(p: &mut Parser) {
+    assert!(p.at(L_PAREN));
+    let m = p.start();
+    p.bump();
+    while !p.at(R_PAREN) && !p.at(EOF) {
+        expr(p);
+        if !p.at(R_PAREN) && !p.expect(COMMA) {
+            break;
+        }
+    }
+    p.eat(R_PAREN);
+    m.complete(p, ARG_LIST);
+}
+
+// test path_expr
+// fn foo() {
+//     let _ = a;
+//     let _ = a::b;
+//     let _ = ::a::<b>;
+//     let _ = format!();
+// }
+fn path_expr(p: &mut Parser, r: Restrictions) -> CompletedMarker {
+    assert!(paths::is_path_start(p));
+    let m = p.start();
+    paths::expr_path(p);
+    match p.current() {
+        L_CURLY if !r.forbid_structs => {
+            struct_lit(p);
+            m.complete(p, STRUCT_LIT)
+        }
+        EXCL => {
+            items::macro_call_after_excl(p);
+            m.complete(p, MACRO_CALL)
+        }
+        _ => m.complete(p, PATH_EXPR)
+    }
+}
+
+// test struct_lit
+// fn foo() {
+//     S {};
+//     S { x, y: 32, };
+//     S { x, y: 32, ..Default::default() };
+// }
+fn struct_lit(p: &mut Parser) {
+    assert!(p.at(L_CURLY));
+    p.bump();
+    while !p.at(EOF) && !p.at(R_CURLY) {
+        match p.current() {
+            IDENT => {
+                let m = p.start();
+                name_ref(p);
+                if p.eat(COLON) {
+                    expr(p);
+                }
+                m.complete(p, STRUCT_LIT_FIELD);
+            }
+            DOTDOT => {
+                p.bump();
+                expr(p);
+            }
+            _ => p.err_and_bump("expected identifier"),
+        }
+        if !p.at(R_CURLY) {
+            p.expect(COMMA);
+        }
+    }
+    p.expect(R_CURLY);
+}
diff --git a/crates/libsyntax2/src/grammar/items/consts.rs b/crates/libsyntax2/src/grammar/items/consts.rs
new file mode 100644
index 000000000..b11949b49
--- /dev/null
+++ b/crates/libsyntax2/src/grammar/items/consts.rs
@@ -0,0 +1,21 @@
+use super::*;
+
+pub(super) fn static_item(p: &mut Parser) {
+    const_or_static(p, STATIC_KW)
+}
+
+pub(super) fn const_item(p: &mut Parser) {
+    const_or_static(p, CONST_KW)
+}
+
+fn const_or_static(p: &mut Parser, kw: SyntaxKind) {
+    assert!(p.at(kw));
+    p.bump();
+    p.eat(MUT_KW); // TODO: validator to forbid const mut
+    name(p);
+    types::ascription(p);
+    if p.eat(EQ) {
+        expressions::expr(p);
+    }
+    p.expect(SEMI);
+}
diff --git a/crates/libsyntax2/src/grammar/items/mod.rs b/crates/libsyntax2/src/grammar/items/mod.rs
new file mode 100644
index 000000000..3bf906f85
--- /dev/null
+++ b/crates/libsyntax2/src/grammar/items/mod.rs
@@ -0,0 +1,332 @@
+use super::*;
+
+mod consts;
+mod structs;
+mod traits;
+mod use_item;
+
+// test mod_contents
+// fn foo() {}
+// macro_rules! foo {}
+// foo::bar!();
+// super::baz! {}
+// struct S;
+pub(super) fn mod_contents(p: &mut Parser, stop_on_r_curly: bool) {
+    attributes::inner_attributes(p);
+    while !p.at(EOF) && !(stop_on_r_curly && p.at(R_CURLY)) {
+        item_or_macro(p, stop_on_r_curly)
+    }
+}
+
+pub(super) fn item_or_macro(p: &mut Parser, stop_on_r_curly: bool) {
+    let m = p.start();
+    match maybe_item(p) {
+        MaybeItem::Item(kind) => {
+            m.complete(p, kind);
+        }
+        MaybeItem::None => {
+            if paths::is_path_start(p) {
+                match macro_call(p) {
+                    BlockLike::Block => (),
+                    BlockLike::NotBlock => {
+                        p.expect(SEMI);
+                    }
+                }
+                m.complete(p, MACRO_CALL);
+            } else {
+                m.abandon(p);
+                if p.at(L_CURLY) {
+                    error_block(p, "expected an item");
+                } else if !p.at(EOF) && !(stop_on_r_curly && p.at(R_CURLY)) {
+                    p.err_and_bump("expected an item");
+                } else {
+                    p.error("expected an item");
+                }
+            }
+        }
+        MaybeItem::Modifiers => {
+            p.error("expected fn, trait or impl");
+            m.complete(p, ERROR);
+        }
+    }
+}
+
+pub(super) const ITEM_FIRST: TokenSet =
+    token_set![EXTERN_KW, MOD_KW, USE_KW, STRUCT_KW, ENUM_KW, FN_KW, PUB_KW, POUND];
+
+pub(super) enum MaybeItem {
+    None,
+    Item(SyntaxKind),
+    Modifiers,
+}
+
+pub(super) fn maybe_item(p: &mut Parser) -> MaybeItem {
+    attributes::outer_attributes(p);
+    visibility(p);
+    if let Some(kind) = items_without_modifiers(p) {
+        return MaybeItem::Item(kind);
+    }
+
+    let mut has_mods = false;
+    // modifiers
+    has_mods |= p.eat(CONST_KW);
+
+    // test unsafe_block_in_mod
+    // fn foo(){} unsafe { } fn bar(){}
+    if p.at(UNSAFE_KW) && p.nth(1) != L_CURLY {
+        p.eat(UNSAFE_KW);
+        has_mods = true;
+    }
+    if p.at(EXTERN_KW) {
+        has_mods = true;
+        abi(p);
+    }
+    if p.at(IDENT) && p.at_contextual_kw("auto") && p.nth(1) == TRAIT_KW {
+        p.bump_remap(AUTO_KW);
+        has_mods = true;
+    }
+    if p.at(IDENT) && p.at_contextual_kw("default") && p.nth(1) == IMPL_KW {
+        p.bump_remap(DEFAULT_KW);
+        has_mods = true;
+    }
+
+    // items
+    let kind = match p.current() {
+        // test extern_fn
+        // extern fn foo() {}
+
+        // test const_fn
+        // const fn foo() {}
+
+        // test const_unsafe_fn
+        // const unsafe fn foo() {}
+
+        // test unsafe_extern_fn
+        // unsafe extern "C" fn foo() {}
+
+        // test unsafe_fn
+        // unsafe fn foo() {}
+        FN_KW => {
+            function(p);
+            FUNCTION
+        }
+
+        // test unsafe_trait
+        // unsafe trait T {}
+
+        // test auto_trait
+        // auto trait T {}
+
+        // test unsafe_auto_trait
+        // unsafe auto trait T {}
+        TRAIT_KW => {
+            traits::trait_item(p);
+            TRAIT_ITEM
+        }
+
+        // test unsafe_impl
+        // unsafe impl Foo {}
+
+        // test default_impl
+        // default impl Foo {}
+
+        // test unsafe_default_impl
+        // unsafe default impl Foo {}
+        IMPL_KW => {
+            traits::impl_item(p);
+            IMPL_ITEM
+        }
+        _ => return if has_mods {
+            MaybeItem::Modifiers
+        } else {
+            MaybeItem::None
+        }
+    };
+
+    MaybeItem::Item(kind)
+}
+
+fn items_without_modifiers(p: &mut Parser) -> Option<SyntaxKind> {
+    let la = p.nth(1);
+    let kind = match p.current() {
+        // test extern_crate
+        // extern crate foo;
+        EXTERN_KW if la == CRATE_KW => {
+            extern_crate_item(p);
+            EXTERN_CRATE_ITEM
+        }
+        TYPE_KW => {
+            type_item(p);
+            TYPE_ITEM
+        }
+        MOD_KW => {
+            mod_item(p);
+            MOD_ITEM
+        }
+        STRUCT_KW => {
+            structs::struct_item(p);
+            if p.at(SEMI) {
+                p.err_and_bump(
+                    "expected item, found `;`\n\
+                     consider removing this semicolon"
+                );
+            }
+            STRUCT_ITEM
+        }
+        ENUM_KW => {
+            structs::enum_item(p);
+            ENUM_ITEM
+        }
+        USE_KW => {
+            use_item::use_item(p);
+            USE_ITEM
+        }
+        CONST_KW if (la == IDENT || la == MUT_KW) => {
+            consts::const_item(p);
+            CONST_ITEM
+        }
+        STATIC_KW => {
+            consts::static_item(p);
+            STATIC_ITEM
+        }
+        // test extern_block
+        // extern {}
+        EXTERN_KW if la == L_CURLY || ((la == STRING || la == RAW_STRING) && p.nth(2) == L_CURLY) => {
+            abi(p);
+            extern_block(p);
+            EXTERN_BLOCK_EXPR
+        }
+        _ => return None,
+    };
+    Some(kind)
+}
+
+fn extern_crate_item(p: &mut Parser) {
+    assert!(p.at(EXTERN_KW));
+    p.bump();
+    assert!(p.at(CRATE_KW));
+    p.bump();
+    name(p);
+    alias(p);
+    p.expect(SEMI);
+}
+
+fn extern_block(p: &mut Parser) {
+    assert!(p.at(L_CURLY));
+    p.bump();
+    p.expect(R_CURLY);
+}
+
+fn function(p: &mut Parser) {
+    assert!(p.at(FN_KW));
+    p.bump();
+
+    name(p);
+    // test function_type_params
+    // fn foo<T: Clone + Copy>(){}
+    type_params::type_param_list(p);
+
+    if p.at(L_PAREN) {
+        params::param_list(p);
+    } else {
+        p.error("expected function arguments");
+    }
+    // test function_ret_type
+    // fn foo() {}
+    // fn bar() -> () {}
+    fn_ret_type(p);
+
+    // test function_where_clause
+    // fn foo<T>() where T: Copy {}
+    type_params::where_clause(p);
+
+    // test fn_decl
+    // trait T { fn foo(); }
+    if !p.eat(SEMI) {
+        expressions::block(p);
+    }
+}
+
+// test type_item
+// type Foo = Bar;
+fn type_item(p: &mut Parser) {
+    assert!(p.at(TYPE_KW));
+    p.bump();
+
+    name(p);
+
+    // test type_item_type_params
+    // type Result<T> = ();
+    type_params::type_param_list(p);
+
+    if p.at(COLON) {
+        type_params::bounds(p);
+    }
+
+    // test type_item_where_clause
+    // type Foo where Foo: Copy = ();
+    type_params::where_clause(p);
+
+    if p.eat(EQ) {
+        types::type_(p);
+    }
+    p.expect(SEMI);
+}
+
+fn mod_item(p: &mut Parser) {
+    assert!(p.at(MOD_KW));
+    p.bump();
+
+    name(p);
+    if !p.eat(SEMI) {
+        if p.expect(L_CURLY) {
+            mod_contents(p, true);
+            p.expect(R_CURLY);
+        }
+    }
+}
+
+fn macro_call(p: &mut Parser) -> BlockLike {
+    assert!(paths::is_path_start(p));
+    paths::use_path(p);
+    macro_call_after_excl(p)
+}
+
+pub(super) fn macro_call_after_excl(p: &mut Parser) -> BlockLike {
+    p.expect(EXCL);
+    p.eat(IDENT);
+    let flavor = match p.current() {
+        L_CURLY => {
+            token_tree(p);
+            BlockLike::Block
+        }
+        L_PAREN | L_BRACK => {
+            token_tree(p);
+            BlockLike::NotBlock
+        }
+        _ => {
+            p.error("expected `{`, `[`, `(`");
+            BlockLike::NotBlock
+        },
+    };
+
+    flavor
+}
+
+fn token_tree(p: &mut Parser) {
+    let closing_paren_kind = match p.current() {
+        L_CURLY => R_CURLY,
+        L_PAREN => R_PAREN,
+        L_BRACK => R_BRACK,
+        _ => unreachable!(),
+    };
+    p.bump();
+    while !p.at(EOF) && !p.at(closing_paren_kind) {
+        match p.current() {
+            L_CURLY | L_PAREN | L_BRACK => token_tree(p),
+            R_CURLY | R_PAREN | R_BRACK => p.err_and_bump("unmatched brace"),
+            _ => p.bump()
+        }
+    };
+    p.expect(closing_paren_kind);
+}
diff --git a/crates/libsyntax2/src/grammar/items/structs.rs b/crates/libsyntax2/src/grammar/items/structs.rs
new file mode 100644
index 000000000..67616eaad
--- /dev/null
+++ b/crates/libsyntax2/src/grammar/items/structs.rs
@@ -0,0 +1,116 @@
+use super::*;
+
+pub(super) fn struct_item(p: &mut Parser) {
+    assert!(p.at(STRUCT_KW));
+    p.bump();
+
+    name(p);
+    type_params::type_param_list(p);
+    match p.current() {
+        WHERE_KW => {
+            type_params::where_clause(p);
+            match p.current() {
+                SEMI => {
+                    p.bump();
+                    return;
+                }
+                L_CURLY => named_fields(p),
+                _ => {
+                    //TODO: special case `(` error message
+                    p.error("expected `;` or `{`");
+                    return;
+                }
+            }
+        }
+        SEMI => {
+            p.bump();
+            return;
+        }
+        L_CURLY => named_fields(p),
+        L_PAREN => {
+            pos_fields(p);
+            p.expect(SEMI);
+        }
+        _ => {
+            p.error("expected `;`, `{`, or `(`");
+            return;
+        }
+    }
+}
+
+pub(super) fn enum_item(p: &mut Parser) {
+    assert!(p.at(ENUM_KW));
+    p.bump();
+    name(p);
+    type_params::type_param_list(p);
+    type_params::where_clause(p);
+    if p.expect(L_CURLY) {
+        while !p.at(EOF) && !p.at(R_CURLY) {
+            let var = p.start();
+            attributes::outer_attributes(p);
+            if p.at(IDENT) {
+                name(p);
+                match p.current() {
+                    L_CURLY => named_fields(p),
+                    L_PAREN => pos_fields(p),
+                    EQ => {
+                        p.bump();
+                        expressions::expr(p);
+                    }
+                    _ => (),
+                }
+                var.complete(p, ENUM_VARIANT);
+            } else {
+                var.abandon(p);
+                p.err_and_bump("expected enum variant");
+            }
+            if !p.at(R_CURLY) {
+                p.expect(COMMA);
+            }
+        }
+        p.expect(R_CURLY);
+    }
+}
+
+fn named_fields(p: &mut Parser) {
+    assert!(p.at(L_CURLY));
+    p.bump();
+    while !p.at(R_CURLY) && !p.at(EOF) {
+        named_field(p);
+        if !p.at(R_CURLY) {
+            p.expect(COMMA);
+        }
+    }
+    p.expect(R_CURLY);
+
+    fn named_field(p: &mut Parser) {
+        let field = p.start();
+        visibility(p);
+        if p.at(IDENT) {
+            name(p);
+            p.expect(COLON);
+            types::type_(p);
+            field.complete(p, NAMED_FIELD);
+        } else {
+            field.abandon(p);
+            p.err_and_bump("expected field declaration");
+        }
+    }
+}
+
+fn pos_fields(p: &mut Parser) {
+    if !p.expect(L_PAREN) {
+        return;
+    }
+    while !p.at(R_PAREN) && !p.at(EOF) {
+        let pos_field = p.start();
+        visibility(p);
+        types::type_(p);
+        pos_field.complete(p, POS_FIELD);
+
+        if !p.at(R_PAREN) {
+            p.expect(COMMA);
+        }
+    }
+    p.expect(R_PAREN);
+}
diff --git a/crates/libsyntax2/src/grammar/items/traits.rs b/crates/libsyntax2/src/grammar/items/traits.rs
new file mode 100644
index 000000000..0b9fb2b0b
--- /dev/null
+++ b/crates/libsyntax2/src/grammar/items/traits.rs
@@ -0,0 +1,87 @@
+use super::*;
+
+// test trait_item
+// trait T<U>: Hash + Clone where U: Copy {}
+pub(super) fn trait_item(p: &mut Parser) {
+    assert!(p.at(TRAIT_KW));
+    p.bump();
+    name(p);
+    type_params::type_param_list(p);
+    if p.at(COLON) {
+        type_params::bounds(p);
+    }
+    type_params::where_clause(p);
+    p.expect(L_CURLY);
+    // test trait_item_items
+    // impl F {
+    //     type A: Clone;
+    //     const B: i32;
+    //     fn foo() {}
+    //     fn bar(&self);
+    // }
+    while !p.at(EOF) && !p.at(R_CURLY) {
+        item_or_macro(p, true);
+    }
+    p.expect(R_CURLY);
+}
+
+// test impl_item
+// impl Foo {}
+pub(super) fn impl_item(p: &mut Parser) {
+    assert!(p.at(IMPL_KW));
+    p.bump();
+    if choose_type_params_over_qpath(p) {
+        type_params::type_param_list(p);
+    }
+
+    // TODO: never type
+    // impl ! {}
+
+    // test impl_item_neg
+    // impl !Send for X {}
+    p.eat(EXCL);
+    types::type_(p);
+    if p.eat(FOR_KW) {
+        types::type_(p);
+    }
+    type_params::where_clause(p);
+    p.expect(L_CURLY);
+
+    // test impl_item_items
+    // impl F {
+    //     type A = i32;
+    //     const B: i32 = 92;
+    //     fn foo() {}
+    //     fn bar(&self) {}
+    // }
+    while !p.at(EOF) && !p.at(R_CURLY) {
+        item_or_macro(p, true);
+    }
+    p.expect(R_CURLY);
+}
+
+fn choose_type_params_over_qpath(p: &Parser) -> bool {
+    // There's an ambiguity between generic parameters and qualified paths in impls.
+    // If we see `<` it may start both, so we have to inspect some following tokens.
+    // The following combinations can only start generics,
+    // but not qualified paths (with one exception):
+    //     `<` `>` - empty generic parameters
+    //     `<` `#` - generic parameters with attributes
+    //     `<` (LIFETIME|IDENT) `>` - single generic parameter
+    //     `<` (LIFETIME|IDENT) `,` - first generic parameter in a list
+    //     `<` (LIFETIME|IDENT) `:` - generic parameter with bounds
+    //     `<` (LIFETIME|IDENT) `=` - generic parameter with a default
+    // The only truly ambiguous case is
+    //     `<` IDENT `>` `::` IDENT ...
+    // we disambiguate it in favor of generics (`impl<T> ::absolute::Path<T> { ... }`)
+    // because this is what almost always expected in practice, qualified paths in impls
+    // (`impl <Type>::AssocTy { ... }`) aren't even allowed by type checker at the moment.
+    if !p.at(L_ANGLE) {
+        return false;
+    }
+    if p.nth(1) == POUND || p.nth(1) == R_ANGLE {
+        return true;
+    }
+    (p.nth(1) == LIFETIME || p.nth(1) == IDENT)
+        && (p.nth(2) == R_ANGLE || p.nth(2) == COMMA || p.nth(2) == COLON || p.nth(2) == EQ)
+}
diff --git a/crates/libsyntax2/src/grammar/items/use_item.rs b/crates/libsyntax2/src/grammar/items/use_item.rs
new file mode 100644
index 000000000..a3f7f0da8
--- /dev/null
+++ b/crates/libsyntax2/src/grammar/items/use_item.rs
@@ -0,0 +1,66 @@
+use super::*;
+
+pub(super) fn use_item(p: &mut Parser) {
+    assert!(p.at(USE_KW));
+    p.bump();
+    use_tree(p);
+    p.expect(SEMI);
+}
+
+fn use_tree(p: &mut Parser) {
+    let la = p.nth(1);
+    let m = p.start();
+    match (p.current(), la) {
+        (STAR, _) => p.bump(),
+        (COLONCOLON, STAR) => {
+            p.bump();
+            p.bump();
+        }
+        (L_CURLY, _) | (COLONCOLON, L_CURLY) => {
+            if p.at(COLONCOLON) {
+                p.bump();
+            }
+            nested_trees(p);
+        }
+        _ if paths::is_path_start(p) => {
+            paths::use_path(p);
+            match p.current() {
+                AS_KW => {
+                    alias(p);
+                }
+                COLONCOLON => {
+                    p.bump();
+                    match p.current() {
+                        STAR => {
+                            p.bump();
+                        }
+                        L_CURLY => nested_trees(p),
+                        _ => {
+                            // is this unreachable?
+                            p.error("expected `{` or `*`");
+                        }
+                    }
+                }
+                _ => (),
+            }
+        }
+        _ => {
+            m.abandon(p);
+            p.err_and_bump("expected one of `*`, `::`, `{`, `self`, `super`, `indent`");
+            return;
+        }
+    }
+    m.complete(p, USE_TREE);
+}
+
+fn nested_trees(p: &mut Parser) {
+    assert!(p.at(L_CURLY));
+    p.bump();
+    while !p.at(EOF) && !p.at(R_CURLY) {
+        use_tree(p);
+        if !p.at(R_CURLY) {
+            p.expect(COMMA);
+        }
+    }
+    p.expect(R_CURLY);
+}
diff --git a/crates/libsyntax2/src/grammar/mod.rs b/crates/libsyntax2/src/grammar/mod.rs
new file mode 100644
index 000000000..e1329044d
--- /dev/null
+++ b/crates/libsyntax2/src/grammar/mod.rs
@@ -0,0 +1,161 @@
+//! This is the actual "grammar" of the Rust language.
+//!
+//! Each function in this module and its children corresponds
+//! to a production of the format grammar. Submodules roughly
+//! correspond to different *areas* of the grammar. By convention,
+//! each submodule starts with `use super::*` import and exports
+//! "public" productions via `pub(super)`.
+//!
+//! See docs for `Parser` to learn about API, available to the grammar,
+//! and see docs for `Event` to learn how this actually manages to
+//! produce parse trees.
+//!
+//! Code in this module also contains inline tests, which start with
+//! `// test name-of-the-test` comment and look like this:
+//!
+//! ```
+//! // test function_with_zero_parameters
+//! // fn foo() {}
+//! ```
+//!
+//! After adding a new inline-test, run `cargo collect-tests` to extract
+//! it as a standalone text-fixture into `tests/data/parser/inline`, and
+//! run `cargo test` once to create the "gold" value.
+mod attributes;
+mod expressions;
+mod items;
+mod params;
+mod paths;
+mod patterns;
+mod type_args;
+mod type_params;
+mod types;
+
+use {
+    parser_api::{CompletedMarker, Parser, TokenSet},
+    SyntaxKind::{self, *},
+};
+
+pub(crate) fn file(p: &mut Parser) {
+    let file = p.start();
+    p.eat(SHEBANG);
+    items::mod_contents(p, false);
+    file.complete(p, FILE);
+}
+
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum BlockLike {
+    Block,
+    NotBlock,
+}
+
+impl BlockLike {
+    fn is_block(self) -> bool { self == BlockLike::Block }
+}
+
+fn visibility(p: &mut Parser) {
+    match p.current() {
+        PUB_KW => {
+            let m = p.start();
+            p.bump();
+            if p.at(L_PAREN) {
+                match p.nth(1) {
+                    // test crate_visibility
+                    // pub(crate) struct S;
+                    // pub(self) struct S;
+                    // pub(self) struct S;
+                    // pub(self) struct S;
+                    CRATE_KW | SELF_KW | SUPER_KW => {
+                        p.bump();
+                        p.bump();
+                        p.expect(R_PAREN);
+                    }
+                    IN_KW => {
+                        p.bump();
+                        p.bump();
+                        paths::use_path(p);
+                        p.expect(R_PAREN);
+                    }
+                    _ => (),
+                }
+            }
+            m.complete(p, VISIBILITY);
+        }
+        // test crate_keyword_vis
+        // crate fn main() { }
+        CRATE_KW => {
+            let m = p.start();
+            p.bump();
+            m.complete(p, VISIBILITY);
+        }
+        _ => (),
+    }
+}
+fn alias(p: &mut Parser) -> bool {
+    if p.at(AS_KW) {
+        let alias = p.start();
+        p.bump();
+        name(p);
+        alias.complete(p, ALIAS);
+    }
+    true //FIXME: return false if three are errors
+}
+
+fn abi(p: &mut Parser) {
+    assert!(p.at(EXTERN_KW));
+    let abi = p.start();
+    p.bump();
+    match p.current() {
+        STRING | RAW_STRING => p.bump(),
+        _ => (),
+    }
+    abi.complete(p, ABI);
+}
+
+fn fn_ret_type(p: &mut Parser) -> bool {
+    if p.at(THIN_ARROW) {
+        p.bump();
+        types::type_(p);
+        true
+    } else {
+        false
+    }
+}
+
+fn name(p: &mut Parser) {
+    if p.at(IDENT) {
+        let m = p.start();
+        p.bump();
+        m.complete(p, NAME);
+    } else {
+        p.error("expected a name");
+    }
+}
+
+fn name_ref(p: &mut Parser) {
+    if p.at(IDENT) {
+        let m = p.start();
+        p.bump();
+        m.complete(p, NAME_REF);
+    } else {
+        p.error("expected identifier");
+    }
+}
+
+fn error_block(p: &mut Parser, message: &str) {
+    assert!(p.at(L_CURLY));
+    let err = p.start();
+    p.error(message);
+    p.bump();
+    let mut level: u32 = 1;
+    while level > 0 && !p.at(EOF) {
+        match p.current() {
+            L_CURLY => level += 1,
+            R_CURLY => level -= 1,
+            _ => (),
+        }
+        p.bump();
+    }
+    err.complete(p, ERROR);
+}
diff --git a/crates/libsyntax2/src/grammar/params.rs b/crates/libsyntax2/src/grammar/params.rs
new file mode 100644
index 000000000..32e905cb2
--- /dev/null
+++ b/crates/libsyntax2/src/grammar/params.rs
@@ -0,0 +1,116 @@
+use super::*;
+
+// test param_list
+// fn a() {}
+// fn b(x: i32) {}
+// fn c(x: i32, ) {}
+// fn d(x: i32, y: ()) {}
+pub(super) fn param_list(p: &mut Parser) {
+    list_(p, Flavor::Normal)
+}
+
+// test param_list_opt_patterns
+// fn foo<F: FnMut(&mut Foo<'a>)>(){}
+pub(super) fn param_list_opt_patterns(p: &mut Parser) {
+    list_(p, Flavor::OptionalPattern)
+}
+
+pub(super) fn param_list_opt_types(p: &mut Parser) {
+    list_(p, Flavor::OptionalType)
+}
+
+#[derive(Clone, Copy, Eq, PartialEq)]
+enum Flavor {
+    OptionalType,
+    OptionalPattern,
+    Normal,
+}
+
+impl Flavor {
+    fn type_required(self) -> bool {
+        match self {
+            Flavor::OptionalType => false,
+            _ => true,
+        }
+    }
+}
+
+fn list_(p: &mut Parser, flavor: Flavor) {
+    let (bra, ket) = if flavor.type_required() {
+        (L_PAREN, R_PAREN)
+    } else {
+        (PIPE, PIPE)
+    };
+    assert!(p.at(bra));
+    let m = p.start();
+    p.bump();
+    if flavor.type_required() {
+        self_param(p);
+    }
+    while !p.at(EOF) && !p.at(ket) {
+        value_parameter(p, flavor);
+        if !p.at(ket) {
+            p.expect(COMMA);
+        }
+    }
+    p.expect(ket);
+    m.complete(p, PARAM_LIST);
+}
+
+fn value_parameter(p: &mut Parser, flavor: Flavor) {
+    let m = p.start();
+    match flavor {
+        Flavor::OptionalType | Flavor::Normal => {
+            patterns::pattern(p);
+            if p.at(COLON) || flavor.type_required() {
+                types::ascription(p)
+            }
+        },
+        // test value_parameters_no_patterns
+        // type F = Box<Fn(a: i32, &b: &i32, &mut c: &i32, ())>;
+        Flavor::OptionalPattern => {
+            let la0 = p.current();
+            let la1 = p.nth(1);
+            let la2 = p.nth(2);
+            let la3 = p.nth(3);
+            if la0 == IDENT && la1 == COLON
+                || la0 == AMP && la1 == IDENT && la2 == COLON
+                || la0 == AMP && la1 == MUT_KW && la2 == IDENT && la3 == COLON {
+                patterns::pattern(p);
+                types::ascription(p);
+            } else {
+                types::type_(p);
+            }
+        },
+    }
+    m.complete(p, PARAM);
+}
+
+// test self_param
+// impl S {
+//     fn a(self) {}
+//     fn b(&self,) {}
+//     fn c(&'a self,) {}
+//     fn d(&'a mut self, x: i32) {}
+// }
+fn self_param(p: &mut Parser) {
+    let la1 = p.nth(1);
+    let la2 = p.nth(2);
+    let la3 = p.nth(3);
+    let n_toks = match (p.current(), la1, la2, la3) {
+        (SELF_KW, _, _, _) => 1,
+        (AMP, SELF_KW, _, _) => 2,
+        (AMP, MUT_KW, SELF_KW, _) => 3,
+        (AMP, LIFETIME, SELF_KW, _) => 3,
+        (AMP, LIFETIME, MUT_KW, SELF_KW) => 4,
+        _ => return,
+    };
+    let m = p.start();
+    for _ in 0..n_toks {
+        p.bump();
+    }
+    m.complete(p, SELF_PARAM);
+    if !p.at(R_PAREN) {
+        p.expect(COMMA);
+    }
+}
diff --git a/crates/libsyntax2/src/grammar/paths.rs b/crates/libsyntax2/src/grammar/paths.rs
new file mode 100644
index 000000000..c277e2a6b
--- /dev/null
+++ b/crates/libsyntax2/src/grammar/paths.rs
@@ -0,0 +1,86 @@
+use super::*;
+
+pub(super) fn is_path_start(p: &Parser) -> bool {
+    match p.current() {
+        IDENT | SELF_KW | SUPER_KW | COLONCOLON => true,
+        _ => false,
+    }
+}
+
+pub(super) fn use_path(p: &mut Parser) {
+    path(p, Mode::Use)
+}
+
+pub(super) fn type_path(p: &mut Parser) {
+    path(p, Mode::Type)
+}
+
+pub(super) fn expr_path(p: &mut Parser) {
+    path(p, Mode::Expr)
+}
+
+#[derive(Clone, Copy, Eq, PartialEq)]
+enum Mode {
+    Use,
+    Type,
+    Expr,
+}
+
+fn path(p: &mut Parser, mode: Mode) {
+    if !is_path_start(p) {
+        return;
+    }
+    let path = p.start();
+    path_segment(p, mode, true);
+    let mut qual = path.complete(p, PATH);
+    loop {
+        let use_tree = match p.nth(1) {
+            STAR | L_CURLY => true,
+            _ => false,
+        };
+        if p.at(COLONCOLON) && !use_tree {
+            let path = qual.precede(p);
+            p.bump();
+            path_segment(p, mode, false);
+            let path = path.complete(p, PATH);
+            qual = path;
+        } else {
+            break;
+        }
+    }
+}
+
+fn path_segment(p: &mut Parser, mode: Mode, first: bool) {
+    let segment = p.start();
+    if first {
+        p.eat(COLONCOLON);
+    }
+    match p.current() {
+        IDENT => {
+            name_ref(p);
+            path_generic_args(p, mode);
+        }
+        SELF_KW | SUPER_KW => p.bump(),
+        _ => {
+            p.error("expected identifier");
+        }
+    };
+    segment.complete(p, PATH_SEGMENT);
+}
+
+fn path_generic_args(p: &mut Parser, mode: Mode) {
+    match mode {
+        Mode::Use => return,
+        Mode::Type => {
+            // test path_fn_trait_args
+            // type F = Box<Fn(x: i32) -> ()>;
+            if p.at(L_PAREN) {
+                params::param_list_opt_patterns(p);
+                fn_ret_type(p);
+            } else {
+                type_args::type_arg_list(p, false)
+            }
+        },
+        Mode::Expr => type_args::type_arg_list(p, true),
+    }
+}
diff --git a/crates/libsyntax2/src/grammar/patterns.rs b/crates/libsyntax2/src/grammar/patterns.rs
new file mode 100644
index 000000000..436f3b26d
--- /dev/null
+++ b/crates/libsyntax2/src/grammar/patterns.rs
@@ -0,0 +1,204 @@
+use super::*;
+
+pub(super) fn pattern(p: &mut Parser) {
+    if let Some(lhs) = atom_pat(p) {
+        // test range_pat
+        // fn main() {
+        //     match 92 { 0 ... 100 => () }
+        // }
+        if p.at(DOTDOTDOT) {
+            let m = lhs.precede(p);
+            p.bump();
+            atom_pat(p);
+            m.complete(p, RANGE_PAT);
+        }
+    }
+}
+
+fn atom_pat(p: &mut Parser) -> Option<CompletedMarker> {
+    let la0 = p.nth(0);
+    let la1 = p.nth(1);
+    if la0 == REF_KW || la0 == MUT_KW
+        || (la0 == IDENT && !(la1 == COLONCOLON || la1 == L_PAREN || la1 == L_CURLY)) {
+        return Some(bind_pat(p, true));
+    }
+    if paths::is_path_start(p) {
+        return Some(path_pat(p));
+    }
+
+    // test literal_pattern
+    // fn main() {
+    //     match () {
+    //         92 => (),
+    //         'c' => (),
+    //         "hello" => (),
+    //     }
+    // }
+    match expressions::literal(p) {
+        Some(m) => return Some(m),
+        None => (),
+    }
+
+    let m = match la0 {
+        UNDERSCORE => placeholder_pat(p),
+        AMP => ref_pat(p),
+        L_PAREN => tuple_pat(p),
+        L_BRACK => slice_pat(p),
+        _ => {
+            p.err_and_bump("expected pattern");
+            return None;
+        }
+    };
+    Some(m)
+}
+
+// test path_part
+// fn foo() {
+//     let foo::Bar = ();
+//     let ::Bar = ();
+//     let Bar { .. } = ();
+//     let Bar(..) = ();
+// }
+fn path_pat(p: &mut Parser) -> CompletedMarker {
+    let m = p.start();
+    paths::expr_path(p);
+    let kind = match p.current() {
+        L_PAREN => {
+            tuple_pat_fields(p);
+            TUPLE_STRUCT_PAT
+        }
+        L_CURLY => {
+            struct_pat_fields(p);
+            STRUCT_PAT
+        }
+        _ => PATH_PAT
+    };
+    m.complete(p, kind)
+}
+
+// test tuple_pat_fields
+// fn foo() {
+//     let S() = ();
+//     let S(_) = ();
+//     let S(_,) = ();
+//     let S(_, .. , x) = ();
+// }
+fn tuple_pat_fields(p: &mut Parser) {
+    assert!(p.at(L_PAREN));
+    p.bump();
+    while !p.at(EOF) && !p.at(R_PAREN) {
+        match p.current() {
+            DOTDOT => p.bump(),
+            _ => pattern(p),
+        }
+        if !p.at(R_PAREN) {
+            p.expect(COMMA);
+        }
+    }
+    p.expect(R_PAREN);
+}
+
+// test struct_pat_fields
+// fn foo() {
+//     let S {} = ();
+//     let S { f, ref mut g } = ();
+//     let S { h: _, ..} = ();
+//     let S { h: _, } = ();
+// }
+fn struct_pat_fields(p: &mut Parser) {
+    assert!(p.at(L_CURLY));
+    p.bump();
+    while !p.at(EOF) && !p.at(R_CURLY) {
+        match p.current() {
+            DOTDOT => p.bump(),
+            IDENT if p.nth(1) == COLON => {
+                p.bump();
+                p.bump();
+                pattern(p);
+            }
+            _ => {
+                bind_pat(p, false);
+            }
+        }
+        if !p.at(R_CURLY) {
+            p.expect(COMMA);
+        }
+    }
+    p.expect(R_CURLY);
+}
+
+// test placeholder_pat
+// fn main() { let _ = (); }
+fn placeholder_pat(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(UNDERSCORE));
+    let m = p.start();
+    p.bump();
+    m.complete(p, PLACEHOLDER_PAT)
+}
+
+// test ref_pat
+// fn main() {
+//     let &a = ();
+//     let &mut b = ();
+// }
+fn ref_pat(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(AMP));
+    let m = p.start();
+    p.bump();
+    p.eat(MUT_KW);
+    pattern(p);
+    m.complete(p, REF_PAT)
+}
+
+// test tuple_pat
+// fn main() {
+//     let (a, b, ..) = ();
+// }
+fn tuple_pat(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(L_PAREN));
+    let m = p.start();
+    tuple_pat_fields(p);
+    m.complete(p, TUPLE_PAT)
+}
+
+// test slice_pat
+// fn main() {
+//     let [a, b, ..] = [];
+// }
+fn slice_pat(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(L_BRACK));
+    let m = p.start();
+    p.bump();
+    while !p.at(EOF) && !p.at(R_BRACK) {
+        match p.current() {
+            DOTDOT => p.bump(),
+            _ => pattern(p),
+        }
+        if !p.at(R_BRACK) {
+            p.expect(COMMA);
+        }
+    }
+    p.expect(R_BRACK);
+
+    m.complete(p, SLICE_PAT)
+}
+
+// test bind_pat
+// fn main() {
+//     let a = ();
+//     let mut b = ();
+//     let ref c = ();
+//     let ref mut d = ();
+//     let e @ _ = ();
+//     let ref mut f @ g @ _ = ();
+// }
+fn bind_pat(p: &mut Parser, with_at: bool) -> CompletedMarker {
+    let m = p.start();
+    p.eat(REF_KW);
+    p.eat(MUT_KW);
+    name(p);
+    if with_at && p.eat(AT) {
+        pattern(p);
+    }
+    m.complete(p, BIND_PAT)
+}
diff --git a/crates/libsyntax2/src/grammar/type_args.rs b/crates/libsyntax2/src/grammar/type_args.rs
new file mode 100644
index 000000000..5b960f10b
--- /dev/null
+++ b/crates/libsyntax2/src/grammar/type_args.rs
@@ -0,0 +1,48 @@
+use super::*;
+
+pub(super) fn type_arg_list(p: &mut Parser, colon_colon_required: bool) {
+    let m;
+    match (colon_colon_required, p.nth(0), p.nth(1)) {
+        (_, COLONCOLON, L_ANGLE) => {
+            m = p.start();
+            p.bump();
+            p.bump();
+        }
+        (false, L_ANGLE, _) => {
+            m = p.start();
+            p.bump();
+        }
+        _ => return,
+    };
+
+    while !p.at(EOF) && !p.at(R_ANGLE) {
+        type_arg(p);
+        if !p.at(R_ANGLE) && !p.expect(COMMA) {
+            break;
+        }
+    }
+    p.expect(R_ANGLE);
+    m.complete(p, TYPE_ARG_LIST);
+}
+
+// test type_arg
+// type A = B<'static, i32, Item=u64>
+fn type_arg(p: &mut Parser) {
+    let m = p.start();
+    match p.current() {
+        LIFETIME => {
+            p.bump();
+            m.complete(p, LIFETIME_ARG);
+        }
+        IDENT if p.nth(1) == EQ => {
+            name_ref(p);
+            p.bump();
+            types::type_(p);
+            m.complete(p, ASSOC_TYPE_ARG);
+        }
+        _ => {
+            types::type_(p);
+            m.complete(p, TYPE_ARG);
+        }
+    }
+}
diff --git a/crates/libsyntax2/src/grammar/type_params.rs b/crates/libsyntax2/src/grammar/type_params.rs
new file mode 100644
index 000000000..0a3e8fd07
--- /dev/null
+++ b/crates/libsyntax2/src/grammar/type_params.rs
@@ -0,0 +1,127 @@
+use super::*;
+
+pub(super) fn type_param_list(p: &mut Parser) {
+    if !p.at(L_ANGLE) {
+        return;
+    }
+    let m = p.start();
+    p.bump();
+
+    while !p.at(EOF) && !p.at(R_ANGLE) {
+        match p.current() {
+            LIFETIME => lifetime_param(p),
+            IDENT => type_param(p),
+            _ => p.err_and_bump("expected type parameter"),
+        }
+        if !p.at(R_ANGLE) && !p.expect(COMMA) {
+            break;
+        }
+    }
+    p.expect(R_ANGLE);
+    m.complete(p, TYPE_PARAM_LIST);
+
+    fn lifetime_param(p: &mut Parser) {
+        assert!(p.at(LIFETIME));
+        let m = p.start();
+        p.bump();
+        if p.at(COLON) {
+            lifetime_bounds(p);
+        }
+        m.complete(p, LIFETIME_PARAM);
+    }
+
+    fn type_param(p: &mut Parser) {
+        assert!(p.at(IDENT));
+        let m = p.start();
+        name(p);
+        if p.at(COLON) {
+            bounds(p);
+        }
+        // test type_param_default
+        // struct S<T = i32>;
+        if p.at(EQ) {
+            p.bump();
+            types::type_(p)
+        }
+        m.complete(p, TYPE_PARAM);
+    }
+}
+
+// test type_param_bounds
+// struct S<T: 'a + ?Sized + (Copy)>;
+pub(super) fn bounds(p: &mut Parser) {
+    assert!(p.at(COLON));
+    p.bump();
+    bounds_without_colon(p);
+}
+
+fn lifetime_bounds(p: &mut Parser) {
+    assert!(p.at(COLON));
+    p.bump();
+    while p.at(LIFETIME) {
+        p.bump();
+        if !p.eat(PLUS) {
+            break;
+        }
+    }
+}
+
+pub(super) fn bounds_without_colon(p: &mut Parser) {
+    loop {
+        let has_paren = p.eat(L_PAREN);
+        p.eat(QUESTION);
+        if p.at(FOR_KW) {
+            //TODO
+        }
+        if p.at(LIFETIME) {
+            p.bump();
+        } else if paths::is_path_start(p) {
+            paths::type_path(p);
+        } else {
+            break;
+        }
+        if has_paren {
+            p.expect(R_PAREN);
+        }
+        if !p.eat(PLUS) {
+            break;
+        }
+    }
+}
+
+// test where_clause
+// fn foo()
+// where
+//    'a: 'b + 'c,
+//    T: Clone + Copy + 'static,
+//    Iterator::Item: 'a,
+// {}
+pub(super) fn where_clause(p: &mut Parser) {
+    if !p.at(WHERE_KW) {
+        return;
+    }
+    let m = p.start();
+    p.bump();
+    loop {
+        if !(paths::is_path_start(p) || p.current() == LIFETIME) {
+            break
+        }
+        where_predicate(p);
+        if p.current() != L_CURLY && p.current() != SEMI {
+            p.expect(COMMA);
+        }
+    }
+    m.complete(p, WHERE_CLAUSE);
+}
+
+fn where_predicate(p: &mut Parser) {
+    let m = p.start();
+    if p.at(LIFETIME) {
+        p.eat(LIFETIME);
+        lifetime_bounds(p)
+    } else {
+        types::path_type(p);
+        bounds(p);
+    }
+    m.complete(p, WHERE_PRED);
+}
diff --git a/crates/libsyntax2/src/grammar/types.rs b/crates/libsyntax2/src/grammar/types.rs
new file mode 100644
index 000000000..0d8c6bfba
--- /dev/null
+++ b/crates/libsyntax2/src/grammar/types.rs
@@ -0,0 +1,212 @@
+use super::*;
+
+pub(super) fn type_(p: &mut Parser) {
+    match p.current() {
+        L_PAREN => paren_or_tuple_type(p),
+        EXCL => never_type(p),
+        STAR => pointer_type(p),
+        L_BRACK => array_or_slice_type(p),
+        AMP => reference_type(p),
+        UNDERSCORE => placeholder_type(p),
+        FN_KW | UNSAFE_KW | EXTERN_KW => fn_pointer_type(p),
+        FOR_KW => for_type(p),
+        IMPL_KW => impl_trait_type(p),
+        _ if paths::is_path_start(p) => path_type(p),
+        _ => {
+            p.error("expected type");
+        }
+    }
+}
+
+pub(super) fn ascription(p: &mut Parser) {
+    p.expect(COLON);
+    type_(p)
+}
+
+fn type_no_plus(p: &mut Parser) {
+    type_(p);
+}
+
+fn paren_or_tuple_type(p: &mut Parser) {
+    assert!(p.at(L_PAREN));
+    let m = p.start();
+    p.bump();
+    let mut n_types: u32 = 0;
+    let mut trailing_comma: bool = false;
+    while !p.at(EOF) && !p.at(R_PAREN) {
+        n_types += 1;
+        type_(p);
+        if p.eat(COMMA) {
+            trailing_comma = true;
+        } else {
+            trailing_comma = false;
+            break;
+        }
+    }
+    p.expect(R_PAREN);
+
+    let kind = if n_types == 1 && !trailing_comma {
+        // test paren_type
+        // type T = (i32);
+        PAREN_TYPE
+    } else {
+        // test unit_type
+        // type T = ();
+
+        // test singleton_tuple_type
+        // type T = (i32,);
+        TUPLE_TYPE
+    };
+    m.complete(p, kind);
+}
+
+// test never_type
+// type Never = !;
+fn never_type(p: &mut Parser) {
+    assert!(p.at(EXCL));
+    let m = p.start();
+    p.bump();
+    m.complete(p, NEVER_TYPE);
+}
+
+fn pointer_type(p: &mut Parser) {
+    assert!(p.at(STAR));
+    let m = p.start();
+    p.bump();
+
+    match p.current() {
+        // test pointer_type_mut
+        // type M = *mut ();
+        // type C = *mut ();
+        MUT_KW | CONST_KW => p.bump(),
+        _ => {
+            // test pointer_type_no_mutability
+            // type T = *();
+            p.error(
+                "expected mut or const in raw pointer type \
+                 (use `*mut T` or `*const T` as appropriate)",
+            );
+        }
+    };
+
+    type_no_plus(p);
+    m.complete(p, POINTER_TYPE);
+}
+
+fn array_or_slice_type(p: &mut Parser) {
+    assert!(p.at(L_BRACK));
+    let m = p.start();
+    p.bump();
+
+    type_(p);
+    let kind = match p.current() {
+        // test slice_type
+        // type T = [()];
+        R_BRACK => {
+            p.bump();
+            SLICE_TYPE
+        }
+
+        // test array_type
+        // type T = [(); 92];
+        SEMI => {
+            p.bump();
+            expressions::expr(p);
+            p.expect(R_BRACK);
+            ARRAY_TYPE
+        }
+        // test array_type_missing_semi
+        // type T = [() 92];
+        _ => {
+            p.error("expected `;` or `]`");
+            SLICE_TYPE
+        }
+    };
+    m.complete(p, kind);
+}
+
+// test reference_type;
+// type A = &();
+// type B = &'static ();
+// type C = &mut ();
+fn reference_type(p: &mut Parser) {
+    assert!(p.at(AMP));
+    let m = p.start();
+    p.bump();
+    p.eat(LIFETIME);
+    p.eat(MUT_KW);
+    type_no_plus(p);
+    m.complete(p, REFERENCE_TYPE);
+}
+
+// test placeholder_type
+// type Placeholder = _;
+fn placeholder_type(p: &mut Parser) {
+    assert!(p.at(UNDERSCORE));
+    let m = p.start();
+    p.bump();
+    m.complete(p, PLACEHOLDER_TYPE);
+}
+
+// test fn_pointer_type
+// type A = fn();
+// type B = unsafe fn();
+// type C = unsafe extern "C" fn();
+fn fn_pointer_type(p: &mut Parser) {
+    let m = p.start();
+    p.eat(UNSAFE_KW);
+    if p.at(EXTERN_KW) {
+        abi(p);
+    }
+    // test fn_pointer_type_missing_fn
+    // type F = unsafe ();
+    if !p.eat(FN_KW) {
+        m.abandon(p);
+        p.error("expected `fn`");
+        return;
+    }
+
+    params::param_list_opt_patterns(p);
+    // test fn_pointer_type_with_ret
+    // type F = fn() -> ();
+    fn_ret_type(p);
+    m.complete(p, FN_POINTER_TYPE);
+}
+
+// test for_type
+// type A = for<'a> fn() -> ();
+fn for_type(p: &mut Parser) {
+    assert!(p.at(FOR_KW));
+    let m = p.start();
+    p.bump();
+    type_params::type_param_list(p);
+    type_(p);
+    m.complete(p, FOR_TYPE);
+}
+
+// test impl_trait_type
+// type A = impl Iterator<Item=Foo<'a>> + 'a;
+fn impl_trait_type(p: &mut Parser) {
+    assert!(p.at(IMPL_KW));
+    let m = p.start();
+    p.bump();
+    type_params::bounds_without_colon(p);
+    m.complete(p, IMPL_TRAIT_TYPE);
+}
+
+// test path_type
+// type A = Foo;
+// type B = ::Foo;
+// type C = self::Foo;
+// type D = super::Foo;
+pub(super) fn path_type(p: &mut Parser) {
+    assert!(paths::is_path_start(p));
+    let m = p.start();
+    paths::type_path(p);
+    // test path_type_with_bounds
+    // fn foo() -> Box<T + 'f> {}
+    if p.eat(PLUS) {
+        type_params::bounds_without_colon(p);
+    }
+    m.complete(p, PATH_TYPE);
+}
diff --git a/crates/libsyntax2/src/lexer/classes.rs b/crates/libsyntax2/src/lexer/classes.rs
new file mode 100644
index 000000000..4235d2648
--- /dev/null
+++ b/crates/libsyntax2/src/lexer/classes.rs
@@ -0,0 +1,26 @@
+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/libsyntax2/src/lexer/comments.rs b/crates/libsyntax2/src/lexer/comments.rs
new file mode 100644
index 000000000..01acb6515
--- /dev/null
+++ b/crates/libsyntax2/src/lexer/comments.rs
@@ -0,0 +1,57 @@
+use lexer::ptr::Ptr;
+
+use SyntaxKind::{self, *};
+
+pub(crate) fn scan_shebang(ptr: &mut Ptr) -> bool {
+    if ptr.next_is('!') && ptr.nnext_is('/') {
+        ptr.bump();
+        ptr.bump();
+        bump_until_eol(ptr);
+        true
+    } else {
+        false
+    }
+}
+
+fn scan_block_comment(ptr: &mut Ptr) -> Option<SyntaxKind> {
+    if ptr.next_is('*') {
+        ptr.bump();
+        let mut depth: u32 = 1;
+        while depth > 0 {
+            if ptr.next_is('*') && ptr.nnext_is('/') {
+                depth -= 1;
+                ptr.bump();
+                ptr.bump();
+            } else if ptr.next_is('/') && ptr.nnext_is('*') {
+                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.next_is('/') {
+        bump_until_eol(ptr);
+        Some(COMMENT)
+    } else {
+        scan_block_comment(ptr)
+    }
+}
+
+fn bump_until_eol(ptr: &mut Ptr) {
+    loop {
+        if ptr.next_is('\n') || ptr.next_is('\r') && ptr.nnext_is('\n') {
+            return;
+        }
+        if ptr.bump().is_none() {
+            break;
+        }
+    }
+}
diff --git a/crates/libsyntax2/src/lexer/mod.rs b/crates/libsyntax2/src/lexer/mod.rs
new file mode 100644
index 000000000..f8fdc41ac
--- /dev/null
+++ b/crates/libsyntax2/src/lexer/mod.rs
@@ -0,0 +1,209 @@
+mod classes;
+mod comments;
+mod numbers;
+mod ptr;
+mod strings;
+
+use {
+    SyntaxKind::{self, *},
+    TextUnit,
+};
+
+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,
+    },
+};
+
+/// A token of Rust source.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Token {
+    /// The kind of token.
+    pub kind: SyntaxKind,
+    /// The length of the token.
+    pub len: TextUnit,
+}
+
+/// Break a string up into its component tokens
+pub fn tokenize(text: &str) -> Vec<Token> {
+    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;
+    }
+
+    match c {
+        '#' => if scan_shebang(ptr) {
+            return SHEBANG;
+        },
+        '/' => if let Some(kind) = scan_comment(ptr) {
+            return kind;
+        },
+        _ => (),
+    }
+
+    let ident_start = is_ident_start(c) && !is_string_literal_start(c, ptr.next(), ptr.nnext());
+    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 {
+        // Multi-byte tokens.
+        '.' => {
+            return match (ptr.next(), ptr.nnext()) {
+                (Some('.'), Some('.')) => {
+                    ptr.bump();
+                    ptr.bump();
+                    DOTDOTDOT
+                }
+                (Some('.'), Some('=')) => {
+                    ptr.bump();
+                    ptr.bump();
+                    DOTDOTEQ
+                }
+                (Some('.'), _) => {
+                    ptr.bump();
+                    DOTDOT
+                }
+                _ => DOT,
+            };
+        }
+        ':' => {
+            return match ptr.next() {
+                Some(':') => {
+                    ptr.bump();
+                    COLONCOLON
+                }
+                _ => COLON,
+            };
+        }
+        '=' => {
+            return match ptr.next() {
+                Some('=') => {
+                    ptr.bump();
+                    EQEQ
+                }
+                Some('>') => {
+                    ptr.bump();
+                    FAT_ARROW
+                }
+                _ => EQ,
+            };
+        }
+        '!' => {
+            return match ptr.next() {
+                Some('=') => {
+                    ptr.bump();
+                    NEQ
+                }
+                _ => EXCL,
+            };
+        }
+        '-' => {
+            return if ptr.next_is('>') {
+                ptr.bump();
+                THIN_ARROW
+            } else {
+                MINUS
+            };
+        }
+
+        // If the character is an ident start not followed by another single
+        // quote, then this is a lifetime name:
+        '\'' => {