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:
+        '\'' => {
+            return if ptr.next_is_p(is_ident_start) && !ptr.nnext_is('\'') {
+                ptr.bump();
+                while ptr.next_is_p(is_ident_continue) {
+                    ptr.bump();
+                }
+                // lifetimes shouldn't end with a single quote
+                // if we find one, then this is an invalid character literal
+                if ptr.next_is('\'') {
+                    ptr.bump();
+                    return CHAR; // TODO: error reporting
+                }
+                LIFETIME
+            } else {
+                scan_char(ptr);
+                scan_literal_suffix(ptr);
+                CHAR
+            };
+        }
+        'b' => {
+            let kind = scan_byte_char_or_string(ptr);
+            scan_literal_suffix(ptr);
+            return kind;
+        }
+        '"' => {
+            scan_string(ptr);
+            scan_literal_suffix(ptr);
+            return STRING;
+        }
+        'r' => {
+            scan_raw_string(ptr);
+            scan_literal_suffix(ptr);
+            return RAW_STRING;
+        }
+        _ => (),
+    }
+    ERROR
+}
+
+fn scan_ident(c: char, ptr: &mut Ptr) -> SyntaxKind {
+    let is_single_letter = match ptr.next() {
+        None => true,
+        Some(c) if !is_ident_continue(c) => true,
+        _ => false,
+    };
+    if is_single_letter {
+        return if c == '_' { UNDERSCORE } else { IDENT };
+    }
+    ptr.bump_while(is_ident_continue);
+    if let Some(kind) = SyntaxKind::from_keyword(ptr.current_token_text()) {
+        return kind;
+    }
+    IDENT
+}
+
+fn scan_literal_suffix(ptr: &mut Ptr) {
+    if ptr.next_is_p(is_ident_start) {
+        ptr.bump();
+    }
+    ptr.bump_while(is_ident_continue);
+}
diff --git a/crates/libsyntax2/src/lexer/numbers.rs b/crates/libsyntax2/src/lexer/numbers.rs
new file mode 100644
index 000000000..5c4641a2d
--- /dev/null
+++ b/crates/libsyntax2/src/lexer/numbers.rs
@@ -0,0 +1,67 @@
+use lexer::classes::*;
+use lexer::ptr::Ptr;
+
+use SyntaxKind::{self, *};
+
+pub(crate) fn scan_number(c: char, ptr: &mut Ptr) -> SyntaxKind {
+    if c == '0' {
+        match ptr.next().unwrap_or('\0') {
+            'b' | 'o' => {
+                ptr.bump();
+                scan_digits(ptr, false);
+            }
+            'x' => {
+                ptr.bump();
+                scan_digits(ptr, true);
+            }
+            '0'...'9' | '_' | '.' | 'e' | 'E' => {
+                scan_digits(ptr, true);
+            }
+            _ => return INT_NUMBER,
+        }
+    } else {
+        scan_digits(ptr, false);
+    }
+
+    // might be a float, but don't be greedy if this is actually an
+    // integer literal followed by field/method access or a range pattern
+    // (`0..2` and `12.foo()`)
+    if ptr.next_is('.') && !(ptr.nnext_is('.') || ptr.nnext_is_p(is_ident_start)) {
+        // might have stuff after the ., and if it does, it needs to start
+        // with a number
+        ptr.bump();
+        scan_digits(ptr, false);
+        scan_float_exponent(ptr);
+        return FLOAT_NUMBER;
+    }
+    // it might be a float if it has an exponent
+    if ptr.next_is('e') || ptr.next_is('E') {
+        scan_float_exponent(ptr);
+        return FLOAT_NUMBER;
+    }
+    INT_NUMBER
+}
+
+fn scan_digits(ptr: &mut Ptr, allow_hex: bool) {
+    while let Some(c) = ptr.next() {
+        match c {
+            '_' | '0'...'9' => {
+                ptr.bump();
+            }
+            'a'...'f' | 'A'...'F' if allow_hex => {
+                ptr.bump();
+            }
+            _ => return,
+        }
+    }
+}
+
+fn scan_float_exponent(ptr: &mut Ptr) {
+    if ptr.next_is('e') || ptr.next_is('E') {
+        ptr.bump();
+        if ptr.next_is('-') || ptr.next_is('+') {
+            ptr.bump();
+        }
+        scan_digits(ptr, false);
+    }
+}
diff --git a/crates/libsyntax2/src/lexer/ptr.rs b/crates/libsyntax2/src/lexer/ptr.rs
new file mode 100644
index 000000000..d1391fd5f
--- /dev/null
+++ b/crates/libsyntax2/src/lexer/ptr.rs
@@ -0,0 +1,74 @@
+use TextUnit;
+
+use std::str::Chars;
+
+pub(crate) struct Ptr<'s> {
+    text: &'s str,
+    len: TextUnit,
+}
+
+impl<'s> Ptr<'s> {
+    pub fn new(text: &'s str) -> Ptr<'s> {
+        Ptr {
+            text,
+            len: 0.into(),
+        }
+    }
+
+    pub fn into_len(self) -> TextUnit {
+        self.len
+    }
+
+    pub fn next(&self) -> Option<char> {
+        self.chars().next()
+    }
+
+    pub fn nnext(&self) -> Option<char> {
+        let mut chars = self.chars();
+        chars.next()?;
+        chars.next()
+    }
+
+    pub fn next_is(&self, c: char) -> bool {
+        self.next() == Some(c)
+    }
+
+    pub fn nnext_is(&self, c: char) -> bool {
+        self.nnext() == Some(c)
+    }
+
+    pub fn next_is_p<P: Fn(char) -> bool>(&self, p: P) -> bool {
+        self.next().map(p) == Some(true)
+    }
+
+    pub fn nnext_is_p<P: Fn(char) -> bool>(&self, p: P) -> bool {
+        self.nnext().map(p) == Some(true)
+    }
+
+    pub fn bump(&mut self) -> Option<char> {
+        let ch = self.chars().next()?;
+        self.len += TextUnit::of_char(ch);
+        Some(ch)
+    }
+
+    pub fn bump_while<F: Fn(char) -> bool>(&mut self, pred: F) {
+        loop {
+            match self.next() {
+                Some(c) if pred(c) => {
+                    self.bump();
+                }
+                _ => return,
+            }
+        }
+    }
+
+    pub fn current_token_text(&self) -> &str {
+        let len: u32 = self.len.into();
+        &self.text[..len as usize]
+    }
+
+    fn chars(&self) -> Chars {
+        let len: u32 = self.len.into();
+        self.text[len as usize..].chars()
+    }
+}
diff --git a/crates/libsyntax2/src/lexer/strings.rs b/crates/libsyntax2/src/lexer/strings.rs
new file mode 100644
index 000000000..e3704fbb3
--- /dev/null
+++ b/crates/libsyntax2/src/lexer/strings.rs
@@ -0,0 +1,106 @@
+use SyntaxKind::{self, *};
+
+use lexer::ptr::Ptr;
+
+pub(crate) fn is_string_literal_start(c: char, c1: Option<char>, c2: Option<char>) -> bool {
+    match (c, c1, c2) {
+        ('r', Some('"'), _)
+        | ('r', Some('#'), _)
+        | ('b', Some('"'), _)
+        | ('b', Some('\''), _)
+        | ('b', Some('r'), Some('"'))
+        | ('b', Some('r'), Some('#')) => true,
+        _ => false,
+    }
+}
+
+pub(crate) fn scan_char(ptr: &mut Ptr) {
+    if ptr.bump().is_none() {
+        return; // TODO: error reporting is upper in the stack
+    }
+    scan_char_or_byte(ptr);
+    if !ptr.next_is('\'') {
+        return; // TODO: error reporting
+    }
+    ptr.bump();
+}
+
+pub(crate) fn scan_byte_char_or_string(ptr: &mut Ptr) -> SyntaxKind {
+    // unwrapping and not-exhaustive match are ok
+    // because of string_literal_start
+    let c = ptr.bump().unwrap();
+    match c {
+        '\'' => {
+            scan_byte(ptr);
+            BYTE
+        }
+        '"' => {
+            scan_byte_string(ptr);
+            BYTE_STRING
+        }
+        'r' => {
+            scan_raw_byte_string(ptr);
+            RAW_BYTE_STRING
+        }
+        _ => unreachable!(),
+    }
+}
+
+pub(crate) fn scan_string(ptr: &mut Ptr) {
+    while let Some(c) = ptr.bump() {
+        if c == '"' {
+            return;
+        }
+    }
+}
+
+pub(crate) fn scan_raw_string(ptr: &mut Ptr) {
+    if !ptr.next_is('"') {
+        return;
+    }
+    ptr.bump();
+
+    while let Some(c) = ptr.bump() {
+        if c == '"' {
+            return;
+        }
+    }
+}
+
+fn scan_byte(ptr: &mut Ptr) {
+    if ptr.next_is('\'') {
+        ptr.bump();
+        return;
+    }
+    ptr.bump();
+    if ptr.next_is('\'') {
+        ptr.bump();
+        return;
+    }
+}
+
+fn scan_byte_string(ptr: &mut Ptr) {
+    while let Some(c) = ptr.bump() {
+        if c == '"' {
+            return;
+        }
+    }
+}
+
+fn scan_raw_byte_string(ptr: &mut Ptr) {
+    if !ptr.next_is('"') {
+        return;
+    }
+    ptr.bump();
+
+    while let Some(c) = ptr.bump() {
+        if c == '"' {
+            return;
+        }
+    }
+}
+
+fn scan_char_or_byte(ptr: &mut Ptr) {
+    //FIXME: deal with escape sequencies
+    ptr.bump();
+}
diff --git a/crates/libsyntax2/src/lib.rs b/crates/libsyntax2/src/lib.rs
new file mode 100644
index 000000000..ca33618a0
--- /dev/null
+++ b/crates/libsyntax2/src/lib.rs
@@ -0,0 +1,55 @@
+//! An experimental implementation of [Rust RFC#2256 libsyntax2.0][rfc#2256].
+//!
+//! The intent is to be an IDE-ready parser, i.e. one that offers
+//!
+//! - easy and fast incremental re-parsing,
+//! - graceful handling of errors, and
+//! - maintains all information in the source file.
+//!
+//! For more information, see [the RFC][rfc#2265], or [the working draft][RFC.md].
+//!
+//!   [rfc#2256]: <https://github.com/rust-lang/rfcs/pull/2256>
+//!   [RFC.md]: <https://github.com/matklad/libsyntax2/blob/master/docs/RFC.md>
+
+#![forbid(
+    missing_debug_implementations,
+    unconditional_recursion,
+    future_incompatible
+)]
+#![deny(bad_style, missing_docs)]
+#![allow(missing_docs)]
+//#![warn(unreachable_pub)] // rust-lang/rust#47816
+
+extern crate itertools;
+extern crate text_unit;
+extern crate unicode_xid;
+extern crate drop_bomb;
+extern crate parking_lot;
+
+pub mod algo;
+pub mod ast;
+mod lexer;
+#[macro_use]
+mod parser_api;
+mod grammar;
+mod parser_impl;
+
+mod syntax_kinds;
+mod smol_str;
+mod yellow;
+/// Utilities for simple uses of the parser.
+pub mod utils;
+
+pub use {
+    ast::{AstNode, File},
+    lexer::{tokenize, Token},
+    syntax_kinds::SyntaxKind,
+    text_unit::{TextRange, TextUnit},
+    yellow::{SyntaxNode, SyntaxNodeRef, SyntaxRoot, TreeRoot, SyntaxError},
+};
+
+
+pub fn parse(text: &str) -> SyntaxNode {
+    let tokens = tokenize(&text);
+    parser_impl::parse::<yellow::GreenBuilder>(text, &tokens)
+}
diff --git a/crates/libsyntax2/src/parser_api.rs b/crates/libsyntax2/src/parser_api.rs
new file mode 100644
index 000000000..c78c6e43a
--- /dev/null
+++ b/crates/libsyntax2/src/parser_api.rs
@@ -0,0 +1,195 @@
+use {
+    parser_impl::ParserImpl,
+    SyntaxKind::{self, ERROR},
+    drop_bomb::DropBomb,
+};
+
+#[derive(Clone, Copy)]
+pub(crate) struct TokenSet(pub(crate) u128);
+
+fn mask(kind: SyntaxKind) -> u128 {
+    1u128 << (kind as usize)
+}
+
+impl TokenSet {
+    pub fn contains(&self, kind: SyntaxKind) -> bool {
+        self.0 & mask(kind) != 0
+    }
+}
+
+#[macro_export]
+macro_rules! token_set {
+    ($($t:ident),*) => { TokenSet($(1u128 << ($t as usize))|*) };
+    ($($t:ident),* ,) => { token_set!($($t),*) };
+}
+
+#[macro_export]
+macro_rules! token_set_union {
+    ($($ts:expr),*) => { TokenSet($($ts.0)|*) };
+    ($($ts:expr),* ,) => { token_set_union!($($ts),*) };
+}
+
+#[test]
+fn token_set_works_for_tokens() {
+    use SyntaxKind::*;
+    let ts = token_set! { EOF, SHEBANG };
+    assert!(ts.contains(EOF));
+    assert!(ts.contains(SHEBANG));
+    assert!(!ts.contains(PLUS));
+}
+
+/// `Parser` struct provides the low-level API for
+/// navigating through the stream of tokens and
+/// constructing the parse tree. The actual parsing
+/// happens in the `grammar` module.
+///
+/// However, the result of this `Parser` is not a real
+/// tree, but rather a flat stream of events of the form
+/// "start expression, consume number literal,
+/// finish expression". See `Event` docs for more.
+pub(crate) struct Parser<'t>(pub(super) ParserImpl<'t>);
+
+impl<'t> Parser<'t> {
+    /// Returns the kind of the current token.
+    /// If parser has already reached the end of input,
+    /// the special `EOF` kind is returned.
+    pub(crate) fn current(&self) -> SyntaxKind {
+        self.nth(0)
+    }
+
+    /// Lookahead operation: returns the kind of the next nth
+    /// token.
+    pub(crate) fn nth(&self, n: u32) -> SyntaxKind {
+        self.0.nth(n)
+    }
+
+    /// Checks if the current token is `kind`.
+    pub(crate) fn at(&self, kind: SyntaxKind) -> bool {
+        self.current() == kind
+    }
+
+    pub(crate) fn at_compound2(&self, c1: SyntaxKind, c2: SyntaxKind) -> bool {
+        self.0.at_compound2(c1, c2)
+    }
+
+    pub(crate) fn at_compound3(&self, c1: SyntaxKind, c2: SyntaxKind, c3: SyntaxKind) -> bool {
+        self.0.at_compound3(c1, c2, c3)
+    }
+
+    /// Checks if the current token is contextual keyword with text `t`.
+    pub(crate) fn at_contextual_kw(&self, t: &str) -> bool {
+        self.0.at_kw(t)
+    }
+
+    /// Starts a new node in the syntax tree. All nodes and tokens
+    /// consumed between the `start` and the corresponding `Marker::complete`
+    /// belong to the same node.
+    pub(crate) fn start(&mut self) -> Marker {
+        Marker::new(self.0.start())
+    }
+
+    /// Advances the parser by one token.
+    pub(crate) fn bump(&mut self) {
+        self.0.bump();
+    }
+
+    /// Advances the parser by one token, remapping its kind.
+    /// This is useful to create contextual keywords from
+    /// identifiers. For example, the lexer creates an `union`
+    /// *identifier* token, but the parser remaps it to the
+    /// `union` keyword, and keyword is what ends up in the
+    /// final tree.
+    pub(crate) fn bump_remap(&mut self, kind: SyntaxKind) {
+        self.0.bump_remap(kind);
+    }
+
+    /// Advances the parser by `n` tokens, remapping its kind.
+    /// This is useful to create compound tokens from parts. For
+    /// example, an `<<` token is two consecutive remapped `<` tokens
+    pub(crate) fn bump_compound(&mut self, kind: SyntaxKind, n: u8) {
+        self.0.bump_compound(kind, n);
+    }
+
+    /// Emit error with the `message`
+    /// TODO: this should be much more fancy and support
+    /// structured errors with spans and notes, like rustc
+    /// does.
+    pub(crate) fn error<T: Into<String>>(&mut self, message: T) {
+        self.0.error(message.into())
+    }
+
+    /// Consume the next token if it is `kind`.
+    pub(crate) fn eat(&mut self, kind: SyntaxKind) -> bool {
+        if !self.at(kind) {
+            return false;
+        }
+        self.bump();
+        true
+    }
+
+    /// Consume the next token if it is `kind` or emit an error
+    /// otherwise.
+    pub(crate) fn expect(&mut self, kind: SyntaxKind) -> bool {
+        if self.eat(kind) {
+            return true;
+        }
+        self.error(format!("expected {:?}", kind));
+        false
+    }
+
+    /// Create an error node and consume the next token.
+    pub(crate) fn err_and_bump(&mut self, message: &str) {
+        let m = self.start();
+        self.error(message);
+        self.bump();
+        m.complete(self, ERROR);
+    }
+}
+
+/// See `Parser::start`.
+pub(crate) struct Marker {
+    pos: u32,
+    bomb: DropBomb,
+}
+
+impl Marker {
+    fn new(pos: u32) -> Marker {
+        Marker {
+            pos,
+            bomb: DropBomb::new("Marker must be either completed or abandoned"),
+        }
+    }
+
+    /// Finishes the syntax tree node and assigns `kind` to it.
+    pub(crate) fn complete(mut self, p: &mut Parser, kind: SyntaxKind) -> CompletedMarker {
+        self.bomb.defuse();
+        p.0.complete(self.pos, kind);
+        CompletedMarker(self.pos, kind)
+    }
+
+    /// Abandons the syntax tree node. All its children
+    /// are attached to its parent instead.
+    pub(crate) fn abandon(mut self, p: &mut Parser) {
+        self.bomb.defuse();
+        p.0.abandon(self.pos);
+    }
+}
+
+pub(crate) struct CompletedMarker(u32, SyntaxKind);
+
+impl CompletedMarker {
+    /// This one is tricky :-)
+    /// This method allows to create a new node which starts
+    /// *before* the current one. That is, parser could start
+    /// node `A`, then complete it, and then after parsing the
+    /// whole `A`, decide that it should have started some node
+    /// `B` before starting `A`. `precede` allows to do exactly
+    /// that. See also docs about `forward_parent` in `Event::Start`.
+    pub(crate) fn precede(self, p: &mut Parser) -> Marker {
+        Marker::new(p.0.precede(self.0))
+    }
+
+    pub(crate) fn kind(&self) -> SyntaxKind {
+        self.1
+    }
+}
diff --git a/crates/libsyntax2/src/parser_impl/event.rs b/crates/libsyntax2/src/parser_impl/event.rs
new file mode 100644
index 000000000..9fd56b996
--- /dev/null
+++ b/crates/libsyntax2/src/parser_impl/event.rs
@@ -0,0 +1,154 @@
+//! This module provides a way to construct a `File`.
+//! It is intended to be completely decoupled from the
+//! parser, so as to allow to evolve the tree representation
+//! and the parser algorithm independently.
+//!
+//! The `Sink` trait is the bridge between the parser and the
+//! tree builder: the parser produces a stream of events like
+//! `start node`, `finish node`, and `FileBuilder` converts
+//! this stream to a real tree.
+use std::mem;
+use {
+    lexer::Token,
+    parser_impl::Sink,
+    SyntaxKind::{self, TOMBSTONE},
+};
+
+
+/// `Parser` produces a flat list of `Event`s.
+/// They are converted to a tree-structure in
+/// a separate pass, via `TreeBuilder`.
+#[derive(Debug)]
+pub(crate) enum Event {
+    /// This event signifies the start of the node.
+    /// It should be either abandoned (in which case the
+    /// `kind` is `TOMBSTONE`, and the event is ignored),
+    /// or completed via a `Finish` event.
+    ///
+    /// All tokens between a `Start` and a `Finish` would
+    /// become the children of the respective node.
+    ///
+    /// For left-recursive syntactic constructs, the parser produces
+    /// a child node before it sees a parent. `forward_parent`
+    /// exists to allow to tweak parent-child relationships.
+    ///
+    /// Consider this path
+    ///
+    /// foo::bar
+    ///
+    /// The events for it would look like this:
+    ///
+    ///
+    /// START(PATH) IDENT('foo') FINISH START(PATH) COLONCOLON IDENT('bar') FINISH
+    ///       |                          /\
+    ///       |                          |
+    ///       +------forward-parent------+
+    ///
+    /// And the tree would look like this
+    ///
+    ///    +--PATH---------+
+    ///    |   |           |
+    ///    |   |           |
+    ///    |  '::'       'bar'
+    ///    |
+    ///   PATH
+    ///    |
+    ///   'foo'
+    ///
+    /// See also `CompletedMarker::precede`.
+    Start {
+        kind: SyntaxKind,
+        forward_parent: Option<u32>,
+    },
+
+    /// Complete the previous `Start` event
+    Finish,
+
+    /// Produce a single leaf-element.
+    /// `n_raw_tokens` is used to glue complex contextual tokens.
+    /// For example, lexer tokenizes `>>` as `>`, `>`, and
+    /// `n_raw_tokens = 2` is used to produced a single `>>`.
+    Token {
+        kind: SyntaxKind,
+        n_raw_tokens: u8,
+    },
+
+    Error {
+        msg: String,
+    },
+}
+
+
+pub(super) fn process<'a, S: Sink<'a>>(builder: &mut S, tokens: &[Token], mut events: Vec<Event>) {
+    fn tombstone() -> Event {
+        Event::Start { kind: TOMBSTONE, forward_parent: None }
+    }
+    let eat_ws = |idx: &mut usize, builder: &mut S| {
+        while let Some(token) = tokens.get(*idx) {
+            if !token.kind.is_trivia() {
+                break;
+            }
+            builder.leaf(token.kind, token.len);
+            *idx += 1
+        }
+    };
+
+    let events: &mut [Event] = &mut events;
+    let mut depth = 0;
+    let mut forward_parents = Vec::new();
+    let mut next_tok_idx = 0;
+    for i in 0..events.len() {
+        match mem::replace(&mut events[i], tombstone()) {
+            Event::Start {
+                kind: TOMBSTONE, ..
+            } => (),
+
+            Event::Start { kind, forward_parent } => {
+                forward_parents.push(kind);
+                let mut idx = i;
+                let mut fp = forward_parent;
+                while let Some(fwd) = fp {
+                    idx += fwd as usize;
+                    fp = match mem::replace(&mut events[idx], tombstone()) {
+                        Event::Start {
+                            kind,
+                            forward_parent,
+                        } => {
+                            forward_parents.push(kind);
+                            forward_parent
+                        },
+                        _ => unreachable!(),
+                    };
+                }
+                for kind in forward_parents.drain(..).rev() {
+                    if depth > 0 {
+                        eat_ws(&mut next_tok_idx, builder);
+                    }
+                    depth += 1;
+                    builder.start_internal(kind);
+                }
+            }
+            Event::Finish => {
+                depth -= 1;
+                if depth == 0 {
+                    eat_ws(&mut next_tok_idx, builder);
+                }
+
+                builder.finish_internal();
+            }
+            Event::Token {
+                kind,
+                mut n_raw_tokens,
+            } => {
+                eat_ws(&mut next_tok_idx, builder);
+                let mut len = 0.into();
+                for _ in 0..n_raw_tokens {
+                    len += tokens[next_tok_idx].len;
+                    next_tok_idx += 1;
+                }
+                builder.leaf(kind, len);
+            }
+            Event::Error { msg } => builder.error(msg),
+        }
+    }
+}
diff --git a/crates/libsyntax2/src/parser_impl/input.rs b/crates/libsyntax2/src/parser_impl/input.rs
new file mode 100644
index 000000000..c0fe4d488
--- /dev/null
+++ b/crates/libsyntax2/src/parser_impl/input.rs
@@ -0,0 +1,86 @@
+use {lexer::Token, SyntaxKind, SyntaxKind::EOF, TextRange, TextUnit};
+
+use std::ops::{Add, AddAssign};
+
+pub(crate) struct ParserInput<'t> {
+    text: &'t str,
+    start_offsets: Vec<TextUnit>,
+    tokens: Vec<Token>, // non-whitespace tokens
+}
+
+impl<'t> ParserInput<'t> {
+    pub fn new(text: &'t str, raw_tokens: &'t [Token]) -> ParserInput<'t> {
+        let mut tokens = Vec::new();
+        let mut start_offsets = Vec::new();
+        let mut len = 0.into();
+        for &token in raw_tokens.iter() {
+            if !token.kind.is_trivia() {
+                tokens.push(token);
+                start_offsets.push(len);
+            }
+            len += token.len;
+        }
+
+        ParserInput {
+            text,
+            start_offsets,
+            tokens,
+        }
+    }
+
+    pub fn kind(&self, pos: InputPosition) -> SyntaxKind {
+        let idx = pos.0 as usize;
+        if !(idx < self.tokens.len()) {
+            return EOF;
+        }
+        self.tokens[idx].kind
+    }
+
+    pub fn len(&self, pos: InputPosition) -> TextUnit {
+        let idx = pos.0 as usize;
+        if !(idx < self.tokens.len()) {
+            return 0.into();
+        }
+        self.tokens[idx].len
+    }
+
+    pub fn start(&self, pos: InputPosition) -> TextUnit {
+        let idx = pos.0 as usize;
+        if !(idx < self.tokens.len()) {
+            return 0.into();
+        }
+        self.start_offsets[idx]
+    }
+
+    pub fn text(&self, pos: InputPosition) -> &'t str {
+        let idx = pos.0 as usize;
+        if !(idx < self.tokens.len()) {
+            return "";
+        }
+        let range = TextRange::offset_len(self.start_offsets[idx], self.tokens[idx].len);
+        &self.text[range]
+    }
+}
+
+#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
+pub(crate) struct InputPosition(u32);
+
+impl InputPosition {
+    pub fn new() -> Self {
+        InputPosition(0)
+    }
+}
+
+impl Add<u32> for InputPosition {
+    type Output = InputPosition;
+
+    fn add(self, rhs: u32) -> InputPosition {
+        InputPosition(self.0 + rhs)
+    }
+}
+
+impl AddAssign<u32> for InputPosition {
+    fn add_assign(&mut self, rhs: u32) {
+        self.0 += rhs
+    }
+}
diff --git a/crates/libsyntax2/src/parser_impl/mod.rs b/crates/libsyntax2/src/parser_impl/mod.rs
new file mode 100644
index 000000000..06c16cdb4
--- /dev/null
+++ b/crates/libsyntax2/src/parser_impl/mod.rs
@@ -0,0 +1,170 @@
+mod event;
+mod input;
+
+use {
+    grammar,
+    lexer::Token,
+    parser_api::Parser,
+    parser_impl::{
+        event::{process, Event},
+        input::{InputPosition, ParserInput},
+    },
+    TextUnit,
+};
+
+use SyntaxKind::{self, EOF, TOMBSTONE};
+
+pub(crate) trait Sink<'a> {
+    type Tree;
+
+    fn new(text: &'a str) -> Self;
+
+    fn leaf(&mut self, kind: SyntaxKind, len: TextUnit);
+    fn start_internal(&mut self, kind: SyntaxKind);
+    fn finish_internal(&mut self);
+    fn error(&mut self, err: String);
+    fn finish(self) -> Self::Tree;
+}
+
+/// Parse a sequence of tokens into the representative node tree
+pub(crate) fn parse<'a, S: Sink<'a>>(text: &'a str, tokens: &[Token]) -> S::Tree {
+    let events = {
+        let input = input::ParserInput::new(text, tokens);
+        let parser_impl = ParserImpl::new(&input);
+        let mut parser_api = Parser(parser_impl);
+        grammar::file(&mut parser_api);
+        parser_api.0.into_events()
+    };
+    let mut sink = S::new(text);
+    process(&mut sink, tokens, events);
+    sink.finish()
+}
+
+/// Implementation details of `Parser`, extracted
+/// to a separate struct in order not to pollute
+/// the public API of the `Parser`.
+pub(crate) struct ParserImpl<'t> {
+    inp: &'t ParserInput<'t>,
+
+    pos: InputPosition,
+    events: Vec<Event>,
+}
+
+impl<'t> ParserImpl<'t> {
+    pub(crate) fn new(inp: &'t ParserInput<'t>) -> ParserImpl<'t> {
+        ParserImpl {
+            inp,
+
+            pos: InputPosition::new(),
+            events: Vec::new(),
+        }
+    }
+
+    pub(crate) fn into_events(self) -> Vec<Event> {
+        assert_eq!(self.nth(0), EOF);
+        self.events
+    }
+
+    pub(super) fn at_compound2(&self, c1: SyntaxKind, c2: SyntaxKind) -> bool {
+        self.inp.kind(self.pos) == c1 && self.inp.kind(self.pos + 1) == c2
+            && self.inp.start(self.pos + 1) == self.inp.start(self.pos) + self.inp.len(self.pos)
+    }
+
+    pub(super) fn at_compound3(&self, c1: SyntaxKind, c2: SyntaxKind, c3: SyntaxKind) -> bool {
+        self.inp.kind(self.pos) == c1 && self.inp.kind(self.pos + 1) == c2 && self.inp.kind(self.pos + 2) == c3
+            && self.inp.start(self.pos + 1) == self.inp.start(self.pos) + self.inp.len(self.pos)
+            && self.inp.start(self.pos + 2) == self.inp.start(self.pos + 1) + self.inp.len(self.pos + 1)
+    }
+
+    pub(super) fn nth(&self, n: u32) -> SyntaxKind {
+        self.inp.kind(self.pos + n)
+    }
+
+    pub(super) fn at_kw(&self, t: &str) -> bool {
+        self.inp.text(self.pos) == t
+    }
+
+    pub(super) fn start(&mut self) -> u32 {
+        let pos = self.events.len() as u32;
+        self.event(Event::Start {
+            kind: TOMBSTONE,
+            forward_parent: None,
+        });
+        pos
+    }
+
+    pub(super) fn bump(&mut self) {
+        let kind = self.nth(0);
+        if kind == EOF {
+            return;
+        }
+        self.do_bump(kind, 1);
+    }
+
+    pub(super) fn bump_remap(&mut self, kind: SyntaxKind) {
+        if self.nth(0) == EOF {
+            // TODO: panic!?
+            return;
+        }
+        self.do_bump(kind, 1);
+    }
+
+    pub(super) fn bump_compound(&mut self, kind: SyntaxKind, n: u8) {
+        self.do_bump(kind, n);
+    }
+
+    fn do_bump(&mut self, kind: SyntaxKind, n_raw_tokens: u8) {
+        self.pos += u32::from(n_raw_tokens);
+        self.event(Event::Token {
+            kind,
+            n_raw_tokens,
+        });
+    }
+
+    pub(super) fn error(&mut self, msg: String) {
+        self.event(Event::Error { msg })
+    }
+
+    pub(super) fn complete(&mut self, pos: u32, kind: SyntaxKind) {
+        match self.events[pos as usize] {
+            Event::Start {
+                kind: ref mut slot, ..
+            } => {
+                *slot = kind;
+            }
+            _ => unreachable!(),
+        }
+        self.event(Event::Finish);
+    }
+
+    pub(super) fn abandon(&mut self, pos: u32) {
+        let idx = pos as usize;
+        if idx == self.events.len() - 1 {
+            match self.events.pop() {
+                Some(Event::Start {
+                    kind: TOMBSTONE,
+                    forward_parent: None,
+                }) => (),
+                _ => unreachable!(),
+            }
+        }
+    }
+
+    pub(super) fn precede(&mut self, pos: u32) -> u32 {
+        let new_pos = self.start();
+        match self.events[pos as usize] {
+            Event::Start {
+                ref mut forward_parent,
+                ..
+            } => {
+                *forward_parent = Some(new_pos - pos);
+            }
+            _ => unreachable!(),
+        }
+        new_pos
+    }
+
+    fn event(&mut self, event: Event) {
+        self.events.push(event)
+    }
+}
diff --git a/crates/libsyntax2/src/smol_str.rs b/crates/libsyntax2/src/smol_str.rs
new file mode 100644
index 000000000..abf69dce7
--- /dev/null
+++ b/crates/libsyntax2/src/smol_str.rs
@@ -0,0 +1,83 @@
+use std::{sync::Arc};
+
+const INLINE_CAP: usize = 22;
+const WS_TAG: u8 = (INLINE_CAP + 1) as u8;
+
+#[derive(Clone, Debug)]
+pub(crate) enum SmolStr {
+    Heap(Arc<str>),
+    Inline {
+        len: u8,
+        buf: [u8; INLINE_CAP],
+    },
+}
+
+impl SmolStr {
+    pub fn new(text: &str) -> SmolStr {
+        let len = text.len();
+        if len <= INLINE_CAP {
+            let mut buf = [0; INLINE_CAP];
+            buf[..len].copy_from_slice(text.as_bytes());
+            return SmolStr::Inline { len: len as u8, buf };
+        }
+
+        let newlines = text.bytes().take_while(|&b| b == b'\n').count();
+        let spaces = text[newlines..].bytes().take_while(|&b| b == b' ').count();
+        if newlines + spaces == len && newlines <= N_NEWLINES && spaces <= N_SPACES {
+            let mut buf = [0; INLINE_CAP];
+            buf[0] = newlines as u8;
+            buf[1] = spaces as u8;
+            return SmolStr::Inline { len: WS_TAG, buf };
+        }
+
+        SmolStr::Heap(
+            text.to_string().into_boxed_str().into()
+        )
+    }
+
+    pub fn as_str(&self) -> &str {
+        match self {
+            SmolStr::Heap(data) => &*data,
+            SmolStr::Inline { len, buf } => {
+                if *len == WS_TAG {
+                    let newlines = buf[0] as usize;
+                    let spaces = buf[1] as usize;
+                    assert!(newlines <= N_NEWLINES && spaces <= N_SPACES);
+                    return &WS[N_NEWLINES - newlines..N_NEWLINES + spaces]
+                }
+
+                let len = *len as usize;
+                let buf = &buf[..len];
+                unsafe { ::std::str::from_utf8_unchecked(buf) }
+            }
+        }
+    }
+}
+
+const N_NEWLINES: usize = 32;
+const N_SPACES: usize = 128;
+const WS: &str =
+    "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n                                                                                                                                ";
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn smol_str_is_smol() {
+        assert_eq!(::std::mem::size_of::<SmolStr>(), 8 + 8 + 8)
+    }
+
+    #[test]
+    fn test_round_trip() {
+        let mut text = String::new();
+        for n in 0..256 {
+            let smol = SmolStr::new(&text);
+            assert_eq!(smol.as_str(), text.as_str());
+            text.push_str(&n.to_string());
+        }
+    }
+}
+
diff --git a/crates/libsyntax2/src/syntax_kinds/generated.rs b/crates/libsyntax2/src/syntax_kinds/generated.rs
new file mode 100644
index 000000000..de2807ba6
--- /dev/null
+++ b/crates/libsyntax2/src/syntax_kinds/generated.rs
@@ -0,0 +1,508 @@
+#![allow(bad_style, missing_docs, unreachable_pub)]
+#![cfg_attr(rustfmt, rustfmt_skip)]
+use super::SyntaxInfo;
+
+/// The kind of syntax node, e.g. `IDENT`, `USE_KW`, or `STRUCT_DEF`.
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum SyntaxKind {
+    // Technical SyntaxKinds: they appear temporally during parsing,
+    // but never end up in the final tree
+    #[doc(hidden)]
+    TOMBSTONE,
+    #[doc(hidden)]
+    EOF,
+    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,
+    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,
+    USE_KW,
+    FN_KW,
+    STRUCT_KW,
+    ENUM_KW,
+    TRAIT_KW,
+    IMPL_KW,
+    TRUE_KW,
+    FALSE_KW,
+    AS_KW,
+    EXTERN_KW,
+    CRATE_KW,
+    MOD_KW,
+    PUB_KW,
+    SELF_KW,
+    SUPER_KW,
+    IN_KW,
+    WHERE_KW,
+    FOR_KW,
+    LOOP_KW,
+    WHILE_KW,
+    IF_KW,
+    ELSE_KW,
+    MATCH_KW,
+    CONST_KW,
+    STATIC_KW,
+    MUT_KW,
+    UNSAFE_KW,
+    TYPE_KW,
+    REF_KW,
+    LET_KW,
+    MOVE_KW,
+    RETURN_KW,
+    AUTO_KW,
+    DEFAULT_KW,
+    UNION_KW,
+    ERROR,
+    IDENT,
+    UNDERSCORE,
+    WHITESPACE,
+    INT_NUMBER,
+    FLOAT_NUMBER,
+    LIFETIME,
+    CHAR,
+    BYTE,
+    STRING,
+    RAW_STRING,
+    BYTE_STRING,
+    RAW_BYTE_STRING,
+    COMMENT,
+    DOC_COMMENT,
+    SHEBANG,
+    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,
+    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,
+    CALL_EXPR,
+    INDEX_EXPR,
+    METHOD_CALL_EXPR,
+    FIELD_EXPR,
+    TRY_EXPR,
+    CAST_EXPR,
+    REF_EXPR,
+    PREFIX_EXPR,
+    RANGE_EXPR,
+    BIN_EXPR,
+    EXTERN_BLOCK_EXPR,
+    ENUM_VARIANT,
+    NAMED_FIELD,
+    POS_FIELD,
+    ATTR,
+    META_ITEM,
+    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,
+}
+use self::SyntaxKind::*;
+
+impl SyntaxKind {
+    pub fn is_keyword(self) -> bool {
+        match self {
+            | USE_KW
+            | FN_KW
+            | STRUCT_KW
+            | ENUM_KW
+            | TRAIT_KW
+            | IMPL_KW
+            | TRUE_KW
+            | FALSE_KW
+            | AS_KW
+            | EXTERN_KW
+            | CRATE_KW
+            | MOD_KW
+            | PUB_KW
+            | SELF_KW
+            | SUPER_KW
+            | IN_KW
+            | WHERE_KW
+            | FOR_KW
+            | LOOP_KW
+            | WHILE_KW
+            | IF_KW
+            | ELSE_KW
+            | MATCH_KW
+            | CONST_KW
+            | STATIC_KW
+            | MUT_KW
+            | UNSAFE_KW
+            | TYPE_KW
+            | REF_KW
+            | LET_KW
+            | MOVE_KW
+            | RETURN_KW
+            | AUTO_KW
+            | DEFAULT_KW
+            | UNION_KW
+                => true,
+            _ => false
+        }
+    }
+
+    pub(crate) fn info(self) -> &'static SyntaxInfo {
+        match self {
+            SEMI => &SyntaxInfo { name: "SEMI" },
+            COMMA => &SyntaxInfo { name: "COMMA" },
+            L_PAREN => &SyntaxInfo { name: "L_PAREN" },
+            R_PAREN => &SyntaxInfo { name: "R_PAREN" },
+            L_CURLY => &SyntaxInfo { name: "L_CURLY" },
+            R_CURLY => &SyntaxInfo { name: "R_CURLY" },
+            L_BRACK => &SyntaxInfo { name: "L_BRACK" },
+            R_BRACK => &SyntaxInfo { name: "R_BRACK" },
+            L_ANGLE => &SyntaxInfo { name: "L_ANGLE" },
+            R_ANGLE => &SyntaxInfo { name: "R_ANGLE" },
+            AT => &SyntaxInfo { name: "AT" },
+            POUND => &SyntaxInfo { name: "POUND" },
+            TILDE => &SyntaxInfo { name: "TILDE" },
+            QUESTION => &SyntaxInfo { name: "QUESTION" },
+            DOLLAR => &SyntaxInfo { name: "DOLLAR" },
+            AMP => &SyntaxInfo { name: "AMP" },
+            PIPE => &SyntaxInfo { name: "PIPE" },
+            PLUS => &SyntaxInfo { name: "PLUS" },
+            STAR => &SyntaxInfo { name: "STAR" },
+            SLASH => &SyntaxInfo { name: "SLASH" },
+            CARET => &SyntaxInfo { name: "CARET" },
+            PERCENT => &SyntaxInfo { name: "PERCENT" },
+            DOT => &SyntaxInfo { name: "DOT" },
+            DOTDOT => &SyntaxInfo { name: "DOTDOT" },
+            DOTDOTDOT => &SyntaxInfo { name: "DOTDOTDOT" },
+            DOTDOTEQ => &SyntaxInfo { name: "DOTDOTEQ" },
+            COLON => &SyntaxInfo { name: "COLON" },
+            COLONCOLON => &SyntaxInfo { name: "COLONCOLON" },
+            EQ => &SyntaxInfo { name: "EQ" },
+            EQEQ => &SyntaxInfo { name: "EQEQ" },
+            FAT_ARROW => &SyntaxInfo { name: "FAT_ARROW" },
+            EXCL => &SyntaxInfo { name: "EXCL" },
+            NEQ => &SyntaxInfo { name: "NEQ" },
+            MINUS => &SyntaxInfo { name: "MINUS" },
+            THIN_ARROW => &SyntaxInfo { name: "THIN_ARROW" },
+            LTEQ => &SyntaxInfo { name: "LTEQ" },
+            GTEQ => &SyntaxInfo { name: "GTEQ" },
+            PLUSEQ => &SyntaxInfo { name: "PLUSEQ" },
+            MINUSEQ => &SyntaxInfo { name: "MINUSEQ" },
+            AMPAMP => &SyntaxInfo { name: "AMPAMP" },
+            PIPEPIPE => &SyntaxInfo { name: "PIPEPIPE" },
+            SHL => &SyntaxInfo { name: "SHL" },
+            SHR => &SyntaxInfo { name: "SHR" },
+            SHLEQ => &SyntaxInfo { name: "SHLEQ" },
+            SHREQ => &SyntaxInfo { name: "SHREQ" },
+            USE_KW => &SyntaxInfo { name: "USE_KW" },
+            FN_KW => &SyntaxInfo { name: "FN_KW" },
+            STRUCT_KW => &SyntaxInfo { name: "STRUCT_KW" },
+            ENUM_KW => &SyntaxInfo { name: "ENUM_KW" },
+            TRAIT_KW => &SyntaxInfo { name: "TRAIT_KW" },
+            IMPL_KW => &SyntaxInfo { name: "IMPL_KW" },
+            TRUE_KW => &SyntaxInfo { name: "TRUE_KW" },
+            FALSE_KW => &SyntaxInfo { name: "FALSE_KW" },
+            AS_KW => &SyntaxInfo { name: "AS_KW" },
+            EXTERN_KW => &SyntaxInfo { name: "EXTERN_KW" },
+            CRATE_KW => &SyntaxInfo { name: "CRATE_KW" },
+            MOD_KW => &SyntaxInfo { name: "MOD_KW" },
+            PUB_KW => &SyntaxInfo { name: "PUB_KW" },
+            SELF_KW => &SyntaxInfo { name: "SELF_KW" },
+            SUPER_KW => &SyntaxInfo { name: "SUPER_KW" },
+            IN_KW => &SyntaxInfo { name: "IN_KW" },
+            WHERE_KW => &SyntaxInfo { name: "WHERE_KW" },
+            FOR_KW => &SyntaxInfo { name: "FOR_KW" },
+            LOOP_KW => &SyntaxInfo { name: "LOOP_KW" },
+            WHILE_KW => &SyntaxInfo { name: "WHILE_KW" },
+            IF_KW => &SyntaxInfo { name: "IF_KW" },
+            ELSE_KW => &SyntaxInfo { name: "ELSE_KW" },
+            MATCH_KW => &SyntaxInfo { name: "MATCH_KW" },
+            CONST_KW => &SyntaxInfo { name: "CONST_KW" },
+            STATIC_KW => &SyntaxInfo { name: "STATIC_KW" },
+            MUT_KW => &SyntaxInfo { name: "MUT_KW" },
+            UNSAFE_KW => &SyntaxInfo { name: "UNSAFE_KW" },
+            TYPE_KW => &SyntaxInfo { name: "TYPE_KW" },
+            REF_KW => &SyntaxInfo { name: "REF_KW" },
+            LET_KW => &SyntaxInfo { name: "LET_KW" },
+            MOVE_KW => &SyntaxInfo { name: "MOVE_KW" },
+            RETURN_KW => &SyntaxInfo { name: "RETURN_KW" },
+            AUTO_KW => &SyntaxInfo { name: "AUTO_KW" },
+            DEFAULT_KW => &SyntaxInfo { name: "DEFAULT_KW" },
+            UNION_KW => &SyntaxInfo { name: "UNION_KW" },
+            ERROR => &SyntaxInfo { name: "ERROR" },
+            IDENT => &SyntaxInfo { name: "IDENT" },
+            UNDERSCORE => &SyntaxInfo { name: "UNDERSCORE" },
+            WHITESPACE => &SyntaxInfo { name: "WHITESPACE" },
+            INT_NUMBER => &SyntaxInfo { name: "INT_NUMBER" },
+            FLOAT_NUMBER => &SyntaxInfo { name: "FLOAT_NUMBER" },
+            LIFETIME => &SyntaxInfo { name: "LIFETIME" },
+            CHAR => &SyntaxInfo { name: "CHAR" },
+            BYTE => &SyntaxInfo { name: "BYTE" },
+            STRING => &SyntaxInfo { name: "STRING" },
+            RAW_STRING => &SyntaxInfo { name: "RAW_STRING" },
+            BYTE_STRING => &SyntaxInfo { name: "BYTE_STRING" },
+            RAW_BYTE_STRING => &SyntaxInfo { name: "RAW_BYTE_STRING" },
+            COMMENT => &SyntaxInfo { name: "COMMENT" },
+            DOC_COMMENT => &SyntaxInfo { name: "DOC_COMMENT" },
+            SHEBANG => &SyntaxInfo { name: "SHEBANG" },
+            FILE => &SyntaxInfo { name: "FILE" },
+            STRUCT_ITEM => &SyntaxInfo { name: "STRUCT_ITEM" },
+            ENUM_ITEM => &SyntaxInfo { name: "ENUM_ITEM" },
+            FUNCTION => &SyntaxInfo { name: "FUNCTION" },
+            EXTERN_CRATE_ITEM => &SyntaxInfo { name: "EXTERN_CRATE_ITEM" },
+            MOD_ITEM => &SyntaxInfo { name: "MOD_ITEM" },
+            USE_ITEM => &SyntaxInfo { name: "USE_ITEM" },
+            STATIC_ITEM => &SyntaxInfo { name: "STATIC_ITEM" },
+            CONST_ITEM => &SyntaxInfo { name: "CONST_ITEM" },
+            TRAIT_ITEM => &SyntaxInfo { name: "TRAIT_ITEM" },
+            IMPL_ITEM => &SyntaxInfo { name: "IMPL_ITEM" },
+            TYPE_ITEM => &SyntaxInfo { name: "TYPE_ITEM" },
+            MACRO_CALL => &SyntaxInfo { name: "MACRO_CALL" },
+            TOKEN_TREE => &SyntaxInfo { name: "TOKEN_TREE" },
+            PAREN_TYPE => &SyntaxInfo { name: "PAREN_TYPE" },
+            TUPLE_TYPE => &SyntaxInfo { name: "TUPLE_TYPE" },
+            NEVER_TYPE => &SyntaxInfo { name: "NEVER_TYPE" },
+            PATH_TYPE => &SyntaxInfo { name: "PATH_TYPE" },
+            POINTER_TYPE => &SyntaxInfo { name: "POINTER_TYPE" },
+            ARRAY_TYPE => &SyntaxInfo { name: "ARRAY_TYPE" },
+            SLICE_TYPE => &SyntaxInfo { name: "SLICE_TYPE" },
+            REFERENCE_TYPE => &SyntaxInfo { name: "REFERENCE_TYPE" },
+            PLACEHOLDER_TYPE => &SyntaxInfo { name: "PLACEHOLDER_TYPE" },
+            FN_POINTER_TYPE => &SyntaxInfo { name: "FN_POINTER_TYPE" },
+            FOR_TYPE => &SyntaxInfo { name: "FOR_TYPE" },
+            IMPL_TRAIT_TYPE => &SyntaxInfo { name: "IMPL_TRAIT_TYPE" },
+            REF_PAT => &SyntaxInfo { name: "REF_PAT" },
+            BIND_PAT => &SyntaxInfo { name: "BIND_PAT" },
+            PLACEHOLDER_PAT => &SyntaxInfo { name: "PLACEHOLDER_PAT" },
+            PATH_PAT => &SyntaxInfo { name: "PATH_PAT" },
+            STRUCT_PAT => &SyntaxInfo { name: "STRUCT_PAT" },
+            TUPLE_STRUCT_PAT => &SyntaxInfo { name: "TUPLE_STRUCT_PAT" },
+            TUPLE_PAT => &SyntaxInfo { name: "TUPLE_PAT" },
+            SLICE_PAT => &SyntaxInfo { name: "SLICE_PAT" },
+            RANGE_PAT => &SyntaxInfo { name: "RANGE_PAT" },
+            TUPLE_EXPR => &SyntaxInfo { name: "TUPLE_EXPR" },
+            ARRAY_EXPR => &SyntaxInfo { name: "ARRAY_EXPR" },
+            PAREN_EXPR => &SyntaxInfo { name: "PAREN_EXPR" },
+            PATH_EXPR => &SyntaxInfo { name: "PATH_EXPR" },
+            LAMBDA_EXPR => &SyntaxInfo { name: "LAMBDA_EXPR" },
+            IF_EXPR => &SyntaxInfo { name: "IF_EXPR" },
+            WHILE_EXPR => &SyntaxInfo { name: "WHILE_EXPR" },
+            LOOP_EXPR => &SyntaxInfo { name: "LOOP_EXPR" },
+            FOR_EXPR => &SyntaxInfo { name: "FOR_EXPR" },
+            BLOCK_EXPR => &SyntaxInfo { name: "BLOCK_EXPR" },
+            RETURN_EXPR => &SyntaxInfo { name: "RETURN_EXPR" },
+            MATCH_EXPR => &SyntaxInfo { name: "MATCH_EXPR" },
+            MATCH_ARM => &SyntaxInfo { name: "MATCH_ARM" },
+            MATCH_GUARD => &SyntaxInfo { name: "MATCH_GUARD" },
+            STRUCT_LIT => &SyntaxInfo { name: "STRUCT_LIT" },
+            STRUCT_LIT_FIELD => &SyntaxInfo { name: "STRUCT_LIT_FIELD" },
+            CALL_EXPR => &SyntaxInfo { name: "CALL_EXPR" },
+            INDEX_EXPR => &SyntaxInfo { name: "INDEX_EXPR" },
+            METHOD_CALL_EXPR => &SyntaxInfo { name: "METHOD_CALL_EXPR" },
+            FIELD_EXPR => &SyntaxInfo { name: "FIELD_EXPR" },
+            TRY_EXPR => &SyntaxInfo { name: "TRY_EXPR" },
+            CAST_EXPR => &SyntaxInfo { name: "CAST_EXPR" },
+            REF_EXPR => &SyntaxInfo { name: "REF_EXPR" },
+            PREFIX_EXPR => &SyntaxInfo { name: "PREFIX_EXPR" },
+            RANGE_EXPR => &SyntaxInfo { name: "RANGE_EXPR" },
+            BIN_EXPR => &SyntaxInfo { name: "BIN_EXPR" },
+            EXTERN_BLOCK_EXPR => &SyntaxInfo { name: "EXTERN_BLOCK_EXPR" },
+            ENUM_VARIANT => &SyntaxInfo { name: "ENUM_VARIANT" },
+            NAMED_FIELD => &SyntaxInfo { name: "NAMED_FIELD" },
+            POS_FIELD => &SyntaxInfo { name: "POS_FIELD" },
+            ATTR => &SyntaxInfo { name: "ATTR" },
+            META_ITEM => &SyntaxInfo { name: "META_ITEM" },
+            USE_TREE => &SyntaxInfo { name: "USE_TREE" },
+            PATH => &SyntaxInfo { name: "PATH" },
+            PATH_SEGMENT => &SyntaxInfo { name: "PATH_SEGMENT" },
+            LITERAL => &SyntaxInfo { name: "LITERAL" },
+            ALIAS => &SyntaxInfo { name: "ALIAS" },
+            VISIBILITY => &SyntaxInfo { name: "VISIBILITY" },
+            WHERE_CLAUSE => &SyntaxInfo { name: "WHERE_CLAUSE" },
+            WHERE_PRED => &SyntaxInfo { name: "WHERE_PRED" },
+            ABI => &SyntaxInfo { name: "ABI" },
+            NAME => &SyntaxInfo { name: "NAME" },
+            NAME_REF => &SyntaxInfo { name: "NAME_REF" },
+            LET_STMT => &SyntaxInfo { name: "LET_STMT" },
+            EXPR_STMT => &SyntaxInfo { name: "EXPR_STMT" },
+            TYPE_PARAM_LIST => &SyntaxInfo { name: "TYPE_PARAM_LIST" },
+            LIFETIME_PARAM => &SyntaxInfo { name: "LIFETIME_PARAM" },
+            TYPE_PARAM => &SyntaxInfo { name: "TYPE_PARAM" },
+            TYPE_ARG_LIST => &SyntaxInfo { name: "TYPE_ARG_LIST" },
+            LIFETIME_ARG => &SyntaxInfo { name: "LIFETIME_ARG" },
+            TYPE_ARG => &SyntaxInfo { name: "TYPE_ARG" },
+            ASSOC_TYPE_ARG => &SyntaxInfo { name: "ASSOC_TYPE_ARG" },
+            PARAM_LIST => &SyntaxInfo { name: "PARAM_LIST" },
+            PARAM => &SyntaxInfo { name: "PARAM" },
+            SELF_PARAM => &SyntaxInfo { name: "SELF_PARAM" },
+            ARG_LIST => &SyntaxInfo { name: "ARG_LIST" },
+            TOMBSTONE => &SyntaxInfo { name: "TOMBSTONE" },
+            EOF => &SyntaxInfo { name: "EOF" },
+        }
+    }
+    pub(crate) fn from_keyword(ident: &str) -> Option<SyntaxKind> {
+        let kw = match ident {
+            "use" => USE_KW,
+            "fn" => FN_KW,
+            "struct" => STRUCT_KW,
+            "enum" => ENUM_KW,
+            "trait" => TRAIT_KW,
+            "impl" => IMPL_KW,
+            "true" => TRUE_KW,
+            "false" => FALSE_KW,
+            "as" => AS_KW,
+            "extern" => EXTERN_KW,
+            "crate" => CRATE_KW,
+            "mod" => MOD_KW,
+            "pub" => PUB_KW,
+            "self" => SELF_KW,
+            "super" => SUPER_KW,
+            "in" => IN_KW,
+            "where" => WHERE_KW,
+            "for" => FOR_KW,
+            "loop" => LOOP_KW,
+            "while" => WHILE_KW,
+            "if" => IF_KW,
+            "else" => ELSE_KW,
+            "match" => MATCH_KW,
+            "const" => CONST_KW,
+            "static" => STATIC_KW,
+            "mut" => MUT_KW,
+            "unsafe" => UNSAFE_KW,
+            "type" => TYPE_KW,
+            "ref" => REF_KW,
+            "let" => LET_KW,
+            "move" => MOVE_KW,
+            "return" => RETURN_KW,
+            _ => return None,
+        };
+        Some(kw)
+    }
+
+    pub(crate) fn from_char(c: char) -> Option<SyntaxKind> {
+        let tok = match c {
+            ';' => 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,
+            _ => return None,
+        };
+        Some(tok)
+    }
+}
+
diff --git a/crates/libsyntax2/src/syntax_kinds/generated.rs.tera b/crates/libsyntax2/src/syntax_kinds/generated.rs.tera
new file mode 100644
index 000000000..90618721a
--- /dev/null
+++ b/crates/libsyntax2/src/syntax_kinds/generated.rs.tera
@@ -0,0 +1,73 @@
+#![allow(bad_style, missing_docs, unreachable_pub)]
+#![cfg_attr(rustfmt, rustfmt_skip)]
+use super::SyntaxInfo;
+
+/// The kind of syntax node, e.g. `IDENT`, `USE_KW`, or `STRUCT_DEF`.
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum SyntaxKind {
+    // Technical SyntaxKinds: they appear temporally during parsing,
+    // but never end up in the final tree
+    #[doc(hidden)]
+    TOMBSTONE,
+    #[doc(hidden)]
+    EOF,
+
+{%- for t in concat(a=single_byte_tokens, b=multi_byte_tokens) %}
+    {{t.1}},
+{%- endfor -%}
+{% for kw in concat(a=keywords, b=contextual_keywords) %}
+    {{kw | upper}}_KW,
+{%- endfor -%}
+{% for t in concat(a=tokens, b=nodes) %}
+    {{t}},
+{%- endfor %}
+}
+use self::SyntaxKind::*;
+
+impl SyntaxKind {
+    pub fn is_keyword(self) -> bool {
+        match self {
+{%- for kw in concat(a=keywords, b=contextual_keywords) %}
+            | {{kw | upper}}_KW
+{%- endfor %}
+                => true,
+            _ => false
+        }
+    }
+
+    pub(crate) fn info(self) -> &'static SyntaxInfo {
+        match self {
+{%- for t in concat(a=single_byte_tokens, b=multi_byte_tokens) %}
+            {{t.1}} => &SyntaxInfo { name: "{{t.1}}" },
+{%- endfor -%}
+{% for kw in concat(a=keywords, b=contextual_keywords) %}
+            {{kw | upper}}_KW => &SyntaxInfo { name: "{{kw | upper}}_KW" },
+{%- endfor -%}
+{% for t in concat(a=tokens, b=nodes) %}
+            {{t}} => &SyntaxInfo { name: "{{t}}" },
+{%- endfor %}
+            TOMBSTONE => &SyntaxInfo { name: "TOMBSTONE" },
+            EOF => &SyntaxInfo { name: "EOF" },
+        }
+    }
+    pub(crate) fn from_keyword(ident: &str) -> Option<SyntaxKind> {
+        let kw = match ident {
+{%- for kw in keywords %}
+            "{{kw}}" => {{kw | upper}}_KW,
+{%- endfor %}
+            _ => return None,
+        };
+        Some(kw)
+    }
+
+    pub(crate) fn from_char(c: char) -> Option<SyntaxKind> {
+        let tok = match c {
+{%- for t in single_byte_tokens %}
+            '{{t.0}}' => {{t.1}},
+{%- endfor %}
+            _ => return None,
+        };
+        Some(tok)
+    }
+}
+
diff --git a/crates/libsyntax2/src/syntax_kinds/mod.rs b/crates/libsyntax2/src/syntax_kinds/mod.rs
new file mode 100644
index 000000000..ed4fa5d4d
--- /dev/null
+++ b/crates/libsyntax2/src/syntax_kinds/mod.rs
@@ -0,0 +1,26 @@
+mod generated;
+
+use std::fmt;
+use SyntaxKind::*;
+
+pub use self::generated::SyntaxKind;
+
+impl fmt::Debug for SyntaxKind {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = self.info().name;
+        f.write_str(name)
+    }
+}
+
+pub(crate) struct SyntaxInfo {
+    pub name: &'static str,
+}
+
+impl SyntaxKind {
+    pub(crate) fn is_trivia(self) -> bool {
+        match self {
+            WHITESPACE | COMMENT | DOC_COMMENT => true,
+            _ => false,
+        }
+    }
+}
diff --git a/crates/libsyntax2/src/utils.rs b/crates/libsyntax2/src/utils.rs
new file mode 100644
index 000000000..1fbb872a5
--- /dev/null
+++ b/crates/libsyntax2/src/utils.rs
@@ -0,0 +1,48 @@
+use std::fmt::Write;
+use {
+    algo::walk::{walk, WalkEvent},
+    SyntaxNode,
+};
+
+/// Parse a file and create a string representation of the resulting parse tree.
+pub fn dump_tree(syntax: &SyntaxNode) -> String {
+    let syntax = syntax.as_ref();
+    let mut errors: Vec<_> = syntax.root.errors.iter().cloned().collect();
+    errors.sort_by_key(|e| e.offset);
+    let mut err_pos = 0;
+    let mut level = 0;
+    let mut buf = String::new();
+    macro_rules! indent {
+        () => {
+            for _ in 0..level {
+                buf.push_str("  ");
+            }
+        };
+    }
+
+    for event in walk(syntax) {
+        match event {
+            WalkEvent::Enter(node) => {
+                indent!();
+                writeln!(buf, "{:?}", node).unwrap();
+                if node.first_child().is_none() {
+                    let off = node.range().end();
+                    while err_pos < errors.len() && errors[err_pos].offset <= off {
+                        indent!();
+                        writeln!(buf, "err: `{}`", errors[err_pos].msg).unwrap();
+                        err_pos += 1;
+                    }
+                }
+                level += 1;
+            }
+            WalkEvent::Exit(_) => level -= 1,
+        }
+    }
+
+    assert_eq!(level, 0);
+    for err in errors[err_pos..].iter() {
+        writeln!(buf, "err: `{}`", err.msg).unwrap();
+    }
+
+    return buf;
+}
diff --git a/crates/libsyntax2/src/yellow/builder.rs b/crates/libsyntax2/src/yellow/builder.rs
new file mode 100644
index 000000000..5e94e5055
--- /dev/null
+++ b/crates/libsyntax2/src/yellow/builder.rs
@@ -0,0 +1,65 @@
+use {
+    parser_impl::Sink,
+    yellow::{GreenNode, SyntaxError, SyntaxNode, SyntaxRoot},
+    SyntaxKind, TextRange, TextUnit,
+};
+
+pub(crate) struct GreenBuilder<'a> {
+    text: &'a str,
+    parents: Vec<(SyntaxKind, usize)>,
+    children: Vec<GreenNode>,
+    pos: TextUnit,
+    errors: Vec<SyntaxError>,
+}
+
+impl<'a> Sink<'a> for GreenBuilder<'a> {
+    type Tree = SyntaxNode;
+
+    fn new(text: &'a str) -> Self {
+        GreenBuilder {
+            text,
+            parents: Vec::new(),
+            children: Vec::new(),
+            pos: 0.into(),
+            errors: Vec::new(),
+        }
+    }
+
+    fn leaf(&mut self, kind: SyntaxKind, len: TextUnit) {
+        let range = TextRange::offset_len(self.pos, len);
+        self.pos += len;
+        let text = &self.text[range];
+        self.children.push(
+            GreenNode::new_leaf(kind, text)
+        );
+    }
+
+    fn start_internal(&mut self, kind: SyntaxKind) {
+        let len = self.children.len();
+        self.parents.push((kind, len));
+    }
+
+    fn finish_internal(&mut self) {
+        let (kind, first_child) = self.parents.pop().unwrap();
+        let children: Vec<_> = self.children
+            .drain(first_child..)
+            .collect();
+        self.children.push(
+            GreenNode::new_branch(kind, children.into_boxed_slice())
+        );
+    }
+
+    fn error(&mut self, message: String) {
+        self.errors.push(SyntaxError {
+            msg: message,
+            offset: self.pos,
+        })
+    }
+
+    fn finish(mut self) -> SyntaxNode {
+        assert_eq!(self.children.len(), 1);
+        let root = self.children.pop().unwrap();
+        let root = SyntaxRoot::new(root, self.errors);
+        SyntaxNode::new_owned(root)
+    }
+}
diff --git a/crates/libsyntax2/src/yellow/green.rs b/crates/libsyntax2/src/yellow/green.rs
new file mode 100644
index 000000000..f505b26d7
--- /dev/null
+++ b/crates/libsyntax2/src/yellow/green.rs
@@ -0,0 +1,95 @@
+use std::sync::Arc;
+use {
+    SyntaxKind, TextUnit,
+    smol_str::SmolStr,
+};
+
+#[derive(Clone, Debug)]
+pub(crate) enum GreenNode {
+    Leaf {
+        kind: SyntaxKind,
+        text: SmolStr,
+    },
+    Branch(Arc<GreenBranch>),
+}
+
+impl GreenNode {
+    pub(crate) fn new_leaf(kind: SyntaxKind, text: &str) -> GreenNode {
+        GreenNode::Leaf { kind, text: SmolStr::new(text) }
+    }
+
+    pub(crate) fn new_branch(kind: SyntaxKind, children: Box<[GreenNode]>) -> GreenNode {
+        GreenNode::Branch(Arc::new(GreenBranch::new(kind, children)))
+    }
+
+    pub fn kind(&self) -> SyntaxKind {
+        match self {
+            GreenNode::Leaf { kind, .. } => *kind,
+            GreenNode::Branch(b) => b.kind(),
+        }
+    }
+
+    pub fn text_len(&self) -> TextUnit {
+        match self {
+            GreenNode::Leaf { text, ..} => TextUnit::of_str(text.as_str()),
+            GreenNode::Branch(b) => b.text_len(),
+        }
+    }
+
+    pub fn children(&self) -> &[GreenNode] {
+        match self {
+            GreenNode::Leaf { .. } => &[],
+            GreenNode::Branch(b) => b.children(),
+        }
+    }
+
+    pub fn text(&self) -> String {
+        let mut buff = String::new();
+        go(self, &mut buff);
+        return buff;
+        fn go(node: &GreenNode, buff: &mut String) {
+            match node {
+                GreenNode::Leaf { text, .. } => buff.push_str(text.as_str()),
+                GreenNode::Branch(b) => b.children().iter().for_each(|child| go(child, buff)),
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct GreenBranch {
+    text_len: TextUnit,
+    kind: SyntaxKind,
+    children: Box<[GreenNode]>,
+}
+
+impl GreenBranch {
+    fn new(kind: SyntaxKind, children: Box<[GreenNode]>) -> GreenBranch {
+        let text_len = children.iter().map(|x| x.text_len()).sum::<TextUnit>();
+        GreenBranch {
+            text_len,
+            kind,
+            children,
+        }
+    }
+
+    pub fn kind(&self) -> SyntaxKind {
+        self.kind
+    }
+
+    pub fn text_len(&self) -> TextUnit {
+        self.text_len
+    }
+
+    pub fn children(&self) -> &[GreenNode] {
+        &*self.children
+    }
+}
+
+#[test]
+fn test_sizes() {
+    use std::mem::size_of;
+    println!("GreenBranch = {}", size_of::<GreenBranch>());
+    println!("GreenNode   = {}", size_of::<GreenNode>());
+    println!("SmolStr     = {}", size_of::<SmolStr>());
+}
diff --git a/crates/libsyntax2/src/yellow/mod.rs b/crates/libsyntax2/src/yellow/mod.rs
new file mode 100644
index 000000000..ff3bb221b
--- /dev/null
+++ b/crates/libsyntax2/src/yellow/mod.rs
@@ -0,0 +1,62 @@
+mod builder;
+mod green;
+mod red;
+mod syntax;
+
+use std::{
+    ops::Deref,
+    sync::Arc,
+    ptr,
+};
+pub use self::syntax::{SyntaxNode, SyntaxNodeRef, SyntaxError};
+pub(crate) use self::{
+    builder::GreenBuilder,
+    green::GreenNode,
+    red::RedNode,
+};
+
+pub trait TreeRoot: Deref<Target=SyntaxRoot> + Clone + Send + Sync {}
+
+#[derive(Debug)]
+pub struct SyntaxRoot {
+    red: RedNode,
+    pub(crate) errors: Vec<SyntaxError>,
+}
+
+impl TreeRoot for Arc<SyntaxRoot> {}
+
+impl<'a> TreeRoot for &'a SyntaxRoot {}
+
+impl SyntaxRoot {
+    pub(crate) fn new(green: GreenNode, errors: Vec<SyntaxError>) -> SyntaxRoot {
+        SyntaxRoot {
+            red: RedNode::new_root(green),
+            errors,
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub(crate) struct RedPtr(ptr::NonNull<RedNode>);
+
+unsafe impl Send for RedPtr {}
+
+unsafe impl Sync for RedPtr {}
+
+impl RedPtr {
+    fn new(red: &RedNode) -> RedPtr {
+        RedPtr(red.into())
+    }
+
+    unsafe fn get<'a>(self, _root: &'a impl TreeRoot) -> &'a RedNode {
+        &*self.0.as_ptr()
+    }
+}
+
+#[test]
+fn assert_send_sync() {
+    fn f<T: Send + Sync>() {}
+    f::<GreenNode>();
+    f::<RedNode>();
+    f::<SyntaxNode>();
+}
diff --git a/crates/libsyntax2/src/yellow/red.rs b/crates/libsyntax2/src/yellow/red.rs
new file mode 100644
index 000000000..13ad44c65
--- /dev/null
+++ b/crates/libsyntax2/src/yellow/red.rs
@@ -0,0 +1,94 @@
+use parking_lot::RwLock;
+use {yellow::{GreenNode, RedPtr}, TextUnit};
+
+#[derive(Debug)]
+pub(crate) struct RedNode {
+    green: GreenNode,
+    parent: Option<ParentData>,
+    children: RwLock<Box<[Option<RedNode>]>>,
+}
+
+#[derive(Debug)]
+struct ParentData {
+    parent: RedPtr,
+    start_offset: TextUnit,
+    index_in_parent: usize,
+}
+
+impl RedNode {
+    pub fn new_root(green: GreenNode) -> RedNode {
+        RedNode::new(green, None)
+    }
+
+    fn new_child(
+        green: GreenNode,
+        parent: RedPtr,
+        start_offset: TextUnit,
+        index_in_parent: usize,
+    ) -> RedNode {
+        let parent_data = ParentData {
+            parent,
+            start_offset,
+            index_in_parent,
+        };
+        RedNode::new(green, Some(parent_data))
+    }
+
+    fn new(green: GreenNode, parent: Option<ParentData>) -> RedNode {
+        let n_children = green.children().len();
+        let children = (0..n_children)
+            .map(|_| None)
+            .collect::<Vec<_>>()
+            .into_boxed_slice();
+        RedNode {
+            green,
+            parent,
+            children: RwLock::new(children),
+        }
+    }
+
+    pub(crate) fn green(&self) -> &GreenNode {
+        &self.green
+    }
+
+    pub(crate) fn start_offset(&self) -> TextUnit {
+        match &self.parent {
+            None => 0.into(),
+            Some(p) => p.start_offset,
+        }
+    }
+
+    pub(crate) fn n_children(&self) -> usize {
+        self.green.children().len()
+    }
+
+    pub(crate) fn get_child(&self, idx: usize) -> Option<RedPtr> {
+        if idx >= self.n_children() {
+            return None;
+        }
+        match &self.children.read()[idx] {
+            Some(child) => return Some(RedPtr::new(child)),
+            None => (),
+        };
+        let green_children = self.green.children();
+        let start_offset = self.start_offset()
+            + green_children[..idx]
+            .iter()
+            .map(|x| x.text_len())
+            .sum::<TextUnit>();
+        let child =
+            RedNode::new_child(green_children[idx].clone(), RedPtr::new(self), start_offset, idx);
+        let mut children = self.children.write();
+        if children[idx].is_none() {
+            children[idx] = Some(child)
+        }
+        Some(RedPtr::new(children[idx].as_ref().unwrap()))
+    }
+
+    pub(crate) fn parent(&self) -> Option<RedPtr> {
+        Some(self.parent.as_ref()?.parent)
+    }
+    pub(crate) fn index_in_parent(&self) -> Option<usize> {
+        Some(self.parent.as_ref()?.index_in_parent)
+    }
+}
diff --git a/crates/libsyntax2/src/yellow/syntax.rs b/crates/libsyntax2/src/yellow/syntax.rs
new file mode 100644
index 000000000..6e33310f1
--- /dev/null
+++ b/crates/libsyntax2/src/yellow/syntax.rs
@@ -0,0 +1,122 @@
+use std::{fmt, sync::Arc};
+
+use {
+    yellow::{RedNode, TreeRoot, SyntaxRoot, RedPtr},
+    SyntaxKind::{self, *},
+    TextRange, TextUnit,
+};
+
+
+#[derive(Clone, Copy)]
+pub struct SyntaxNode<R: TreeRoot = Arc<SyntaxRoot>> {
+    pub(crate) root: R,
+    // Guaranteed to not dangle, because `root` holds a
+    // strong reference to red's ancestor
+    red: RedPtr,
+}
+
+unsafe impl<R: TreeRoot> Send for SyntaxNode<R> {}
+unsafe impl<R: TreeRoot> Sync for SyntaxNode<R> {}
+
+impl<R1: TreeRoot, R2: TreeRoot> PartialEq<SyntaxNode<R1>> for SyntaxNode<R2> {
+    fn eq(&self, other: &SyntaxNode<R1>) -> bool {
+        self.red == other.red
+    }
+}
+
+impl<R: TreeRoot> Eq for SyntaxNode<R> {}
+
+pub type SyntaxNodeRef<'a> = SyntaxNode<&'a SyntaxRoot>;
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub struct SyntaxError {
+    pub msg: String,
+    pub offset: TextUnit,
+}
+
+impl SyntaxNode<Arc<SyntaxRoot>> {
+    pub(crate) fn new_owned(root: SyntaxRoot) -> Self {
+        let root = Arc::new(root);
+        let red = RedPtr::new(&root.red);
+        SyntaxNode { root, red }
+    }
+}
+
+impl<R: TreeRoot> SyntaxNode<R> {
+    pub fn as_ref<'a>(&'a self) -> SyntaxNode<&'a SyntaxRoot> {
+        SyntaxNode {
+            root: &*self.root,
+            red: self.red,
+        }
+    }
+
+    pub fn kind(&self) -> SyntaxKind {
+        self.red().green().kind()
+    }
+
+    pub fn range(&self) -> TextRange {
+        let red = self.red();
+        TextRange::offset_len(red.start_offset(), red.green().text_len())
+    }
+
+    pub fn text(&self) -> String {
+        self.red().green().text()
+    }
+
+    pub fn children<'a>(&'a self) -> impl Iterator<Item = SyntaxNode<R>> + 'a {
+        let red = self.red();
+        let n_children = red.n_children();
+        (0..n_children).map(move |i| SyntaxNode {
+            root: self.root.clone(),
+            red: red.get_child(i).unwrap(),
+        })
+    }
+
+    pub fn parent(&self) -> Option<SyntaxNode<R>> {
+        let parent = self.red().parent()?;
+        Some(SyntaxNode {
+            root: self.root.clone(),
+            red: parent,
+        })
+    }
+
+    pub fn first_child(&self) -> Option<SyntaxNode<R>> {
+        self.children().next()
+    }
+
+    pub fn next_sibling(&self) -> Option<SyntaxNode<R>> {
+        let red = self.red();
+        let parent = self.parent()?;
+        let next_sibling_idx = red.index_in_parent()? + 1;
+        let sibling_red = parent.red().get_child(next_sibling_idx)?;
+        Some(SyntaxNode {
+            root: self.root.clone(),
+            red: sibling_red,
+        })
+    }
+
+    pub fn is_leaf(&self) -> bool {
+        self.first_child().is_none()
+    }
+
+    fn red(&self) -> &RedNode {
+        unsafe { self.red.get(&self.root) }
+    }
+}
+
+impl<R: TreeRoot> fmt::Debug for SyntaxNode<R> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "{:?}@{:?}", self.kind(), self.range())?;
+        if has_short_text(self.kind()) {
+            write!(fmt, " \"{}\"", self.text())?;
+        }
+        Ok(())
+    }
+}
+
+fn has_short_text(kind: SyntaxKind) -> bool {
+    match kind {
+        IDENT | LIFETIME | INT_NUMBER | FLOAT_NUMBER => true,
+        _ => false,
+    }
+}
diff --git a/crates/libsyntax2/tests/data/lexer/00012_block_comment.rs b/crates/libsyntax2/tests/data/lexer/00012_block_comment.rs
new file mode 100644
index 000000000..708aac197
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/00012_block_comment.rs
@@ -0,0 +1,4 @@
+/* */
+/**/
+/* /* */ */
+/*
diff --git a/crates/libsyntax2/tests/data/lexer/00012_block_comment.txt b/crates/libsyntax2/tests/data/lexer/00012_block_comment.txt
new file mode 100644
index 000000000..9958b2518
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/00012_block_comment.txt
@@ -0,0 +1,7 @@
+COMMENT 5 "/* */"
+WHITESPACE 1 "\n"
+COMMENT 4 "/**/"
+WHITESPACE 1 "\n"
+COMMENT 11 "/* /* */ */"
+WHITESPACE 1 "\n"
+COMMENT 3 "/*\n"
diff --git a/crates/libsyntax2/tests/data/lexer/0001_hello.rs b/crates/libsyntax2/tests/data/lexer/0001_hello.rs
new file mode 100644
index 000000000..95d09f2b1
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/0001_hello.rs
@@ -0,0 +1 @@
+hello world
\ No newline at end of file
diff --git a/crates/libsyntax2/tests/data/lexer/0001_hello.txt b/crates/libsyntax2/tests/data/lexer/0001_hello.txt
new file mode 100644
index 000000000..27a5940a9
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/0001_hello.txt
@@ -0,0 +1,3 @@
+IDENT 5 "hello"
+WHITESPACE 1 " "
+IDENT 5 "world"
diff --git a/crates/libsyntax2/tests/data/lexer/0002_whitespace.rs b/crates/libsyntax2/tests/data/lexer/0002_whitespace.rs
new file mode 100644
index 000000000..08fce1418
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/0002_whitespace.rs
@@ -0,0 +1,4 @@
+a b  c
+d
+
+e       f
diff --git a/crates/libsyntax2/tests/data/lexer/0002_whitespace.txt b/crates/libsyntax2/tests/data/lexer/0002_whitespace.txt
new file mode 100644
index 000000000..01d260918
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/0002_whitespace.txt
@@ -0,0 +1,12 @@
+IDENT 1 "a"
+WHITESPACE 1 " "
+IDENT 1 "b"
+WHITESPACE 2 "  "
+IDENT 1 "c"
+WHITESPACE 1 "\n"
+IDENT 1 "d"
+WHITESPACE 2 "\n\n"
+IDENT 1 "e"
+WHITESPACE 1 "\t"
+IDENT 1 "f"
+WHITESPACE 1 "\n"
diff --git a/crates/libsyntax2/tests/data/lexer/0003_ident.rs b/crates/libsyntax2/tests/data/lexer/0003_ident.rs
new file mode 100644
index 000000000..c05c9c009
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/0003_ident.rs
@@ -0,0 +1 @@
+foo foo_ _foo _ __ x привет
diff --git a/crates/libsyntax2/tests/data/lexer/0003_ident.txt b/crates/libsyntax2/tests/data/lexer/0003_ident.txt
new file mode 100644
index 000000000..4a0d5c053
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/0003_ident.txt
@@ -0,0 +1,14 @@
+IDENT 3 "foo"
+WHITESPACE 1 " "
+IDENT 4 "foo_"
+WHITESPACE 1 " "
+IDENT 4 "_foo"
+WHITESPACE 1 " "
+UNDERSCORE 1 "_"
+WHITESPACE 1 " "
+IDENT 2 "__"
+WHITESPACE 1 " "
+IDENT 1 "x"
+WHITESPACE 1 " "
+IDENT 12 "привет"
+WHITESPACE 1 "\n"
diff --git a/crates/libsyntax2/tests/data/lexer/0004_numbers.rs b/crates/libsyntax2/tests/data/lexer/0004_numbers.rs
new file mode 100644
index 000000000..dc974b553
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/0004_numbers.rs
@@ -0,0 +1,9 @@
+0 0b 0o 0x 00 0_ 0. 0e 0E 0z
+01790 0b1790 0o1790 0x1790aAbBcCdDeEfF 001279 0_1279 0.1279 0e1279 0E1279
+0..2
+0.foo()
+0e+1
+0.e+1
+0.0E-2
+0___0.10000____0000e+111__
+1i64 92.0f32 11__s
\ No newline at end of file
diff --git a/crates/libsyntax2/tests/data/lexer/0004_numbers.txt b/crates/libsyntax2/tests/data/lexer/0004_numbers.txt
new file mode 100644
index 000000000..4b5fd9f71
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/0004_numbers.txt
@@ -0,0 +1,67 @@
+INT_NUMBER 1 "0"
+WHITESPACE 1 " "
+INT_NUMBER 2 "0b"
+WHITESPACE 1 " "
+INT_NUMBER 2 "0o"
+WHITESPACE 1 " "
+INT_NUMBER 2 "0x"
+WHITESPACE 1 " "
+INT_NUMBER 2 "00"
+WHITESPACE 1 " "
+INT_NUMBER 2 "0_"
+WHITESPACE 1 " "
+FLOAT_NUMBER 2 "0."
+WHITESPACE 1 " "
+INT_NUMBER 2 "0e"
+WHITESPACE 1 " "
+INT_NUMBER 2 "0E"
+WHITESPACE 1 " "
+INT_NUMBER 2 "0z"
+WHITESPACE 1 "\n"
+INT_NUMBER 5 "01790"
+WHITESPACE 1 " "
+INT_NUMBER 6 "0b1790"
+WHITESPACE 1 " "
+INT_NUMBER 6 "0o1790"
+WHITESPACE 1 " "
+INT_NUMBER 18 "0x1790aAbBcCdDeEfF"
+WHITESPACE 1 " "
+INT_NUMBER 6 "001279"
+WHITESPACE 1 " "
+INT_NUMBER 6 "0_1279"
+WHITESPACE 1 " "
+FLOAT_NUMBER 6 "0.1279"
+WHITESPACE 1 " "
+INT_NUMBER 6 "0e1279"
+WHITESPACE 1 " "
+INT_NUMBER 6 "0E1279"
+WHITESPACE 1 "\n"
+INT_NUMBER 1 "0"
+DOTDOT 2 ".."
+INT_NUMBER 1 "2"
+WHITESPACE 1 "\n"
+INT_NUMBER 1 "0"
+DOT 1 "."
+IDENT 3 "foo"
+L_PAREN 1 "("
+R_PAREN 1 ")"
+WHITESPACE 1 "\n"
+INT_NUMBER 2 "0e"
+PLUS 1 "+"
+INT_NUMBER 1 "1"
+WHITESPACE 1 "\n"
+INT_NUMBER 1 "0"
+DOT 1 "."
+IDENT 1 "e"
+PLUS 1 "+"
+INT_NUMBER 1 "1"
+WHITESPACE 1 "\n"
+FLOAT_NUMBER 6 "0.0E-2"
+WHITESPACE 1 "\n"
+FLOAT_NUMBER 26 "0___0.10000____0000e+111__"
+WHITESPACE 1 "\n"
+INT_NUMBER 4 "1i64"
+WHITESPACE 1 " "
+FLOAT_NUMBER 7 "92.0f32"
+WHITESPACE 1 " "
+INT_NUMBER 5 "11__s"
diff --git a/crates/libsyntax2/tests/data/lexer/0005_symbols.rs b/crates/libsyntax2/tests/data/lexer/0005_symbols.rs
new file mode 100644
index 000000000..487569b5a
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/0005_symbols.rs
@@ -0,0 +1,6 @@
+; , ( ) { } [ ] < > @ # ~ ? $ & | + * / ^ %
+. .. ... ..=
+: ::
+= =>
+! !=
+- ->
diff --git a/crates/libsyntax2/tests/data/lexer/0005_symbols.txt b/crates/libsyntax2/tests/data/lexer/0005_symbols.txt
new file mode 100644
index 000000000..a6bc83a6f
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/0005_symbols.txt
@@ -0,0 +1,68 @@
+SEMI 1 ";"
+WHITESPACE 1 " "
+COMMA 1 ","
+WHITESPACE 1 " "
+L_PAREN 1 "("
+WHITESPACE 1 " "
+R_PAREN 1 ")"
+WHITESPACE 1 " "
+L_CURLY 1 "{"
+WHITESPACE 1 " "
+R_CURLY 1 "}"
+WHITESPACE 1 " "
+L_BRACK 1 "["
+WHITESPACE 1 " "
+R_BRACK 1 "]"
+WHITESPACE 1 " "
+L_ANGLE 1 "<"
+WHITESPACE 1 " "
+R_ANGLE 1 ">"
+WHITESPACE 1 " "
+AT 1 "@"
+WHITESPACE 1 " "
+POUND 1 "#"
+WHITESPACE 1 " "
+TILDE 1 "~"
+WHITESPACE 1 " "
+QUESTION 1 "?"
+WHITESPACE 1 " "
+DOLLAR 1 "$"
+WHITESPACE 1 " "
+AMP 1 "&"
+WHITESPACE 1 " "
+PIPE 1 "|"
+WHITESPACE 1 " "
+PLUS 1 "+"
+WHITESPACE 1 " "
+STAR 1 "*"
+WHITESPACE 1 " "
+SLASH 1 "/"
+WHITESPACE 1 " "
+CARET 1 "^"
+WHITESPACE 1 " "
+PERCENT 1 "%"
+WHITESPACE 1 "\n"
+DOT 1 "."
+WHITESPACE 1 " "
+DOTDOT 2 ".."
+WHITESPACE 1 " "
+DOTDOTDOT 3 "..."
+WHITESPACE 1 " "
+DOTDOTEQ 3 "..="
+WHITESPACE 1 "\n"
+COLON 1 ":"
+WHITESPACE 1 " "
+COLONCOLON 2 "::"
+WHITESPACE 1 "\n"
+EQ 1 "="
+WHITESPACE 1 " "
+FAT_ARROW 2 "=>"
+WHITESPACE 1 "\n"
+EXCL 1 "!"
+WHITESPACE 1 " "
+NEQ 2 "!="
+WHITESPACE 1 "\n"
+MINUS 1 "-"
+WHITESPACE 1 " "
+THIN_ARROW 2 "->"
+WHITESPACE 1 "\n"
diff --git a/crates/libsyntax2/tests/data/lexer/0006_chars.rs b/crates/libsyntax2/tests/data/lexer/0006_chars.rs
new file mode 100644
index 000000000..03598d908
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/0006_chars.rs
@@ -0,0 +1 @@
+'x' ' ' '0'
diff --git a/crates/libsyntax2/tests/data/lexer/0006_chars.txt b/crates/libsyntax2/tests/data/lexer/0006_chars.txt
new file mode 100644
index 000000000..ecaf22355
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/0006_chars.txt
@@ -0,0 +1,6 @@
+CHAR 3 "\'x\'"
+WHITESPACE 1 " "
+CHAR 3 "\' \'"
+WHITESPACE 1 " "
+CHAR 3 "\'0\'"
+WHITESPACE 1 "\n"
diff --git a/crates/libsyntax2/tests/data/lexer/0007_lifetimes.rs b/crates/libsyntax2/tests/data/lexer/0007_lifetimes.rs
new file mode 100644
index 000000000..b764f1dce
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/0007_lifetimes.rs
@@ -0,0 +1 @@
+'a 'foo 'foo_bar_baz '_
diff --git a/crates/libsyntax2/tests/data/lexer/0007_lifetimes.txt b/crates/libsyntax2/tests/data/lexer/0007_lifetimes.txt
new file mode 100644
index 000000000..005c29100
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/0007_lifetimes.txt
@@ -0,0 +1,8 @@
+LIFETIME 2 "\'a"
+WHITESPACE 1 " "
+LIFETIME 4 "\'foo"
+WHITESPACE 1 " "
+LIFETIME 12 "\'foo_bar_baz"
+WHITESPACE 1 " "
+LIFETIME 2 "\'_"
+WHITESPACE 1 "\n"
diff --git a/crates/libsyntax2/tests/data/lexer/0008_byte_strings.rs b/crates/libsyntax2/tests/data/lexer/0008_byte_strings.rs
new file mode 100644
index 000000000..9dd1570de
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/0008_byte_strings.rs
@@ -0,0 +1,2 @@
+b'' b'x' b"foo" br""
+b''suf b""ix br""br
diff --git a/crates/libsyntax2/tests/data/lexer/0008_byte_strings.txt b/crates/libsyntax2/tests/data/lexer/0008_byte_strings.txt
new file mode 100644
index 000000000..ed8cd4bab
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/0008_byte_strings.txt
@@ -0,0 +1,14 @@
+BYTE 3 "b\'\'"
+WHITESPACE 1 " "
+BYTE 4 "b\'x\'"
+WHITESPACE 1 " "
+BYTE_STRING 6 "b\"foo\""
+WHITESPACE 1 " "
+RAW_BYTE_STRING 4 "br\"\""
+WHITESPACE 1 "\n"
+BYTE 6 "b\'\'suf"
+WHITESPACE 1 " "
+BYTE_STRING 5 "b\"\"ix"
+WHITESPACE 1 " "
+RAW_BYTE_STRING 6 "br\"\"br"
+WHITESPACE 1 "\n"
diff --git a/crates/libsyntax2/tests/data/lexer/0009_strings.rs b/crates/libsyntax2/tests/data/lexer/0009_strings.rs
new file mode 100644
index 000000000..7b7faa5d8
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/0009_strings.rs
@@ -0,0 +1 @@
+"hello" r"world"
diff --git a/crates/libsyntax2/tests/data/lexer/0009_strings.txt b/crates/libsyntax2/tests/data/lexer/0009_strings.txt
new file mode 100644
index 000000000..7fb6b7b36
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/0009_strings.txt
@@ -0,0 +1,4 @@
+STRING 7 "\"hello\""
+WHITESPACE 1 " "
+RAW_STRING 8 "r\"world\""
+WHITESPACE 1 "\n"
diff --git a/crates/libsyntax2/tests/data/lexer/0010_comments.rs b/crates/libsyntax2/tests/data/lexer/0010_comments.rs
new file mode 100644
index 000000000..71bdd1f9c
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/0010_comments.rs
@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+// hello
+//! World
diff --git a/crates/libsyntax2/tests/data/lexer/0010_comments.txt b/crates/libsyntax2/tests/data/lexer/0010_comments.txt
new file mode 100644
index 000000000..3c997de3f
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/0010_comments.txt
@@ -0,0 +1,6 @@
+SHEBANG 19 "#!/usr/bin/env bash"
+WHITESPACE 1 "\n"
+COMMENT 8 "// hello"
+WHITESPACE 1 "\n"
+COMMENT 9 "//! World"
+WHITESPACE 1 "\n"
diff --git a/crates/libsyntax2/tests/data/lexer/0011_keywords.rs b/crates/libsyntax2/tests/data/lexer/0011_keywords.rs
new file mode 100644
index 000000000..e6bf64d4d
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/0011_keywords.rs
@@ -0,0 +1,3 @@
+fn use struct trait enum impl true false as extern crate
+mod pub self super in where for loop while if match const
+static mut type ref let else move return
diff --git a/crates/libsyntax2/tests/data/lexer/0011_keywords.txt b/crates/libsyntax2/tests/data/lexer/0011_keywords.txt
new file mode 100644
index 000000000..d6a1abe8a
--- /dev/null
+++ b/crates/libsyntax2/tests/data/lexer/0011_keywords.txt
@@ -0,0 +1,62 @@
+FN_KW 2 "fn"
+WHITESPACE 1 " "
+USE_KW 3 "use"
+WHITESPACE 1 " "
+STRUCT_KW 6 "struct"
+WHITESPACE 1 " "
+TRAIT_KW 5 "trait"
+WHITESPACE 1 " "
+ENUM_KW 4 "enum"
+WHITESPACE 1 " "
+IMPL_KW 4 "impl"
+WHITESPACE 1 " "
+TRUE_KW 4 "true"
+WHITESPACE 1 " "
+FALSE_KW 5 "false"
+WHITESPACE 1 " "
+AS_KW 2 "as"
+WHITESPACE 1 " "
+EXTERN_KW 6 "extern"
+WHITESPACE 1 " "
+CRATE_KW 5 "crate"
+WHITESPACE 1 "\n"
+MOD_KW 3 "mod"
+WHITESPACE 1 " "
+PUB_KW 3 "pub"
+WHITESPACE 1 " "
+SELF_KW 4 "self"
+WHITESPACE 1 " "
+SUPER_KW 5 "super"
+WHITESPACE 1 " "
+IN_KW 2 "in"
+WHITESPACE 1 " "
+WHERE_KW 5 "where"
+WHITESPACE 1 " "
+FOR_KW 3 "for"
+WHITESPACE 1 " "
+LOOP_KW 4 "loop"
+WHITESPACE 1 " "
+WHILE_KW 5 "while"
+WHITESPACE 1 " "
+IF_KW 2 "if"
+WHITESPACE 1 " "
+MATCH_KW 5 "match"
+WHITESPACE 1 " "
+CONST_KW 5 "const"
+WHITESPACE 1 "\n"
+STATIC_KW 6 "static"
+WHITESPACE 1 " "
+MUT_KW 3 "mut"
+WHITESPACE 1 " "
+TYPE_KW 4 "type"
+WHITESPACE 1 " "
+REF_KW 3 "ref"
+WHITESPACE 1 " "
+LET_KW 3 "let"
+WHITESPACE 1 " "
+ELSE_KW 4 "else"
+WHITESPACE 1 " "
+MOVE_KW 4 "move"
+WHITESPACE 1 " "
+RETURN_KW 6 "return"
+WHITESPACE 1 "\n"
diff --git a/crates/libsyntax2/tests/data/parser/err/0000_struct_field_missing_comma.rs b/crates/libsyntax2/tests/data/parser/err/0000_struct_field_missing_comma.rs
new file mode 100644
index 000000000..fe5030d89
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0000_struct_field_missing_comma.rs
@@ -0,0 +1,4 @@
+struct S {
+    a: u32
+    b: u32
+}
\ No newline at end of file
diff --git a/crates/libsyntax2/tests/data/parser/err/0000_struct_field_missing_comma.txt b/crates/libsyntax2/tests/data/parser/err/0000_struct_field_missing_comma.txt
new file mode 100644
index 000000000..1b5d722f8
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0000_struct_field_missing_comma.txt
@@ -0,0 +1,33 @@
+FILE@[0; 34)
+  STRUCT_ITEM@[0; 34)
+    STRUCT_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    NAME@[7; 8)
+      IDENT@[7; 8) "S"
+    WHITESPACE@[8; 9)
+    L_CURLY@[9; 10)
+    WHITESPACE@[10; 15)
+    NAMED_FIELD@[15; 21)
+      NAME@[15; 16)
+        IDENT@[15; 16) "a"
+      COLON@[16; 17)
+      WHITESPACE@[17; 18)
+      PATH_TYPE@[18; 21)
+        PATH@[18; 21)
+          PATH_SEGMENT@[18; 21)
+            NAME_REF@[18; 21)
+              IDENT@[18; 21) "u32"
+              err: `expected COMMA`
+    WHITESPACE@[21; 26)
+    NAMED_FIELD@[26; 32)
+      NAME@[26; 27)
+        IDENT@[26; 27) "b"
+      COLON@[27; 28)
+      WHITESPACE@[28; 29)
+      PATH_TYPE@[29; 32)
+        PATH@[29; 32)
+          PATH_SEGMENT@[29; 32)
+            NAME_REF@[29; 32)
+              IDENT@[29; 32) "u32"
+    WHITESPACE@[32; 33)
+    R_CURLY@[33; 34)
diff --git a/crates/libsyntax2/tests/data/parser/err/0001_item_recovery_in_file.rs b/crates/libsyntax2/tests/data/parser/err/0001_item_recovery_in_file.rs
new file mode 100644
index 000000000..98f23de1f
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0001_item_recovery_in_file.rs
@@ -0,0 +1,3 @@
+if match
+
+struct S {}
\ No newline at end of file
diff --git a/crates/libsyntax2/tests/data/parser/err/0001_item_recovery_in_file.txt b/crates/libsyntax2/tests/data/parser/err/0001_item_recovery_in_file.txt
new file mode 100644
index 000000000..1aaf07625
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0001_item_recovery_in_file.txt
@@ -0,0 +1,17 @@
+FILE@[0; 21)
+  ERROR@[0; 2)
+    IF_KW@[0; 2)
+    err: `expected an item`
+  WHITESPACE@[2; 3)
+  err: `expected an item`
+  ERROR@[3; 8)
+    MATCH_KW@[3; 8)
+  WHITESPACE@[8; 10)
+  STRUCT_ITEM@[10; 21)
+    STRUCT_KW@[10; 16)
+    WHITESPACE@[16; 17)
+    NAME@[17; 18)
+      IDENT@[17; 18) "S"
+    WHITESPACE@[18; 19)
+    L_CURLY@[19; 20)
+    R_CURLY@[20; 21)
diff --git a/crates/libsyntax2/tests/data/parser/err/0002_duplicate_shebang.rs b/crates/libsyntax2/tests/data/parser/err/0002_duplicate_shebang.rs
new file mode 100644
index 000000000..48a3a3980
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0002_duplicate_shebang.rs
@@ -0,0 +1,2 @@
+#!/use/bin/env rusti
+#!/use/bin/env rusti
diff --git a/crates/libsyntax2/tests/data/parser/err/0002_duplicate_shebang.txt b/crates/libsyntax2/tests/data/parser/err/0002_duplicate_shebang.txt
new file mode 100644
index 000000000..0b6aa26eb
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0002_duplicate_shebang.txt
@@ -0,0 +1,7 @@
+FILE@[0; 42)
+  SHEBANG@[0; 20)
+  WHITESPACE@[20; 21)
+  err: `expected an item`
+  ERROR@[21; 41)
+    SHEBANG@[21; 41)
+  WHITESPACE@[41; 42)
diff --git a/crates/libsyntax2/tests/data/parser/err/0003_C++_semicolon.rs b/crates/libsyntax2/tests/data/parser/err/0003_C++_semicolon.rs
new file mode 100644
index 000000000..009312270
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0003_C++_semicolon.rs
@@ -0,0 +1,4 @@
+struct S {
+    a: i32,
+    b: String,
+};
\ No newline at end of file
diff --git a/crates/libsyntax2/tests/data/parser/err/0003_C++_semicolon.txt b/crates/libsyntax2/tests/data/parser/err/0003_C++_semicolon.txt
new file mode 100644
index 000000000..81777fec0
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0003_C++_semicolon.txt
@@ -0,0 +1,38 @@
+FILE@[0; 40)
+  STRUCT_ITEM@[0; 40)
+    STRUCT_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    NAME@[7; 8)
+      IDENT@[7; 8) "S"
+    WHITESPACE@[8; 9)
+    L_CURLY@[9; 10)
+    WHITESPACE@[10; 15)
+    NAMED_FIELD@[15; 21)
+      NAME@[15; 16)
+        IDENT@[15; 16) "a"
+      COLON@[16; 17)
+      WHITESPACE@[17; 18)
+      PATH_TYPE@[18; 21)
+        PATH@[18; 21)
+          PATH_SEGMENT@[18; 21)
+            NAME_REF@[18; 21)
+              IDENT@[18; 21) "i32"
+    COMMA@[21; 22)
+    WHITESPACE@[22; 27)
+    NAMED_FIELD@[27; 36)
+      NAME@[27; 28)
+        IDENT@[27; 28) "b"
+      COLON@[28; 29)
+      WHITESPACE@[29; 30)
+      PATH_TYPE@[30; 36)
+        PATH@[30; 36)
+          PATH_SEGMENT@[30; 36)
+            NAME_REF@[30; 36)
+              IDENT@[30; 36) "String"
+    COMMA@[36; 37)
+    WHITESPACE@[37; 38)
+    R_CURLY@[38; 39)
+    err: `expected item, found `;`
+consider removing this semicolon`
+    ERROR@[39; 40)
+      SEMI@[39; 40)
diff --git a/crates/libsyntax2/tests/data/parser/err/0004_use_path_bad_segment.rs b/crates/libsyntax2/tests/data/parser/err/0004_use_path_bad_segment.rs
new file mode 100644
index 000000000..060e65d06
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0004_use_path_bad_segment.rs
@@ -0,0 +1 @@
+use foo::92;
\ No newline at end of file
diff --git a/crates/libsyntax2/tests/data/parser/err/0004_use_path_bad_segment.txt b/crates/libsyntax2/tests/data/parser/err/0004_use_path_bad_segment.txt
new file mode 100644
index 000000000..c6ae68103
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0004_use_path_bad_segment.txt
@@ -0,0 +1,20 @@
+FILE@[0; 12)
+  USE_ITEM@[0; 9)
+    USE_KW@[0; 3)
+    WHITESPACE@[3; 4)
+    USE_TREE@[4; 9)
+      PATH@[4; 9)
+        PATH@[4; 7)
+          PATH_SEGMENT@[4; 7)
+            NAME_REF@[4; 7)
+              IDENT@[4; 7) "foo"
+        COLONCOLON@[7; 9)
+        err: `expected identifier`
+        err: `expected SEMI`
+        err: `expected an item`
+        PATH_SEGMENT@[9; 9)
+  ERROR@[9; 11)
+    INT_NUMBER@[9; 11) "92"
+    err: `expected an item`
+  ERROR@[11; 12)
+    SEMI@[11; 12)
diff --git a/crates/libsyntax2/tests/data/parser/err/0005_attribute_recover.rs b/crates/libsyntax2/tests/data/parser/err/0005_attribute_recover.rs
new file mode 100644
index 000000000..de7f81628
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0005_attribute_recover.rs
@@ -0,0 +1,8 @@
+#[foo(foo, +, 92)]
+fn foo() {
+}
+
+
+#[foo(
+fn foo() {
+}
diff --git a/crates/libsyntax2/tests/data/parser/err/0005_attribute_recover.txt b/crates/libsyntax2/tests/data/parser/err/0005_attribute_recover.txt
new file mode 100644
index 000000000..079b0d1f6
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0005_attribute_recover.txt
@@ -0,0 +1,60 @@
+FILE@[0; 54)
+  FUNCTION@[0; 31)
+    ATTR@[0; 18)
+      POUND@[0; 1)
+      L_BRACK@[1; 2)
+      META_ITEM@[2; 17)
+        IDENT@[2; 5) "foo"
+        L_PAREN@[5; 6)
+        META_ITEM@[6; 9)
+          IDENT@[6; 9) "foo"
+        COMMA@[9; 10)
+        WHITESPACE@[10; 11)
+        err: `expected attribute`
+        ERROR@[11; 12)
+          PLUS@[11; 12)
+          err: `expected attribute`
+        ERROR@[12; 13)
+          COMMA@[12; 13)
+        WHITESPACE@[13; 14)
+        LITERAL@[14; 16)
+          INT_NUMBER@[14; 16) "92"
+        R_PAREN@[16; 17)
+      R_BRACK@[17; 18)
+    WHITESPACE@[18; 19)
+    FN_KW@[19; 21)
+    WHITESPACE@[21; 22)
+    NAME@[22; 25)
+      IDENT@[22; 25) "foo"
+    PARAM_LIST@[25; 27)
+      L_PAREN@[25; 26)
+      R_PAREN@[26; 27)
+    WHITESPACE@[27; 28)
+    BLOCK_EXPR@[28; 31)
+      L_CURLY@[28; 29)
+      WHITESPACE@[29; 30)
+      R_CURLY@[30; 31)
+  WHITESPACE@[31; 34)
+  FUNCTION@[34; 53)
+    ATTR@[34; 40)
+      POUND@[34; 35)
+      L_BRACK@[35; 36)
+      META_ITEM@[36; 40)
+        IDENT@[36; 39) "foo"
+        L_PAREN@[39; 40)
+        err: `expected attribute`
+        err: `expected R_BRACK`
+    WHITESPACE@[40; 41)
+    FN_KW@[41; 43)
+    WHITESPACE@[43; 44)
+    NAME@[44; 47)
+      IDENT@[44; 47) "foo"
+    PARAM_LIST@[47; 49)
+      L_PAREN@[47; 48)
+      R_PAREN@[48; 49)
+    WHITESPACE@[49; 50)
+    BLOCK_EXPR@[50; 53)
+      L_CURLY@[50; 51)
+      WHITESPACE@[51; 52)
+      R_CURLY@[52; 53)
+  WHITESPACE@[53; 54)
diff --git a/crates/libsyntax2/tests/data/parser/err/0006_named_field_recovery.rs b/crates/libsyntax2/tests/data/parser/err/0006_named_field_recovery.rs
new file mode 100644
index 000000000..8069c111b
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0006_named_field_recovery.rs
@@ -0,0 +1,7 @@
+struct S {
+    f: u32,
+    pub 92
+    + - *
+    pub x: u32,
+    z: f64,
+}
diff --git a/crates/libsyntax2/tests/data/parser/err/0006_named_field_recovery.txt b/crates/libsyntax2/tests/data/parser/err/0006_named_field_recovery.txt
new file mode 100644
index 000000000..009b307b1
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0006_named_field_recovery.txt
@@ -0,0 +1,73 @@
+FILE@[0; 74)
+  STRUCT_ITEM@[0; 73)
+    STRUCT_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    NAME@[7; 8)
+      IDENT@[7; 8) "S"
+    WHITESPACE@[8; 9)
+    L_CURLY@[9; 10)
+    WHITESPACE@[10; 15)
+    NAMED_FIELD@[15; 21)
+      NAME@[15; 16)
+        IDENT@[15; 16) "f"
+      COLON@[16; 17)
+      WHITESPACE@[17; 18)
+      PATH_TYPE@[18; 21)
+        PATH@[18; 21)
+          PATH_SEGMENT@[18; 21)
+            NAME_REF@[18; 21)
+              IDENT@[18; 21) "u32"
+    COMMA@[21; 22)
+    WHITESPACE@[22; 27)
+    VISIBILITY@[27; 30)
+      PUB_KW@[27; 30)
+    WHITESPACE@[30; 31)
+    err: `expected field declaration`
+    ERROR@[31; 33)
+      INT_NUMBER@[31; 33) "92"
+      err: `expected COMMA`
+    WHITESPACE@[33; 38)
+    err: `expected field declaration`
+    ERROR@[38; 39)
+      PLUS@[38; 39)
+      err: `expected COMMA`
+    WHITESPACE@[39; 40)
+    err: `expected field declaration`
+    ERROR@[40; 41)
+      MINUS@[40; 41)
+      err: `expected COMMA`
+    WHITESPACE@[41; 42)
+    err: `expected field declaration`
+    ERROR@[42; 43)
+      STAR@[42; 43)
+      err: `expected COMMA`
+    WHITESPACE@[43; 48)
+    NAMED_FIELD@[48; 58)
+      VISIBILITY@[48; 51)
+        PUB_KW@[48; 51)
+      WHITESPACE@[51; 52)
+      NAME@[52; 53)
+        IDENT@[52; 53) "x"
+      COLON@[53; 54)
+      WHITESPACE@[54; 55)
+      PATH_TYPE@[55; 58)
+        PATH@[55; 58)
+          PATH_SEGMENT@[55; 58)
+            NAME_REF@[55; 58)
+              IDENT@[55; 58) "u32"
+    COMMA@[58; 59)
+    WHITESPACE@[59; 64)
+    NAMED_FIELD@[64; 70)
+      NAME@[64; 65)
+        IDENT@[64; 65) "z"
+      COLON@[65; 66)
+      WHITESPACE@[66; 67)
+      PATH_TYPE@[67; 70)
+        PATH@[67; 70)
+          PATH_SEGMENT@[67; 70)
+            NAME_REF@[67; 70)
+              IDENT@[67; 70) "f64"
+    COMMA@[70; 71)
+    WHITESPACE@[71; 72)
+    R_CURLY@[72; 73)
+  WHITESPACE@[73; 74)
diff --git a/crates/libsyntax2/tests/data/parser/err/0007_stray_curly_in_file.rs b/crates/libsyntax2/tests/data/parser/err/0007_stray_curly_in_file.rs
new file mode 100644
index 000000000..dc869fb78
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0007_stray_curly_in_file.rs
@@ -0,0 +1,9 @@
+}
+
+struct S;
+
+}
+
+fn foo(){}
+
+}
diff --git a/crates/libsyntax2/tests/data/parser/err/0007_stray_curly_in_file.txt b/crates/libsyntax2/tests/data/parser/err/0007_stray_curly_in_file.txt
new file mode 100644
index 000000000..b36decb46
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0007_stray_curly_in_file.txt
@@ -0,0 +1,32 @@
+FILE@[0; 31)
+  ERROR@[0; 1)
+    R_CURLY@[0; 1)
+    err: `expected an item`
+  WHITESPACE@[1; 3)
+  STRUCT_ITEM@[3; 12)
+    STRUCT_KW@[3; 9)
+    WHITESPACE@[9; 10)
+    NAME@[10; 11)
+      IDENT@[10; 11) "S"
+    SEMI@[11; 12)
+  WHITESPACE@[12; 14)
+  err: `expected an item`
+  ERROR@[14; 15)
+    R_CURLY@[14; 15)
+  WHITESPACE@[15; 17)
+  FUNCTION@[17; 27)
+    FN_KW@[17; 19)
+    WHITESPACE@[19; 20)
+    NAME@[20; 23)
+      IDENT@[20; 23) "foo"
+    PARAM_LIST@[23; 25)
+      L_PAREN@[23; 24)
+      R_PAREN@[24; 25)
+    BLOCK_EXPR@[25; 27)
+      L_CURLY@[25; 26)
+      R_CURLY@[26; 27)
+  WHITESPACE@[27; 29)
+  err: `expected an item`
+  ERROR@[29; 30)
+    R_CURLY@[29; 30)
+  WHITESPACE@[30; 31)
diff --git a/crates/libsyntax2/tests/data/parser/err/0008_item_block_recovery.rs b/crates/libsyntax2/tests/data/parser/err/0008_item_block_recovery.rs
new file mode 100644
index 000000000..9fcac19b5
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0008_item_block_recovery.rs
@@ -0,0 +1,13 @@
+fn foo() {
+}
+
+bar() {
+    if true {
+        1
+    } else {
+        2 + 3
+    }
+}
+
+fn baz() {
+}
diff --git a/crates/libsyntax2/tests/data/parser/err/0008_item_block_recovery.txt b/crates/libsyntax2/tests/data/parser/err/0008_item_block_recovery.txt
new file mode 100644
index 000000000..f2a503cec
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0008_item_block_recovery.txt
@@ -0,0 +1,67 @@
+FILE@[0; 95)
+  FUNCTION@[0; 12)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 12)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 11)
+      R_CURLY@[11; 12)
+  WHITESPACE@[12; 14)
+  MACRO_CALL@[14; 19)
+    PATH@[14; 17)
+      PATH_SEGMENT@[14; 17)
+        NAME_REF@[14; 17)
+          IDENT@[14; 17) "bar"
+          err: `expected EXCL`
+    L_PAREN@[17; 18)
+    R_PAREN@[18; 19)
+    err: `expected SEMI`
+  WHITESPACE@[19; 20)
+  err: `expected an item`
+  ERROR@[20; 80)
+    L_CURLY@[20; 21)
+    WHITESPACE@[21; 26)
+    IF_KW@[26; 28)
+    WHITESPACE@[28; 29)
+    TRUE_KW@[29; 33)
+    WHITESPACE@[33; 34)
+    L_CURLY@[34; 35)
+    WHITESPACE@[35; 44)
+    INT_NUMBER@[44; 45) "1"
+    WHITESPACE@[45; 50)
+    R_CURLY@[50; 51)
+    WHITESPACE@[51; 52)
+    ELSE_KW@[52; 56)
+    WHITESPACE@[56; 57)
+    L_CURLY@[57; 58)
+    WHITESPACE@[58; 67)
+    INT_NUMBER@[67; 68) "2"
+    WHITESPACE@[68; 69)
+    PLUS@[69; 70)
+    WHITESPACE@[70; 71)
+    INT_NUMBER@[71; 72) "3"
+    WHITESPACE@[72; 77)
+    R_CURLY@[77; 78)
+    WHITESPACE@[78; 79)
+    R_CURLY@[79; 80)
+  WHITESPACE@[80; 82)
+  FUNCTION@[82; 94)
+    FN_KW@[82; 84)
+    WHITESPACE@[84; 85)
+    NAME@[85; 88)
+      IDENT@[85; 88) "baz"
+    PARAM_LIST@[88; 90)
+      L_PAREN@[88; 89)
+      R_PAREN@[89; 90)
+    WHITESPACE@[90; 91)
+    BLOCK_EXPR@[91; 94)
+      L_CURLY@[91; 92)
+      WHITESPACE@[92; 93)
+      R_CURLY@[93; 94)
+  WHITESPACE@[94; 95)
diff --git a/crates/libsyntax2/tests/data/parser/err/0009_broken_struct_type_parameter.rs b/crates/libsyntax2/tests/data/parser/err/0009_broken_struct_type_parameter.rs
new file mode 100644
index 000000000..0dd30d0bd
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0009_broken_struct_type_parameter.rs
@@ -0,0 +1,5 @@
+struct S<90 + 2> {
+    f: u32
+}
+
+struct T;
diff --git a/crates/libsyntax2/tests/data/parser/err/0009_broken_struct_type_parameter.txt b/crates/libsyntax2/tests/data/parser/err/0009_broken_struct_type_parameter.txt
new file mode 100644
index 000000000..fc736f0e9
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0009_broken_struct_type_parameter.txt
@@ -0,0 +1,44 @@
+FILE@[0; 43)
+  STRUCT_ITEM@[0; 11)
+    STRUCT_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    NAME@[7; 8)
+      IDENT@[7; 8) "S"
+    TYPE_PARAM_LIST@[8; 11)
+      L_ANGLE@[8; 9)
+      err: `expected type parameter`
+      ERROR@[9; 11)
+        INT_NUMBER@[9; 11) "90"
+        err: `expected COMMA`
+        err: `expected R_ANGLE`
+        err: `expected `;`, `{`, or `(``
+  WHITESPACE@[11; 12)
+  err: `expected an item`
+  ERROR@[12; 13)
+    PLUS@[12; 13)
+  WHITESPACE@[13; 14)
+  err: `expected an item`
+  ERROR@[14; 15)
+    INT_NUMBER@[14; 15) "2"
+    err: `expected an item`
+  ERROR@[15; 16)
+    R_ANGLE@[15; 16)
+  WHITESPACE@[16; 17)
+  err: `expected an item`
+  ERROR@[17; 31)
+    L_CURLY@[17; 18)
+    WHITESPACE@[18; 23)
+    IDENT@[23; 24) "f"
+    COLON@[24; 25)
+    WHITESPACE@[25; 26)
+    IDENT@[26; 29) "u32"
+    WHITESPACE@[29; 30)
+    R_CURLY@[30; 31)
+  WHITESPACE@[31; 33)
+  STRUCT_ITEM@[33; 42)
+    STRUCT_KW@[33; 39)
+    WHITESPACE@[39; 40)
+    NAME@[40; 41)
+      IDENT@[40; 41) "T"
+    SEMI@[41; 42)
+  WHITESPACE@[42; 43)
diff --git a/crates/libsyntax2/tests/data/parser/err/0010_unsafe_lambda_block.rs b/crates/libsyntax2/tests/data/parser/err/0010_unsafe_lambda_block.rs
new file mode 100644
index 000000000..985775282
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0010_unsafe_lambda_block.rs
@@ -0,0 +1,3 @@
+fn main() {
+    || -> () unsafe { () };
+}
diff --git a/crates/libsyntax2/tests/data/parser/err/0010_unsafe_lambda_block.txt b/crates/libsyntax2/tests/data/parser/err/0010_unsafe_lambda_block.txt
new file mode 100644
index 000000000..95d4af424
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0010_unsafe_lambda_block.txt
@@ -0,0 +1,40 @@
+FILE@[0; 42)
+  FUNCTION@[0; 41)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8)
+      R_PAREN@[8; 9)
+    WHITESPACE@[9; 10)
+    BLOCK_EXPR@[10; 41)
+      L_CURLY@[10; 11)
+      WHITESPACE@[11; 16)
+      LAMBDA_EXPR@[16; 24)
+        PARAM_LIST@[16; 18)
+          PIPE@[16; 17)
+          PIPE@[17; 18)
+        WHITESPACE@[18; 19)
+        THIN_ARROW@[19; 21)
+        WHITESPACE@[21; 22)
+        TUPLE_TYPE@[22; 24)
+          L_PAREN@[22; 23)
+          R_PAREN@[23; 24)
+          err: `expected block`
+      WHITESPACE@[24; 25)
+      EXPR_STMT@[25; 39)
+        BLOCK_EXPR@[25; 38)
+          UNSAFE_KW@[25; 31)
+          WHITESPACE@[31; 32)
+          L_CURLY@[32; 33)
+          WHITESPACE@[33; 34)
+          TUPLE_EXPR@[34; 36)
+            L_PAREN@[34; 35)
+            R_PAREN@[35; 36)
+          WHITESPACE@[36; 37)
+          R_CURLY@[37; 38)
+        SEMI@[38; 39)
+      WHITESPACE@[39; 40)
+      R_CURLY@[40; 41)
+  WHITESPACE@[41; 42)
diff --git a/crates/libsyntax2/tests/data/parser/err/0011_extern_struct.rs b/crates/libsyntax2/tests/data/parser/err/0011_extern_struct.rs
new file mode 100644
index 000000000..c1bd0a2d1
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0011_extern_struct.rs
@@ -0,0 +1 @@
+extern struct Foo;
diff --git a/crates/libsyntax2/tests/data/parser/err/0011_extern_struct.txt b/crates/libsyntax2/tests/data/parser/err/0011_extern_struct.txt
new file mode 100644
index 000000000..3c5b678a1
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0011_extern_struct.txt
@@ -0,0 +1,13 @@
+FILE@[0; 19)
+  ERROR@[0; 6)
+    ABI@[0; 6)
+      EXTERN_KW@[0; 6)
+      err: `expected fn, trait or impl`
+  WHITESPACE@[6; 7)
+  STRUCT_ITEM@[7; 18)
+    STRUCT_KW@[7; 13)
+    WHITESPACE@[13; 14)
+    NAME@[14; 17)
+      IDENT@[14; 17) "Foo"
+    SEMI@[17; 18)
+  WHITESPACE@[18; 19)
diff --git a/crates/libsyntax2/tests/data/parser/err/0012_broken_lambda.rs b/crates/libsyntax2/tests/data/parser/err/0012_broken_lambda.rs
new file mode 100644
index 000000000..ad0d8eb4c
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0012_broken_lambda.rs
@@ -0,0 +1,12 @@
+pub(super) fn process<'a, S: Sink<'a>>(builder: &mut S, tokens: &[Token], events: Vec<Event>) {
+    let mut next_tok_idx = 0;
+    let eat_ws = |idx: &mut usize, &mut | {
+        while let Some(token) = tokens.get(*idx) {
+            if !token.kind.is_trivia() {
+                break;
+            }
+            builder.leaf(token.kind, token.len);
+            *idx += 1
+        }
+    };
+}
diff --git a/crates/libsyntax2/tests/data/parser/err/0012_broken_lambda.txt b/crates/libsyntax2/tests/data/parser/err/0012_broken_lambda.txt
new file mode 100644
index 000000000..cf6e68a78
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/err/0012_broken_lambda.txt
@@ -0,0 +1,387 @@
+FILE@[0; 389)
+  FUNCTION@[0; 389)
+    VISIBILITY@[0; 10)
+      PUB_KW@[0; 3)
+      L_PAREN@[3; 4)
+      SUPER_KW@[4; 9)
+      R_PAREN@[9; 10)
+    WHITESPACE@[10; 11)
+    FN_KW@[11; 13)
+    WHITESPACE@[13; 14)
+    NAME@[14; 21)
+      IDENT@[14; 21) "process"
+    TYPE_PARAM_LIST@[21; 38)
+      L_ANGLE@[21; 22)
+      LIFETIME_PARAM@[22; 24)
+        LIFETIME@[22; 24) "'a"
+      COMMA@[24; 25)
+      WHITESPACE@[25; 26)
+      TYPE_PARAM@[26; 37)
+        NAME@[26; 27)
+          IDENT@[26; 27) "S"
+        COLON@[27; 28)
+        WHITESPACE@[28; 29)
+        PATH@[29; 37)
+          PATH_SEGMENT@[29; 37)
+            NAME_REF@[29; 33)
+              IDENT@[29; 33) "Sink"
+            TYPE_ARG_LIST@[33; 37)
+              L_ANGLE@[33; 34)
+              LIFETIME_ARG@[34; 36)
+                LIFETIME@[34; 36) "'a"
+              R_ANGLE@[36; 37)
+      R_ANGLE@[37; 38)
+    PARAM_LIST@[38; 93)
+      L_PAREN@[38; 39)
+      PARAM@[39; 54)
+        BIND_PAT@[39; 46)
+          NAME@[39; 46)
+            IDENT@[39; 46) "builder"
+        COLON@[46; 47)
+        WHITESPACE@[47; 48)
+        REFERENCE_TYPE@[48; 54)
+          AMP@[48; 49)
+          MUT_KW@[49; 52)
+          WHITESPACE@[52; 53)
+          PATH_TYPE@[53; 54)
+            PATH@[53; 54)
+              PATH_SEGMENT@[53; 54)
+                NAME_REF@[53; 54)
+                  IDENT@[53; 54) "S"
+      COMMA@[54; 55)
+      WHITESPACE@[55; 56)
+      PARAM@[56; 72)
+        BIND_PAT@[56; 62)
+          NAME@[56; 62)
+            IDENT@[56; 62) "tokens"
+        COLON@[62; 63)
+        WHITESPACE@[63; 64)
+        REFERENCE_TYPE@[64; 72)
+          AMP@[64; 65)
+          SLICE_TYPE@[65; 72)
+            L_BRACK@[65; 66)
+            PATH_TYPE@[66; 71)
+              PATH@[66; 71)
+                PATH_SEGMENT@[66; 71)
+                  NAME_REF@[66; 71)
+                    IDENT@[66; 71) "Token"
+            R_BRACK@[71; 72)
+      COMMA@[72; 73)
+      WHITESPACE@[73; 74)
+      PARAM@[74; 92)
+        BIND_PAT@[74; 80)
+          NAME@[74; 80)
+            IDENT@[74; 80) "events"
+        COLON@[80; 81)
+        WHITESPACE@[81; 82)
+        PATH_TYPE@[82; 92)
+          PATH@[82; 92)
+            PATH_SEGMENT@[82; 92)
+              NAME_REF@[82; 85)
+                IDENT@[82; 85) "Vec"
+              TYPE_ARG_LIST@[85; 92)
+                L_ANGLE@[85; 86)
+                TYPE_ARG@[86; 91)
+                  PATH_TYPE@[86; 91)
+                    PATH@[86; 91)
+                      PATH_SEGMENT@[86; 91)
+                        NAME_REF@[86; 91)
+                          IDENT@[86; 91) "Event"
+                R_ANGLE@[91; 92)
+      R_PAREN@[92; 93)
+    WHITESPACE@[93; 94)
+    BLOCK_EXPR@[94; 389)
+      L_CURLY@[94; 95)
+      WHITESPACE@[95; 100)
+      LET_STMT@[100; 125)
+        LET_KW@[100; 103)
+        WHITESPACE@[103; 104)
+        BIND_PAT@[104; 120)
+          MUT_KW@[104; 107)
+          WHITESPACE@[107; 108)
+          NAME@[108; 120)
+            IDENT@[108; 120) "next_tok_idx"
+        WHITESPACE@[120; 121)
+        EQ@[121; 122)
+        WHITESPACE@[122; 123)
+        LITERAL@[123; 124)
+          INT_NUMBER@[123; 124) "0"
+        SEMI@[124; 125)
+      WHITESPACE@[125; 130)
+      LET_STMT@[130; 389)
+        LET_KW@[130; 133)
+        WHITESPACE@[133; 134)
+        BIND_PAT@[134; 140)
+          NAME@[134; 140)
+            IDENT@[134; 140) "eat_ws"
+        WHITESPACE@[140; 141)
+        EQ@[141; 142)
+        WHITESPACE@[142; 143)
+        LAMBDA_EXPR@[143; 389)
+          PARAM_LIST@[143; 388)
+            PIPE@[143; 144)
+            PARAM@[144; 159)
+              BIND_PAT@[144; 147)
+                NAME@[144; 147)
+                  IDENT@[144; 147) "idx"
+              COLON@[147; 148)
+              WHITESPACE@[148; 149)
+              REFERENCE_TYPE@[149; 159)
+                AMP@[149; 150)
+                MUT_KW@[150; 153)
+                WHITESPACE@[153; 154)
+                PATH_TYPE@[154; 159)
+                  PATH@[154; 159)
+                    PATH_SEGMENT@[154; 159)
+                      NAME_REF@[154; 159)
+                        IDENT@[154; 159) "usize"
+            COMMA@[159; 160)
+            WHITESPACE@[160; 161)
+            PARAM@[161; 167)
+              REF_PAT@[161; 167)
+                AMP@[161; 162)
+                MUT_KW@[162; 165)
+                WHITESPACE@[165; 166)
+                err: `expected pattern`
+                ERROR@[166; 167)
+                  PIPE@[166; 167)
+                  err: `expected COMMA`
+            WHITESPACE@[167; 168)
+            err: `expected pattern`
+            PARAM@[168; 169)
+              ERROR@[168; 169)
+                L_CURLY@[168; 169)
+                err: `expected COMMA`
+            WHITESPACE@[169; 178)
+            err: `expected pattern`
+            PARAM@[178; 183)
+              ERROR@[178; 183)
+                WHILE_KW@[178; 183)
+                err: `expected COMMA`
+            WHITESPACE@[183; 184)
+            err: `expected pattern`
+            PARAM@[184; 187)
+              ERROR@[184; 187)
+                LET_KW@[184; 187)
+                err: `expected COMMA`
+            WHITESPACE@[187; 188)
+            PARAM@[188; 199)
+              TUPLE_STRUCT_PAT@[188; 199)
+                PATH@[188; 192)
+                  PATH_SEGMENT@[188; 192)
+                    NAME_REF@[188; 192)
+                      IDENT@[188; 192) "Some"
+                L_PAREN@[192; 193)
+                BIND_PAT@[193; 198)
+                  NAME@[193; 198)
+                    IDENT@[193; 198) "token"
+                R_PAREN@[198; 199)
+                err: `expected COMMA`
+            WHITESPACE@[199; 200)
+            err: `expected pattern`
+            PARAM@[200; 201)
+              ERROR@[200; 201)
+                EQ@[200; 201)
+                err: `expected COMMA`
+            WHITESPACE@[201; 202)
+            PARAM@[202; 208)
+              BIND_PAT@[202; 208)
+                NAME@[202; 208)
+                  IDENT@[202; 208) "tokens"
+                  err: `expected COMMA`
+                  err: `expected pattern`
+            PARAM@[208; 209)
+              ERROR@[208; 209)
+                DOT@[208; 209)
+                err: `expected COMMA`
+            PARAM@[209; 218)
+              TUPLE_STRUCT_PAT@[209; 218)
+                PATH@[209; 212)
+                  PATH_SEGMENT@[209; 212)
+                    NAME_REF@[209; 212)
+                      IDENT@[209; 212) "get"
+                L_PAREN@[212; 213)
+                err: `expected pattern`
+                ERROR@[213; 214)
+                  STAR@[213; 214)
+                  err: `expected COMMA`
+                BIND_PAT@[214; 217)
+                  NAME@[214; 217)
+                    IDENT@[214; 217) "idx"
+                R_PAREN@[217; 218)
+                err: `expected COMMA`
+            WHITESPACE@[218; 219)
+            err: `expected pattern`
+            PARAM@[219; 220)
+              ERROR@[219; 220)
+                L_CURLY@[219; 220)
+                err: `expected COMMA`
+            WHITESPACE@[220; 233)
+            err: `expected pattern`
+            PARAM@[233; 235)
+              ERROR@[233; 235)
+                IF_KW@[233; 235)
+                err: `expected COMMA`
+            WHITESPACE@[235; 236)
+            err: `expected pattern`
+            PARAM@[236; 237)
+              ERROR@[236; 237)
+                EXCL@[236; 237)
+                err: `expected COMMA`
+            PARAM@[237; 242)
+              BIND_PAT@[237; 242)
+                NAME@[237; 242)
+                  IDENT@[237; 242) "token"
+                  err: `expected COMMA`
+                  err: `expected pattern`
+            PARAM@[242; 243)
+              ERROR@[242; 243)
+                DOT@[242; 243)
+                err: `expected COMMA`
+            PARAM@[243; 247)
+              BIND_PAT@[243; 247)
+                NAME@[243; 247)
+                  IDENT@[243; 247) "kind"
+                  err: `expected COMMA`
+                  err: `expected pattern`
+            PARAM@[247; 248)
+              ERROR@[247; 248)
+                DOT@[247; 248)
+                err: `expected COMMA`
+            PARAM@[248; 259)
+              TUPLE_STRUCT_PAT@[248; 259)
+                PATH@[248; 257)
+                  PATH_SEGMENT@[248; 257)
+                    NAME_REF@[248; 257)
+                      IDENT@[248; 257) "is_trivia"
+                L_PAREN@[257; 258)
+                R_PAREN@[258; 259)
+                err: `expected COMMA`
+            WHITESPACE@[259; 260)
+            err: `expected pattern`
+            PARAM@[260; 261)
+              ERROR@[260; 261)
+                L_CURLY@[260; 261)
+                err: `expected COMMA`
+            WHITESPACE@[261; 278)
+            PARAM@[278; 283)
+              BIND_PAT@[278; 283)
+                NAME@[278; 283)
+                  IDENT@[278; 283) "break"
+                  err: `expected COMMA`
+                  err: `expected pattern`
+            PARAM@[283; 284)
+              ERROR@[283; 284)
+                SEMI@[283; 284)
+                err: `expected COMMA`
+            WHITESPACE@[284; 297)
+            err: `expected pattern`
+            PARAM@[297; 298)
+              ERROR@[297; 298)
+                R_CURLY@[297; 298)
+                err: `expected COMMA`
+            WHITESPACE@[298; 311)
+            PARAM@[311; 318)
+              BIND_PAT@[311; 318)
+                NAME@[311; 318)
+                  IDENT@[311; 318) "builder"
+                  err: `expected COMMA`
+                  err: `expected pattern`
+            PARAM@[318; 319)
+              ERROR@[318; 319)
+                DOT@[318; 319)
+                err: `expected COMMA`
+            PARAM@[319; 346)
+              TUPLE_STRUCT_PAT@[319; 346)
+                PATH@[319; 323)
+                  PATH_SEGMENT@[319; 323)
+                    NAME_REF@[319; 323)
+                      IDENT@[319; 323) "leaf"
+                L_PAREN@[323; 324)
+                BIND_PAT@[324; 329)
+                  NAME@[324; 329)
+                    IDENT@[324; 329) "token"
+                    err: `expected COMMA`
+                    err: `expected pattern`
+                ERROR@[329; 330)
+                  DOT@[329; 330)
+                  err: `expected COMMA`
+                BIND_PAT@[330; 334)
+                  NAME@[330; 334)
+                    IDENT@[330; 334) "kind"
+                COMMA@[334; 335)
+                WHITESPACE@[335; 336)
+                BIND_PAT@[336; 341)
+                  NAME@[336; 341)
+                    IDENT@[336; 341) "token"
+                    err: `expected COMMA`
+                    err: `expected pattern`
+                ERROR@[341; 342)
+                  DOT@[341; 342)
+                  err: `expected COMMA`
+                BIND_PAT@[342; 345)
+                  NAME@[342; 345)
+                    IDENT@[342; 345) "len"
+                R_PAREN@[345; 346)
+                err: `expected COMMA`
+                err: `expected pattern`
+            PARAM@[346; 347)
+              ERROR@[346; 347)
+                SEMI@[346; 347)
+                err: `expected COMMA`
+            WHITESPACE@[347; 360)
+            err: `expected pattern`
+            PARAM@[360; 361)
+              ERROR@[360; 361)
+                STAR@[360; 361)
+                err: `expected COMMA`
+            PARAM@[361; 364)
+              BIND_PAT@[361; 364)
+                NAME@[361; 364)
+                  IDENT@[361; 364) "idx"
+                  err: `expected COMMA`
+            WHITESPACE@[364; 365)
+            err: `expected pattern`
+            PARAM@[365; 366)
+              ERROR@[365; 366)
+                PLUS@[365; 366)
+                err: `expected COMMA`
+                err: `expected pattern`
+            PARAM@[366; 367)
+              ERROR@[366; 367)
+                EQ@[366; 367)
+                err: `expected COMMA`
+            WHITESPACE@[367; 368)
+            PARAM@[368; 369)
+              LITERAL@[368; 369)
+                INT_NUMBER@[368; 369) "1"
+                err: `expected COMMA`
+            WHITESPACE@[369; 378)
+            err: `expected pattern`
+            PARAM@[378; 379)
+              ERROR@[378; 379)
+                R_CURLY@[378; 379)
+                err: `expected COMMA`
+            WHITESPACE@[379; 384)
+            err: `expected pattern`
+            PARAM@[384; 385)
+              ERROR@[384; 385)
+                R_CURLY@[384; 385)
+                err: `expected COMMA`
+                err: `expected pattern`
+            PARAM@[385; 386)
+              ERROR@[385; 386)
+                SEMI@[385; 386)
+                err: `expected COMMA`
+            WHITESPACE@[386; 387)
+            err: `expected pattern`
+            PARAM@[387; 388)
+              ERROR@[387; 388)
+                R_CURLY@[387; 388)
+                err: `expected COMMA`
+                err: `expected PIPE`
+          WHITESPACE@[388; 389)
+          err: `expected expression`
+          err: `expected SEMI`
+          err: `expected R_CURLY`
+          ERROR@[389; 389)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0001_const_unsafe_fn.rs b/crates/libsyntax2/tests/data/parser/inline/0001_const_unsafe_fn.rs
new file mode 100644
index 000000000..31a1e435f
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0001_const_unsafe_fn.rs
@@ -0,0 +1 @@
+const unsafe fn foo() {}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0001_const_unsafe_fn.txt b/crates/libsyntax2/tests/data/parser/inline/0001_const_unsafe_fn.txt
new file mode 100644
index 000000000..3932d033c
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0001_const_unsafe_fn.txt
@@ -0,0 +1,18 @@
+FILE@[0; 25)
+  FUNCTION@[0; 24)
+    CONST_KW@[0; 5)
+    WHITESPACE@[5; 6)
+    UNSAFE_KW@[6; 12)
+    WHITESPACE@[12; 13)
+    FN_KW@[13; 15)
+    WHITESPACE@[15; 16)
+    NAME@[16; 19)
+      IDENT@[16; 19) "foo"
+    PARAM_LIST@[19; 21)
+      L_PAREN@[19; 20)
+      R_PAREN@[20; 21)
+    WHITESPACE@[21; 22)
+    BLOCK_EXPR@[22; 24)
+      L_CURLY@[22; 23)
+      R_CURLY@[23; 24)
+  WHITESPACE@[24; 25)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0002_const_fn.rs b/crates/libsyntax2/tests/data/parser/inline/0002_const_fn.rs
new file mode 100644
index 000000000..8c84d9cd7
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0002_const_fn.rs
@@ -0,0 +1 @@
+const fn foo() {}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0002_const_fn.txt b/crates/libsyntax2/tests/data/parser/inline/0002_const_fn.txt
new file mode 100644
index 000000000..bc72ab235
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0002_const_fn.txt
@@ -0,0 +1,16 @@
+FILE@[0; 18)
+  FUNCTION@[0; 17)
+    CONST_KW@[0; 5)
+    WHITESPACE@[5; 6)
+    FN_KW@[6; 8)
+    WHITESPACE@[8; 9)
+    NAME@[9; 12)
+      IDENT@[9; 12) "foo"
+    PARAM_LIST@[12; 14)
+      L_PAREN@[12; 13)
+      R_PAREN@[13; 14)
+    WHITESPACE@[14; 15)
+    BLOCK_EXPR@[15; 17)
+      L_CURLY@[15; 16)
+      R_CURLY@[16; 17)
+  WHITESPACE@[17; 18)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0003_extern_block.rs b/crates/libsyntax2/tests/data/parser/inline/0003_extern_block.rs
new file mode 100644
index 000000000..26a9ccd1e
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0003_extern_block.rs
@@ -0,0 +1 @@
+extern {}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0003_extern_block.txt b/crates/libsyntax2/tests/data/parser/inline/0003_extern_block.txt
new file mode 100644
index 000000000..cbe9a1ebc
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0003_extern_block.txt
@@ -0,0 +1,8 @@
+FILE@[0; 10)
+  EXTERN_BLOCK_EXPR@[0; 9)
+    ABI@[0; 6)
+      EXTERN_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    L_CURLY@[7; 8)
+    R_CURLY@[8; 9)
+  WHITESPACE@[9; 10)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0004_extern_fn.rs b/crates/libsyntax2/tests/data/parser/inline/0004_extern_fn.rs
new file mode 100644
index 000000000..394a049f0
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0004_extern_fn.rs
@@ -0,0 +1 @@
+extern fn foo() {}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0004_extern_fn.txt b/crates/libsyntax2/tests/data/parser/inline/0004_extern_fn.txt
new file mode 100644
index 000000000..e7787d4ab
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0004_extern_fn.txt
@@ -0,0 +1,17 @@
+FILE@[0; 19)
+  FUNCTION@[0; 18)
+    ABI@[0; 6)
+      EXTERN_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    FN_KW@[7; 9)
+    WHITESPACE@[9; 10)
+    NAME@[10; 13)
+      IDENT@[10; 13) "foo"
+    PARAM_LIST@[13; 15)
+      L_PAREN@[13; 14)
+      R_PAREN@[14; 15)
+    WHITESPACE@[15; 16)
+    BLOCK_EXPR@[16; 18)
+      L_CURLY@[16; 17)
+      R_CURLY@[17; 18)
+  WHITESPACE@[18; 19)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0005_extern_crate.rs b/crates/libsyntax2/tests/data/parser/inline/0005_extern_crate.rs
new file mode 100644
index 000000000..49af74e1b
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0005_extern_crate.rs
@@ -0,0 +1 @@
+extern crate foo;
diff --git a/crates/libsyntax2/tests/data/parser/inline/0005_extern_crate.txt b/crates/libsyntax2/tests/data/parser/inline/0005_extern_crate.txt
new file mode 100644
index 000000000..eac8656ac
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0005_extern_crate.txt
@@ -0,0 +1,10 @@
+FILE@[0; 18)
+  EXTERN_CRATE_ITEM@[0; 17)
+    EXTERN_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    CRATE_KW@[7; 12)
+    WHITESPACE@[12; 13)
+    NAME@[13; 16)
+      IDENT@[13; 16) "foo"
+    SEMI@[16; 17)
+  WHITESPACE@[17; 18)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0007_unsafe_trait.rs b/crates/libsyntax2/tests/data/parser/inline/0007_unsafe_trait.rs
new file mode 100644
index 000000000..04e021550
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0007_unsafe_trait.rs
@@ -0,0 +1 @@
+unsafe trait T {}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0007_unsafe_trait.txt b/crates/libsyntax2/tests/data/parser/inline/0007_unsafe_trait.txt
new file mode 100644
index 000000000..afa6637d3
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0007_unsafe_trait.txt
@@ -0,0 +1,12 @@
+FILE@[0; 18)
+  TRAIT_ITEM@[0; 17)
+    UNSAFE_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    TRAIT_KW@[7; 12)
+    WHITESPACE@[12; 13)
+    NAME@[13; 14)
+      IDENT@[13; 14) "T"
+    WHITESPACE@[14; 15)
+    L_CURLY@[15; 16)
+    R_CURLY@[16; 17)
+  WHITESPACE@[17; 18)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0008_unsafe_impl.rs b/crates/libsyntax2/tests/data/parser/inline/0008_unsafe_impl.rs
new file mode 100644
index 000000000..41055f41d
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0008_unsafe_impl.rs
@@ -0,0 +1 @@
+unsafe impl Foo {}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0008_unsafe_impl.txt b/crates/libsyntax2/tests/data/parser/inline/0008_unsafe_impl.txt
new file mode 100644
index 000000000..6fd3f868f
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0008_unsafe_impl.txt
@@ -0,0 +1,15 @@
+FILE@[0; 19)
+  IMPL_ITEM@[0; 18)
+    UNSAFE_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    IMPL_KW@[7; 11)
+    WHITESPACE@[11; 12)
+    PATH_TYPE@[12; 15)
+      PATH@[12; 15)
+        PATH_SEGMENT@[12; 15)
+          NAME_REF@[12; 15)
+            IDENT@[12; 15) "Foo"
+    WHITESPACE@[15; 16)
+    L_CURLY@[16; 17)
+    R_CURLY@[17; 18)
+  WHITESPACE@[18; 19)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0009_unsafe_auto_trait.rs b/crates/libsyntax2/tests/data/parser/inline/0009_unsafe_auto_trait.rs
new file mode 100644
index 000000000..03d29f324
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0009_unsafe_auto_trait.rs
@@ -0,0 +1 @@
+unsafe auto trait T {}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0009_unsafe_auto_trait.txt b/crates/libsyntax2/tests/data/parser/inline/0009_unsafe_auto_trait.txt
new file mode 100644
index 000000000..825a56f17
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0009_unsafe_auto_trait.txt
@@ -0,0 +1,14 @@
+FILE@[0; 23)
+  TRAIT_ITEM@[0; 22)
+    UNSAFE_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    AUTO_KW@[7; 11)
+    WHITESPACE@[11; 12)
+    TRAIT_KW@[12; 17)
+    WHITESPACE@[17; 18)
+    NAME@[18; 19)
+      IDENT@[18; 19) "T"
+    WHITESPACE@[19; 20)
+    L_CURLY@[20; 21)
+    R_CURLY@[21; 22)
+  WHITESPACE@[22; 23)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0010_unsafe_default_impl.rs b/crates/libsyntax2/tests/data/parser/inline/0010_unsafe_default_impl.rs
new file mode 100644
index 000000000..9cd6c57bd
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0010_unsafe_default_impl.rs
@@ -0,0 +1 @@
+unsafe default impl Foo {}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0010_unsafe_default_impl.txt b/crates/libsyntax2/tests/data/parser/inline/0010_unsafe_default_impl.txt
new file mode 100644
index 000000000..ab12d5fc0
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0010_unsafe_default_impl.txt
@@ -0,0 +1,17 @@
+FILE@[0; 27)
+  IMPL_ITEM@[0; 26)
+    UNSAFE_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    DEFAULT_KW@[7; 14)
+    WHITESPACE@[14; 15)
+    IMPL_KW@[15; 19)
+    WHITESPACE@[19; 20)
+    PATH_TYPE@[20; 23)
+      PATH@[20; 23)
+        PATH_SEGMENT@[20; 23)
+          NAME_REF@[20; 23)
+            IDENT@[20; 23) "Foo"
+    WHITESPACE@[23; 24)
+    L_CURLY@[24; 25)
+    R_CURLY@[25; 26)
+  WHITESPACE@[26; 27)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0011_unsafe_fn.rs b/crates/libsyntax2/tests/data/parser/inline/0011_unsafe_fn.rs
new file mode 100644
index 000000000..33cfc4cd7
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0011_unsafe_fn.rs
@@ -0,0 +1 @@
+unsafe fn foo() {}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0011_unsafe_fn.txt b/crates/libsyntax2/tests/data/parser/inline/0011_unsafe_fn.txt
new file mode 100644
index 000000000..9e5dcafa6
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0011_unsafe_fn.txt
@@ -0,0 +1,16 @@
+FILE@[0; 19)
+  FUNCTION@[0; 18)
+    UNSAFE_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    FN_KW@[7; 9)
+    WHITESPACE@[9; 10)
+    NAME@[10; 13)
+      IDENT@[10; 13) "foo"
+    PARAM_LIST@[13; 15)
+      L_PAREN@[13; 14)
+      R_PAREN@[14; 15)
+    WHITESPACE@[15; 16)
+    BLOCK_EXPR@[16; 18)
+      L_CURLY@[16; 17)
+      R_CURLY@[17; 18)
+  WHITESPACE@[18; 19)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0012_unsafe_extern_fn.rs b/crates/libsyntax2/tests/data/parser/inline/0012_unsafe_extern_fn.rs
new file mode 100644
index 000000000..1295c2cd2
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0012_unsafe_extern_fn.rs
@@ -0,0 +1 @@
+unsafe extern "C" fn foo() {}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0012_unsafe_extern_fn.txt b/crates/libsyntax2/tests/data/parser/inline/0012_unsafe_extern_fn.txt
new file mode 100644
index 000000000..7ed4d42c1
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0012_unsafe_extern_fn.txt
@@ -0,0 +1,21 @@
+FILE@[0; 30)
+  FUNCTION@[0; 29)
+    UNSAFE_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    ABI@[7; 17)
+      EXTERN_KW@[7; 13)
+      WHITESPACE@[13; 14)
+      STRING@[14; 17)
+    WHITESPACE@[17; 18)
+    FN_KW@[18; 20)
+    WHITESPACE@[20; 21)
+    NAME@[21; 24)
+      IDENT@[21; 24) "foo"
+    PARAM_LIST@[24; 26)
+      L_PAREN@[24; 25)
+      R_PAREN@[25; 26)
+    WHITESPACE@[26; 27)
+    BLOCK_EXPR@[27; 29)
+      L_CURLY@[27; 28)
+      R_CURLY@[28; 29)
+  WHITESPACE@[29; 30)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0013_unsafe_block_in_mod.rs b/crates/libsyntax2/tests/data/parser/inline/0013_unsafe_block_in_mod.rs
new file mode 100644
index 000000000..26141e904
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0013_unsafe_block_in_mod.rs
@@ -0,0 +1 @@
+fn foo(){} unsafe { } fn bar(){}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0013_unsafe_block_in_mod.txt b/crates/libsyntax2/tests/data/parser/inline/0013_unsafe_block_in_mod.txt
new file mode 100644
index 000000000..d1bcffe77
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0013_unsafe_block_in_mod.txt
@@ -0,0 +1,35 @@
+FILE@[0; 33)
+  FUNCTION@[0; 10)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    BLOCK_EXPR@[8; 10)
+      L_CURLY@[8; 9)
+      R_CURLY@[9; 10)
+  WHITESPACE@[10; 11)
+  err: `expected an item`
+  ERROR@[11; 17)
+    UNSAFE_KW@[11; 17)
+  WHITESPACE@[17; 18)
+  err: `expected an item`
+  ERROR@[18; 21)
+    L_CURLY@[18; 19)
+    WHITESPACE@[19; 20)
+    R_CURLY@[20; 21)
+  WHITESPACE@[21; 22)
+  FUNCTION@[22; 32)
+    FN_KW@[22; 24)
+    WHITESPACE@[24; 25)
+    NAME@[25; 28)
+      IDENT@[25; 28) "bar"
+    PARAM_LIST@[28; 30)
+      L_PAREN@[28; 29)
+      R_PAREN@[29; 30)
+    BLOCK_EXPR@[30; 32)
+      L_CURLY@[30; 31)
+      R_CURLY@[31; 32)
+  WHITESPACE@[32; 33)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0014_type_item_type_params.rs b/crates/libsyntax2/tests/data/parser/inline/0014_type_item_type_params.rs
new file mode 100644
index 000000000..defd110c4
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0014_type_item_type_params.rs
@@ -0,0 +1 @@
+type Result<T> = ();
diff --git a/crates/libsyntax2/tests/data/parser/inline/0014_type_item_type_params.txt b/crates/libsyntax2/tests/data/parser/inline/0014_type_item_type_params.txt
new file mode 100644
index 000000000..e39e57889
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0014_type_item_type_params.txt
@@ -0,0 +1,20 @@
+FILE@[0; 21)
+  TYPE_ITEM@[0; 20)
+    TYPE_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 11)
+      IDENT@[5; 11) "Result"
+    TYPE_PARAM_LIST@[11; 14)
+      L_ANGLE@[11; 12)
+      TYPE_PARAM@[12; 13)
+        NAME@[12; 13)
+          IDENT@[12; 13) "T"
+      R_ANGLE@[13; 14)
+    WHITESPACE@[14; 15)
+    EQ@[15; 16)
+    WHITESPACE@[16; 17)
+    TUPLE_TYPE@[17; 19)
+      L_PAREN@[17; 18)
+      R_PAREN@[18; 19)
+    SEMI@[19; 20)
+  WHITESPACE@[20; 21)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0015_type_item.rs b/crates/libsyntax2/tests/data/parser/inline/0015_type_item.rs
new file mode 100644
index 000000000..04c0344fa
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0015_type_item.rs
@@ -0,0 +1 @@
+type Foo = Bar;
diff --git a/crates/libsyntax2/tests/data/parser/inline/0015_type_item.txt b/crates/libsyntax2/tests/data/parser/inline/0015_type_item.txt
new file mode 100644
index 000000000..964071aa1
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0015_type_item.txt
@@ -0,0 +1,16 @@
+FILE@[0; 16)
+  TYPE_ITEM@[0; 15)
+    TYPE_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 8)
+      IDENT@[5; 8) "Foo"
+    WHITESPACE@[8; 9)
+    EQ@[9; 10)
+    WHITESPACE@[10; 11)
+    PATH_TYPE@[11; 14)
+      PATH@[11; 14)
+        PATH_SEGMENT@[11; 14)
+          NAME_REF@[11; 14)
+            IDENT@[11; 14) "Bar"
+    SEMI@[14; 15)
+  WHITESPACE@[15; 16)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0016_type_item_where_clause.rs b/crates/libsyntax2/tests/data/parser/inline/0016_type_item_where_clause.rs
new file mode 100644
index 000000000..a602d07f0
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0016_type_item_where_clause.rs
@@ -0,0 +1 @@
+type Foo where Foo: Copy = ();
diff --git a/crates/libsyntax2/tests/data/parser/inline/0016_type_item_where_clause.txt b/crates/libsyntax2/tests/data/parser/inline/0016_type_item_where_clause.txt
new file mode 100644
index 000000000..2f3c52960
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0016_type_item_where_clause.txt
@@ -0,0 +1,31 @@
+FILE@[0; 31)
+  TYPE_ITEM@[0; 30)
+    TYPE_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 8)
+      IDENT@[5; 8) "Foo"
+    WHITESPACE@[8; 9)
+    WHERE_CLAUSE@[9; 24)
+      WHERE_KW@[9; 14)
+      WHITESPACE@[14; 15)
+      WHERE_PRED@[15; 24)
+        PATH_TYPE@[15; 18)
+          PATH@[15; 18)
+            PATH_SEGMENT@[15; 18)
+              NAME_REF@[15; 18)
+                IDENT@[15; 18) "Foo"
+        COLON@[18; 19)
+        WHITESPACE@[19; 20)
+        PATH@[20; 24)
+          PATH_SEGMENT@[20; 24)
+            NAME_REF@[20; 24)
+              IDENT@[20; 24) "Copy"
+              err: `expected COMMA`
+    WHITESPACE@[24; 25)
+    EQ@[25; 26)
+    WHITESPACE@[26; 27)
+    TUPLE_TYPE@[27; 29)
+      L_PAREN@[27; 28)
+      R_PAREN@[28; 29)
+    SEMI@[29; 30)
+  WHITESPACE@[30; 31)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0017_paren_type.rs b/crates/libsyntax2/tests/data/parser/inline/0017_paren_type.rs
new file mode 100644
index 000000000..6e1b25101
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0017_paren_type.rs
@@ -0,0 +1 @@
+type T = (i32);
diff --git a/crates/libsyntax2/tests/data/parser/inline/0017_paren_type.txt b/crates/libsyntax2/tests/data/parser/inline/0017_paren_type.txt
new file mode 100644
index 000000000..1194fb02c
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0017_paren_type.txt
@@ -0,0 +1,19 @@
+FILE@[0; 16)
+  TYPE_ITEM@[0; 15)
+    TYPE_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 6)
+      IDENT@[5; 6) "T"
+    WHITESPACE@[6; 7)
+    EQ@[7; 8)
+    WHITESPACE@[8; 9)
+    PAREN_TYPE@[9; 14)
+      L_PAREN@[9; 10)
+      PATH_TYPE@[10; 13)
+        PATH@[10; 13)
+          PATH_SEGMENT@[10; 13)
+            NAME_REF@[10; 13)
+              IDENT@[10; 13) "i32"
+      R_PAREN@[13; 14)
+    SEMI@[14; 15)
+  WHITESPACE@[15; 16)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0018_unit_type.rs b/crates/libsyntax2/tests/data/parser/inline/0018_unit_type.rs
new file mode 100644
index 000000000..c039cf7d3
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0018_unit_type.rs
@@ -0,0 +1 @@
+type T = ();
diff --git a/crates/libsyntax2/tests/data/parser/inline/0018_unit_type.txt b/crates/libsyntax2/tests/data/parser/inline/0018_unit_type.txt
new file mode 100644
index 000000000..e52af7b1e
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0018_unit_type.txt
@@ -0,0 +1,14 @@
+FILE@[0; 13)
+  TYPE_ITEM@[0; 12)
+    TYPE_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 6)
+      IDENT@[5; 6) "T"
+    WHITESPACE@[6; 7)
+    EQ@[7; 8)
+    WHITESPACE@[8; 9)
+    TUPLE_TYPE@[9; 11)
+      L_PAREN@[9; 10)
+      R_PAREN@[10; 11)
+    SEMI@[11; 12)
+  WHITESPACE@[12; 13)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0019_singleton_tuple_type.rs b/crates/libsyntax2/tests/data/parser/inline/0019_singleton_tuple_type.rs
new file mode 100644
index 000000000..cb66bad24
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0019_singleton_tuple_type.rs
@@ -0,0 +1 @@
+type T = (i32,);
diff --git a/crates/libsyntax2/tests/data/parser/inline/0019_singleton_tuple_type.txt b/crates/libsyntax2/tests/data/parser/inline/0019_singleton_tuple_type.txt
new file mode 100644
index 000000000..7b8e06c25
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0019_singleton_tuple_type.txt
@@ -0,0 +1,20 @@
+FILE@[0; 17)
+  TYPE_ITEM@[0; 16)
+    TYPE_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 6)
+      IDENT@[5; 6) "T"
+    WHITESPACE@[6; 7)
+    EQ@[7; 8)
+    WHITESPACE@[8; 9)
+    TUPLE_TYPE@[9; 15)
+      L_PAREN@[9; 10)
+      PATH_TYPE@[10; 13)
+        PATH@[10; 13)
+          PATH_SEGMENT@[10; 13)
+            NAME_REF@[10; 13)
+              IDENT@[10; 13) "i32"
+      COMMA@[13; 14)
+      R_PAREN@[14; 15)
+    SEMI@[15; 16)
+  WHITESPACE@[16; 17)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0020_never_type.rs b/crates/libsyntax2/tests/data/parser/inline/0020_never_type.rs
new file mode 100644
index 000000000..de399fcf4
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0020_never_type.rs
@@ -0,0 +1 @@
+type Never = !;
diff --git a/crates/libsyntax2/tests/data/parser/inline/0020_never_type.txt b/crates/libsyntax2/tests/data/parser/inline/0020_never_type.txt
new file mode 100644
index 000000000..89f8a9eea
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0020_never_type.txt
@@ -0,0 +1,13 @@
+FILE@[0; 16)
+  TYPE_ITEM@[0; 15)
+    TYPE_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 10)
+      IDENT@[5; 10) "Never"
+    WHITESPACE@[10; 11)
+    EQ@[11; 12)
+    WHITESPACE@[12; 13)
+    NEVER_TYPE@[13; 14)
+      EXCL@[13; 14)
+    SEMI@[14; 15)
+  WHITESPACE@[15; 16)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0021_pointer_type_no_mutability.rs b/crates/libsyntax2/tests/data/parser/inline/0021_pointer_type_no_mutability.rs
new file mode 100644
index 000000000..fae705131
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0021_pointer_type_no_mutability.rs
@@ -0,0 +1 @@
+type T = *();
diff --git a/crates/libsyntax2/tests/data/parser/inline/0021_pointer_type_no_mutability.txt b/crates/libsyntax2/tests/data/parser/inline/0021_pointer_type_no_mutability.txt
new file mode 100644
index 000000000..d86fc6388
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0021_pointer_type_no_mutability.txt
@@ -0,0 +1,17 @@
+FILE@[0; 14)
+  TYPE_ITEM@[0; 13)
+    TYPE_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 6)
+      IDENT@[5; 6) "T"
+    WHITESPACE@[6; 7)
+    EQ@[7; 8)
+    WHITESPACE@[8; 9)
+    POINTER_TYPE@[9; 12)
+      STAR@[9; 10)
+      err: `expected mut or const in raw pointer type (use `*mut T` or `*const T` as appropriate)`
+      TUPLE_TYPE@[10; 12)
+        L_PAREN@[10; 11)
+        R_PAREN@[11; 12)
+    SEMI@[12; 13)
+  WHITESPACE@[13; 14)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0022_pointer_type_mut.rs b/crates/libsyntax2/tests/data/parser/inline/0022_pointer_type_mut.rs
new file mode 100644
index 000000000..04b2bb9ba
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0022_pointer_type_mut.rs
@@ -0,0 +1,2 @@
+type M = *mut ();
+type C = *mut ();
diff --git a/crates/libsyntax2/tests/data/parser/inline/0022_pointer_type_mut.txt b/crates/libsyntax2/tests/data/parser/inline/0022_pointer_type_mut.txt
new file mode 100644
index 000000000..fbeba506e
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0022_pointer_type_mut.txt
@@ -0,0 +1,35 @@
+FILE@[0; 36)
+  TYPE_ITEM@[0; 17)
+    TYPE_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 6)
+      IDENT@[5; 6) "M"
+    WHITESPACE@[6; 7)
+    EQ@[7; 8)
+    WHITESPACE@[8; 9)
+    POINTER_TYPE@[9; 16)
+      STAR@[9; 10)
+      MUT_KW@[10; 13)
+      WHITESPACE@[13; 14)
+      TUPLE_TYPE@[14; 16)
+        L_PAREN@[14; 15)
+        R_PAREN@[15; 16)
+    SEMI@[16; 17)
+  WHITESPACE@[17; 18)
+  TYPE_ITEM@[18; 35)
+    TYPE_KW@[18; 22)
+    WHITESPACE@[22; 23)
+    NAME@[23; 24)
+      IDENT@[23; 24) "C"
+    WHITESPACE@[24; 25)
+    EQ@[25; 26)
+    WHITESPACE@[26; 27)
+    POINTER_TYPE@[27; 34)
+      STAR@[27; 28)
+      MUT_KW@[28; 31)
+      WHITESPACE@[31; 32)
+      TUPLE_TYPE@[32; 34)
+        L_PAREN@[32; 33)
+        R_PAREN@[33; 34)
+    SEMI@[34; 35)
+  WHITESPACE@[35; 36)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0023_array_type_missing_semi.rs b/crates/libsyntax2/tests/data/parser/inline/0023_array_type_missing_semi.rs
new file mode 100644
index 000000000..a94851443
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0023_array_type_missing_semi.rs
@@ -0,0 +1 @@
+type T = [() 92];
diff --git a/crates/libsyntax2/tests/data/parser/inline/0023_array_type_missing_semi.txt b/crates/libsyntax2/tests/data/parser/inline/0023_array_type_missing_semi.txt
new file mode 100644
index 000000000..4d90d52c7
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0023_array_type_missing_semi.txt
@@ -0,0 +1,27 @@
+FILE@[0; 18)
+  TYPE_ITEM@[0; 12)
+    TYPE_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 6)
+      IDENT@[5; 6) "T"
+    WHITESPACE@[6; 7)
+    EQ@[7; 8)
+    WHITESPACE@[8; 9)
+    SLICE_TYPE@[9; 12)
+      L_BRACK@[9; 10)
+      TUPLE_TYPE@[10; 12)
+        L_PAREN@[10; 11)
+        R_PAREN@[11; 12)
+        err: `expected `;` or `]``
+        err: `expected SEMI`
+  WHITESPACE@[12; 13)
+  err: `expected an item`
+  ERROR@[13; 15)
+    INT_NUMBER@[13; 15) "92"
+    err: `expected an item`
+  ERROR@[15; 16)
+    R_BRACK@[15; 16)
+    err: `expected an item`
+  ERROR@[16; 17)
+    SEMI@[16; 17)
+  WHITESPACE@[17; 18)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0024_array_type.rs b/crates/libsyntax2/tests/data/parser/inline/0024_array_type.rs
new file mode 100644
index 000000000..27eb22f22
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0024_array_type.rs
@@ -0,0 +1 @@
+type T = [(); 92];
diff --git a/crates/libsyntax2/tests/data/parser/inline/0024_array_type.txt b/crates/libsyntax2/tests/data/parser/inline/0024_array_type.txt
new file mode 100644
index 000000000..5a6b76904
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0024_array_type.txt
@@ -0,0 +1,21 @@
+FILE@[0; 19)
+  TYPE_ITEM@[0; 18)
+    TYPE_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 6)
+      IDENT@[5; 6) "T"
+    WHITESPACE@[6; 7)
+    EQ@[7; 8)
+    WHITESPACE@[8; 9)
+    ARRAY_TYPE@[9; 17)
+      L_BRACK@[9; 10)
+      TUPLE_TYPE@[10; 12)
+        L_PAREN@[10; 11)
+        R_PAREN@[11; 12)
+      SEMI@[12; 13)
+      WHITESPACE@[13; 14)
+      LITERAL@[14; 16)
+        INT_NUMBER@[14; 16) "92"
+      R_BRACK@[16; 17)
+    SEMI@[17; 18)
+  WHITESPACE@[18; 19)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0025_slice_type.rs b/crates/libsyntax2/tests/data/parser/inline/0025_slice_type.rs
new file mode 100644
index 000000000..4da1af827
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0025_slice_type.rs
@@ -0,0 +1 @@
+type T = [()];
diff --git a/crates/libsyntax2/tests/data/parser/inline/0025_slice_type.txt b/crates/libsyntax2/tests/data/parser/inline/0025_slice_type.txt
new file mode 100644
index 000000000..52508cda4
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0025_slice_type.txt
@@ -0,0 +1,17 @@
+FILE@[0; 15)
+  TYPE_ITEM@[0; 14)
+    TYPE_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 6)
+      IDENT@[5; 6) "T"
+    WHITESPACE@[6; 7)
+    EQ@[7; 8)
+    WHITESPACE@[8; 9)
+    SLICE_TYPE@[9; 13)
+      L_BRACK@[9; 10)
+      TUPLE_TYPE@[10; 12)
+        L_PAREN@[10; 11)
+        R_PAREN@[11; 12)
+      R_BRACK@[12; 13)
+    SEMI@[13; 14)
+  WHITESPACE@[14; 15)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0026_reference_type;.rs b/crates/libsyntax2/tests/data/parser/inline/0026_reference_type;.rs
new file mode 100644
index 000000000..3ac0badab
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0026_reference_type;.rs
@@ -0,0 +1,3 @@
+type A = &();
+type B = &'static ();
+type C = &mut ();
diff --git a/crates/libsyntax2/tests/data/parser/inline/0026_reference_type;.txt b/crates/libsyntax2/tests/data/parser/inline/0026_reference_type;.txt
new file mode 100644
index 000000000..b6bd6a48c
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0026_reference_type;.txt
@@ -0,0 +1,50 @@
+FILE@[0; 54)
+  TYPE_ITEM@[0; 13)
+    TYPE_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 6)
+      IDENT@[5; 6) "A"
+    WHITESPACE@[6; 7)
+    EQ@[7; 8)
+    WHITESPACE@[8; 9)
+    REFERENCE_TYPE@[9; 12)
+      AMP@[9; 10)
+      TUPLE_TYPE@[10; 12)
+        L_PAREN@[10; 11)
+        R_PAREN@[11; 12)
+    SEMI@[12; 13)
+  WHITESPACE@[13; 14)
+  TYPE_ITEM@[14; 35)
+    TYPE_KW@[14; 18)
+    WHITESPACE@[18; 19)
+    NAME@[19; 20)
+      IDENT@[19; 20) "B"
+    WHITESPACE@[20; 21)
+    EQ@[21; 22)
+    WHITESPACE@[22; 23)
+    REFERENCE_TYPE@[23; 34)
+      AMP@[23; 24)
+      LIFETIME@[24; 31) "'static"
+      WHITESPACE@[31; 32)
+      TUPLE_TYPE@[32; 34)
+        L_PAREN@[32; 33)
+        R_PAREN@[33; 34)
+    SEMI@[34; 35)
+  WHITESPACE@[35; 36)
+  TYPE_ITEM@[36; 53)
+    TYPE_KW@[36; 40)
+    WHITESPACE@[40; 41)
+    NAME@[41; 42)
+      IDENT@[41; 42) "C"
+    WHITESPACE@[42; 43)
+    EQ@[43; 44)
+    WHITESPACE@[44; 45)
+    REFERENCE_TYPE@[45; 52)
+      AMP@[45; 46)
+      MUT_KW@[46; 49)
+      WHITESPACE@[49; 50)
+      TUPLE_TYPE@[50; 52)
+        L_PAREN@[50; 51)
+        R_PAREN@[51; 52)
+    SEMI@[52; 53)
+  WHITESPACE@[53; 54)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0027_placeholder_type.rs b/crates/libsyntax2/tests/data/parser/inline/0027_placeholder_type.rs
new file mode 100644
index 000000000..7952dbd57
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0027_placeholder_type.rs
@@ -0,0 +1 @@
+type Placeholder = _;
diff --git a/crates/libsyntax2/tests/data/parser/inline/0027_placeholder_type.txt b/crates/libsyntax2/tests/data/parser/inline/0027_placeholder_type.txt
new file mode 100644
index 000000000..5e6e6c397
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0027_placeholder_type.txt
@@ -0,0 +1,13 @@
+FILE@[0; 22)
+  TYPE_ITEM@[0; 21)
+    TYPE_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 16)
+      IDENT@[5; 16) "Placeholder"
+    WHITESPACE@[16; 17)
+    EQ@[17; 18)
+    WHITESPACE@[18; 19)
+    PLACEHOLDER_TYPE@[19; 20)
+      UNDERSCORE@[19; 20)
+    SEMI@[20; 21)
+  WHITESPACE@[21; 22)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0028_fn_pointer_type.rs b/crates/libsyntax2/tests/data/parser/inline/0028_fn_pointer_type.rs
new file mode 100644
index 000000000..c9bf3bdb4
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0028_fn_pointer_type.rs
@@ -0,0 +1,3 @@
+type A = fn();
+type B = unsafe fn();
+type C = unsafe extern "C" fn();
diff --git a/crates/libsyntax2/tests/data/parser/inline/0028_fn_pointer_type.txt b/crates/libsyntax2/tests/data/parser/inline/0028_fn_pointer_type.txt
new file mode 100644
index 000000000..31818365a
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0028_fn_pointer_type.txt
@@ -0,0 +1,55 @@
+FILE@[0; 70)
+  TYPE_ITEM@[0; 14)
+    TYPE_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 6)
+      IDENT@[5; 6) "A"
+    WHITESPACE@[6; 7)
+    EQ@[7; 8)
+    WHITESPACE@[8; 9)
+    FN_POINTER_TYPE@[9; 13)
+      FN_KW@[9; 11)
+      PARAM_LIST@[11; 13)
+        L_PAREN@[11; 12)
+        R_PAREN@[12; 13)
+    SEMI@[13; 14)
+  WHITESPACE@[14; 15)
+  TYPE_ITEM@[15; 36)
+    TYPE_KW@[15; 19)
+    WHITESPACE@[19; 20)
+    NAME@[20; 21)
+      IDENT@[20; 21) "B"
+    WHITESPACE@[21; 22)
+    EQ@[22; 23)
+    WHITESPACE@[23; 24)
+    FN_POINTER_TYPE@[24; 35)
+      UNSAFE_KW@[24; 30)
+      WHITESPACE@[30; 31)
+      FN_KW@[31; 33)
+      PARAM_LIST@[33; 35)
+        L_PAREN@[33; 34)
+        R_PAREN@[34; 35)
+    SEMI@[35; 36)
+  WHITESPACE@[36; 37)
+  TYPE_ITEM@[37; 69)
+    TYPE_KW@[37; 41)
+    WHITESPACE@[41; 42)
+    NAME@[42; 43)
+      IDENT@[42; 43) "C"
+    WHITESPACE@[43; 44)
+    EQ@[44; 45)
+    WHITESPACE@[45; 46)
+    FN_POINTER_TYPE@[46; 68)
+      UNSAFE_KW@[46; 52)
+      WHITESPACE@[52; 53)
+      ABI@[53; 63)
+        EXTERN_KW@[53; 59)
+        WHITESPACE@[59; 60)
+        STRING@[60; 63)
+      WHITESPACE@[63; 64)
+      FN_KW@[64; 66)
+      PARAM_LIST@[66; 68)
+        L_PAREN@[66; 67)
+        R_PAREN@[67; 68)
+    SEMI@[68; 69)
+  WHITESPACE@[69; 70)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0029_fn_pointer_type_missing_fn.rs b/crates/libsyntax2/tests/data/parser/inline/0029_fn_pointer_type_missing_fn.rs
new file mode 100644
index 000000000..f014914ff
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0029_fn_pointer_type_missing_fn.rs
@@ -0,0 +1 @@
+type F = unsafe ();
diff --git a/crates/libsyntax2/tests/data/parser/inline/0029_fn_pointer_type_missing_fn.txt b/crates/libsyntax2/tests/data/parser/inline/0029_fn_pointer_type_missing_fn.txt
new file mode 100644
index 000000000..ddec1b866
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0029_fn_pointer_type_missing_fn.txt
@@ -0,0 +1,23 @@
+FILE@[0; 20)
+  TYPE_ITEM@[0; 15)
+    TYPE_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 6)
+      IDENT@[5; 6) "F"
+    WHITESPACE@[6; 7)
+    EQ@[7; 8)
+    WHITESPACE@[8; 9)
+    UNSAFE_KW@[9; 15)
+    err: `expected `fn``
+    err: `expected SEMI`
+  WHITESPACE@[15; 16)
+  err: `expected an item`
+  ERROR@[16; 17)
+    L_PAREN@[16; 17)
+    err: `expected an item`
+  ERROR@[17; 18)
+    R_PAREN@[17; 18)
+    err: `expected an item`
+  ERROR@[18; 19)
+    SEMI@[18; 19)
+  WHITESPACE@[19; 20)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0030_fn_pointer_type_with_ret.rs b/crates/libsyntax2/tests/data/parser/inline/0030_fn_pointer_type_with_ret.rs
new file mode 100644
index 000000000..e3ba5e87f
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0030_fn_pointer_type_with_ret.rs
@@ -0,0 +1 @@
+type F = fn() -> ();
diff --git a/crates/libsyntax2/tests/data/parser/inline/0030_fn_pointer_type_with_ret.txt b/crates/libsyntax2/tests/data/parser/inline/0030_fn_pointer_type_with_ret.txt
new file mode 100644
index 000000000..447b1ed3f
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0030_fn_pointer_type_with_ret.txt
@@ -0,0 +1,22 @@
+FILE@[0; 21)
+  TYPE_ITEM@[0; 20)
+    TYPE_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 6)
+      IDENT@[5; 6) "F"
+    WHITESPACE@[6; 7)
+    EQ@[7; 8)
+    WHITESPACE@[8; 9)
+    FN_POINTER_TYPE@[9; 19)
+      FN_KW@[9; 11)
+      PARAM_LIST@[11; 13)
+        L_PAREN@[11; 12)
+        R_PAREN@[12; 13)
+      WHITESPACE@[13; 14)
+      THIN_ARROW@[14; 16)
+      WHITESPACE@[16; 17)
+      TUPLE_TYPE@[17; 19)
+        L_PAREN@[17; 18)
+        R_PAREN@[18; 19)
+    SEMI@[19; 20)
+  WHITESPACE@[20; 21)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0031_for_type.rs b/crates/libsyntax2/tests/data/parser/inline/0031_for_type.rs
new file mode 100644
index 000000000..4d6a18c6b
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0031_for_type.rs
@@ -0,0 +1 @@
+type A = for<'a> fn() -> ();
diff --git a/crates/libsyntax2/tests/data/parser/inline/0031_for_type.txt b/crates/libsyntax2/tests/data/parser/inline/0031_for_type.txt
new file mode 100644
index 000000000..65753a702
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0031_for_type.txt
@@ -0,0 +1,30 @@
+FILE@[0; 29)
+  TYPE_ITEM@[0; 28)
+    TYPE_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 6)
+      IDENT@[5; 6) "A"
+    WHITESPACE@[6; 7)
+    EQ@[7; 8)
+    WHITESPACE@[8; 9)
+    FOR_TYPE@[9; 27)
+      FOR_KW@[9; 12)
+      TYPE_PARAM_LIST@[12; 16)
+        L_ANGLE@[12; 13)
+        LIFETIME_PARAM@[13; 15)
+          LIFETIME@[13; 15) "'a"
+        R_ANGLE@[15; 16)
+      WHITESPACE@[16; 17)
+      FN_POINTER_TYPE@[17; 27)
+        FN_KW@[17; 19)
+        PARAM_LIST@[19; 21)
+          L_PAREN@[19; 20)
+          R_PAREN@[20; 21)
+        WHITESPACE@[21; 22)
+        THIN_ARROW@[22; 24)
+        WHITESPACE@[24; 25)
+        TUPLE_TYPE@[25; 27)
+          L_PAREN@[25; 26)
+          R_PAREN@[26; 27)
+    SEMI@[27; 28)
+  WHITESPACE@[28; 29)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0032_path_type.rs b/crates/libsyntax2/tests/data/parser/inline/0032_path_type.rs
new file mode 100644
index 000000000..bf94f32e1
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0032_path_type.rs
@@ -0,0 +1,4 @@
+type A = Foo;
+type B = ::Foo;
+type C = self::Foo;
+type D = super::Foo;
diff --git a/crates/libsyntax2/tests/data/parser/inline/0032_path_type.txt b/crates/libsyntax2/tests/data/parser/inline/0032_path_type.txt
new file mode 100644
index 000000000..d9085118a
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0032_path_type.txt
@@ -0,0 +1,70 @@
+FILE@[0; 71)
+  TYPE_ITEM@[0; 13)
+    TYPE_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 6)
+      IDENT@[5; 6) "A"
+    WHITESPACE@[6; 7)
+    EQ@[7; 8)
+    WHITESPACE@[8; 9)
+    PATH_TYPE@[9; 12)
+      PATH@[9; 12)
+        PATH_SEGMENT@[9; 12)
+          NAME_REF@[9; 12)
+            IDENT@[9; 12) "Foo"
+    SEMI@[12; 13)
+  WHITESPACE@[13; 14)
+  TYPE_ITEM@[14; 29)
+    TYPE_KW@[14; 18)
+    WHITESPACE@[18; 19)
+    NAME@[19; 20)
+      IDENT@[19; 20) "B"
+    WHITESPACE@[20; 21)
+    EQ@[21; 22)
+    WHITESPACE@[22; 23)
+    PATH_TYPE@[23; 28)
+      PATH@[23; 28)
+        PATH_SEGMENT@[23; 28)
+          COLONCOLON@[23; 25)
+          NAME_REF@[25; 28)
+            IDENT@[25; 28) "Foo"
+    SEMI@[28; 29)
+  WHITESPACE@[29; 30)
+  TYPE_ITEM@[30; 49)
+    TYPE_KW@[30; 34)
+    WHITESPACE@[34; 35)
+    NAME@[35; 36)
+      IDENT@[35; 36) "C"
+    WHITESPACE@[36; 37)
+    EQ@[37; 38)
+    WHITESPACE@[38; 39)
+    PATH_TYPE@[39; 48)
+      PATH@[39; 48)
+        PATH@[39; 43)
+          PATH_SEGMENT@[39; 43)
+            SELF_KW@[39; 43)
+        COLONCOLON@[43; 45)
+        PATH_SEGMENT@[45; 48)
+          NAME_REF@[45; 48)
+            IDENT@[45; 48) "Foo"
+    SEMI@[48; 49)
+  WHITESPACE@[49; 50)
+  TYPE_ITEM@[50; 70)
+    TYPE_KW@[50; 54)
+    WHITESPACE@[54; 55)
+    NAME@[55; 56)
+      IDENT@[55; 56) "D"
+    WHITESPACE@[56; 57)
+    EQ@[57; 58)
+    WHITESPACE@[58; 59)
+    PATH_TYPE@[59; 69)
+      PATH@[59; 69)
+        PATH@[59; 64)
+          PATH_SEGMENT@[59; 64)
+            SUPER_KW@[59; 64)
+        COLONCOLON@[64; 66)
+        PATH_SEGMENT@[66; 69)
+          NAME_REF@[66; 69)
+            IDENT@[66; 69) "Foo"
+    SEMI@[69; 70)
+  WHITESPACE@[70; 71)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0034_bind_pat.rs b/crates/libsyntax2/tests/data/parser/inline/0034_bind_pat.rs
new file mode 100644
index 000000000..820a9e72c
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0034_bind_pat.rs
@@ -0,0 +1,8 @@
+fn main() {
+    let a = ();
+    let mut b = ();
+    let ref c = ();
+    let ref mut d = ();
+    let e @ _ = ();
+    let ref mut f @ g @ _ = ();
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0034_bind_pat.txt b/crates/libsyntax2/tests/data/parser/inline/0034_bind_pat.txt
new file mode 100644
index 000000000..e8e4e4c2b
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0034_bind_pat.txt
@@ -0,0 +1,127 @@
+FILE@[0; 146)
+  FUNCTION@[0; 145)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8)
+      R_PAREN@[8; 9)
+    WHITESPACE@[9; 10)
+    BLOCK_EXPR@[10; 145)
+      L_CURLY@[10; 11)
+      WHITESPACE@[11; 16)
+      LET_STMT@[16; 27)
+        LET_KW@[16; 19)
+        WHITESPACE@[19; 20)
+        BIND_PAT@[20; 21)
+          NAME@[20; 21)
+            IDENT@[20; 21) "a"
+        WHITESPACE@[21; 22)
+        EQ@[22; 23)
+        WHITESPACE@[23; 24)
+        TUPLE_EXPR@[24; 26)
+          L_PAREN@[24; 25)
+          R_PAREN@[25; 26)
+        SEMI@[26; 27)
+      WHITESPACE@[27; 32)
+      LET_STMT@[32; 47)
+        LET_KW@[32; 35)
+        WHITESPACE@[35; 36)
+        BIND_PAT@[36; 41)
+          MUT_KW@[36; 39)
+          WHITESPACE@[39; 40)
+          NAME@[40; 41)
+            IDENT@[40; 41) "b"
+        WHITESPACE@[41; 42)
+        EQ@[42; 43)
+        WHITESPACE@[43; 44)
+        TUPLE_EXPR@[44; 46)
+          L_PAREN@[44; 45)
+          R_PAREN@[45; 46)
+        SEMI@[46; 47)
+      WHITESPACE@[47; 52)
+      LET_STMT@[52; 67)
+        LET_KW@[52; 55)
+        WHITESPACE@[55; 56)
+        BIND_PAT@[56; 61)
+          REF_KW@[56; 59)
+          WHITESPACE@[59; 60)
+          NAME@[60; 61)
+            IDENT@[60; 61) "c"
+        WHITESPACE@[61; 62)
+        EQ@[62; 63)
+        WHITESPACE@[63; 64)
+        TUPLE_EXPR@[64; 66)
+          L_PAREN@[64; 65)
+          R_PAREN@[65; 66)
+        SEMI@[66; 67)
+      WHITESPACE@[67; 72)
+      LET_STMT@[72; 91)
+        LET_KW@[72; 75)
+        WHITESPACE@[75; 76)
+        BIND_PAT@[76; 85)
+          REF_KW@[76; 79)
+          WHITESPACE@[79; 80)
+          MUT_KW@[80; 83)
+          WHITESPACE@[83; 84)
+          NAME@[84; 85)
+            IDENT@[84; 85) "d"
+        WHITESPACE@[85; 86)
+        EQ@[86; 87)
+        WHITESPACE@[87; 88)
+        TUPLE_EXPR@[88; 90)
+          L_PAREN@[88; 89)
+          R_PAREN@[89; 90)
+        SEMI@[90; 91)
+      WHITESPACE@[91; 96)
+      LET_STMT@[96; 111)
+        LET_KW@[96; 99)
+        WHITESPACE@[99; 100)
+        BIND_PAT@[100; 105)
+          NAME@[100; 101)
+            IDENT@[100; 101) "e"
+          WHITESPACE@[101; 102)
+          AT@[102; 103)
+          WHITESPACE@[103; 104)
+          PLACEHOLDER_PAT@[104; 105)
+            UNDERSCORE@[104; 105)
+        WHITESPACE@[105; 106)
+        EQ@[106; 107)
+        WHITESPACE@[107; 108)
+        TUPLE_EXPR@[108; 110)
+          L_PAREN@[108; 109)
+          R_PAREN@[109; 110)
+        SEMI@[110; 111)
+      WHITESPACE@[111; 116)
+      LET_STMT@[116; 143)
+        LET_KW@[116; 119)
+        WHITESPACE@[119; 120)
+        BIND_PAT@[120; 137)
+          REF_KW@[120; 123)
+          WHITESPACE@[123; 124)
+          MUT_KW@[124; 127)
+          WHITESPACE@[127; 128)
+          NAME@[128; 129)
+            IDENT@[128; 129) "f"
+          WHITESPACE@[129; 130)
+          AT@[130; 131)
+          WHITESPACE@[131; 132)
+          BIND_PAT@[132; 137)
+            NAME@[132; 133)
+              IDENT@[132; 133) "g"
+            WHITESPACE@[133; 134)
+            AT@[134; 135)
+            WHITESPACE@[135; 136)
+            PLACEHOLDER_PAT@[136; 137)
+              UNDERSCORE@[136; 137)
+        WHITESPACE@[137; 138)
+        EQ@[138; 139)
+        WHITESPACE@[139; 140)
+        TUPLE_EXPR@[140; 142)
+          L_PAREN@[140; 141)
+          R_PAREN@[141; 142)
+        SEMI@[142; 143)
+      WHITESPACE@[143; 144)
+      R_CURLY@[144; 145)
+  WHITESPACE@[145; 146)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0035_ref_pat.rs b/crates/libsyntax2/tests/data/parser/inline/0035_ref_pat.rs
new file mode 100644
index 000000000..de41f5cae
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0035_ref_pat.rs
@@ -0,0 +1,4 @@
+fn main() {
+    let &a = ();
+    let &mut b = ();
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0035_ref_pat.txt b/crates/libsyntax2/tests/data/parser/inline/0035_ref_pat.txt
new file mode 100644
index 000000000..6fbffd8b7
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0035_ref_pat.txt
@@ -0,0 +1,49 @@
+FILE@[0; 52)
+  FUNCTION@[0; 51)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8)
+      R_PAREN@[8; 9)
+    WHITESPACE@[9; 10)
+    BLOCK_EXPR@[10; 51)
+      L_CURLY@[10; 11)
+      WHITESPACE@[11; 16)
+      LET_STMT@[16; 28)
+        LET_KW@[16; 19)
+        WHITESPACE@[19; 20)
+        REF_PAT@[20; 22)
+          AMP@[20; 21)
+          BIND_PAT@[21; 22)
+            NAME@[21; 22)
+              IDENT@[21; 22) "a"
+        WHITESPACE@[22; 23)
+        EQ@[23; 24)
+        WHITESPACE@[24; 25)
+        TUPLE_EXPR@[25; 27)
+          L_PAREN@[25; 26)
+          R_PAREN@[26; 27)
+        SEMI@[27; 28)
+      WHITESPACE@[28; 33)
+      LET_STMT@[33; 49)
+        LET_KW@[33; 36)
+        WHITESPACE@[36; 37)
+        REF_PAT@[37; 43)
+          AMP@[37; 38)
+          MUT_KW@[38; 41)
+          WHITESPACE@[41; 42)
+          BIND_PAT@[42; 43)
+            NAME@[42; 43)
+              IDENT@[42; 43) "b"
+        WHITESPACE@[43; 44)
+        EQ@[44; 45)
+        WHITESPACE@[45; 46)
+        TUPLE_EXPR@[46; 48)
+          L_PAREN@[46; 47)
+          R_PAREN@[47; 48)
+        SEMI@[48; 49)
+      WHITESPACE@[49; 50)
+      R_CURLY@[50; 51)
+  WHITESPACE@[51; 52)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0036_placeholder_pat.rs b/crates/libsyntax2/tests/data/parser/inline/0036_placeholder_pat.rs
new file mode 100644
index 000000000..4d719c433
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0036_placeholder_pat.rs
@@ -0,0 +1 @@
+fn main() { let _ = (); }
diff --git a/crates/libsyntax2/tests/data/parser/inline/0036_placeholder_pat.txt b/crates/libsyntax2/tests/data/parser/inline/0036_placeholder_pat.txt
new file mode 100644
index 000000000..8c63cdfae
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0036_placeholder_pat.txt
@@ -0,0 +1,28 @@
+FILE@[0; 26)
+  FUNCTION@[0; 25)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8)
+      R_PAREN@[8; 9)
+    WHITESPACE@[9; 10)
+    BLOCK_EXPR@[10; 25)
+      L_CURLY@[10; 11)
+      WHITESPACE@[11; 12)
+      LET_STMT@[12; 23)
+        LET_KW@[12; 15)
+        WHITESPACE@[15; 16)
+        PLACEHOLDER_PAT@[16; 17)
+          UNDERSCORE@[16; 17)
+        WHITESPACE@[17; 18)
+        EQ@[18; 19)
+        WHITESPACE@[19; 20)
+        TUPLE_EXPR@[20; 22)
+          L_PAREN@[20; 21)
+          R_PAREN@[21; 22)
+        SEMI@[22; 23)
+      WHITESPACE@[23; 24)
+      R_CURLY@[24; 25)
+  WHITESPACE@[25; 26)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0037_crate_visibility.rs b/crates/libsyntax2/tests/data/parser/inline/0037_crate_visibility.rs
new file mode 100644
index 000000000..faeefde94
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0037_crate_visibility.rs
@@ -0,0 +1,4 @@
+pub(crate) struct S;
+pub(self) struct S;
+pub(self) struct S;
+pub(self) struct S;
diff --git a/crates/libsyntax2/tests/data/parser/inline/0037_crate_visibility.txt b/crates/libsyntax2/tests/data/parser/inline/0037_crate_visibility.txt
new file mode 100644
index 000000000..113ac59e2
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0037_crate_visibility.txt
@@ -0,0 +1,53 @@
+FILE@[0; 81)
+  STRUCT_ITEM@[0; 20)
+    VISIBILITY@[0; 10)
+      PUB_KW@[0; 3)
+      L_PAREN@[3; 4)
+      CRATE_KW@[4; 9)
+      R_PAREN@[9; 10)
+    WHITESPACE@[10; 11)
+    STRUCT_KW@[11; 17)
+    WHITESPACE@[17; 18)
+    NAME@[18; 19)
+      IDENT@[18; 19) "S"
+    SEMI@[19; 20)
+  WHITESPACE@[20; 21)
+  STRUCT_ITEM@[21; 40)
+    VISIBILITY@[21; 30)
+      PUB_KW@[21; 24)
+      L_PAREN@[24; 25)
+      SELF_KW@[25; 29)
+      R_PAREN@[29; 30)
+    WHITESPACE@[30; 31)
+    STRUCT_KW@[31; 37)
+    WHITESPACE@[37; 38)
+    NAME@[38; 39)
+      IDENT@[38; 39) "S"
+    SEMI@[39; 40)
+  WHITESPACE@[40; 41)
+  STRUCT_ITEM@[41; 60)
+    VISIBILITY@[41; 50)
+      PUB_KW@[41; 44)
+      L_PAREN@[44; 45)
+      SELF_KW@[45; 49)
+      R_PAREN@[49; 50)
+    WHITESPACE@[50; 51)
+    STRUCT_KW@[51; 57)
+    WHITESPACE@[57; 58)
+    NAME@[58; 59)
+      IDENT@[58; 59) "S"
+    SEMI@[59; 60)
+  WHITESPACE@[60; 61)
+  STRUCT_ITEM@[61; 80)
+    VISIBILITY@[61; 70)
+      PUB_KW@[61; 64)
+      L_PAREN@[64; 65)
+      SELF_KW@[65; 69)
+      R_PAREN@[69; 70)
+    WHITESPACE@[70; 71)
+    STRUCT_KW@[71; 77)
+    WHITESPACE@[77; 78)
+    NAME@[78; 79)
+      IDENT@[78; 79) "S"
+    SEMI@[79; 80)
+  WHITESPACE@[80; 81)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0038_function_ret_type.rs b/crates/libsyntax2/tests/data/parser/inline/0038_function_ret_type.rs
new file mode 100644
index 000000000..d22d8cada
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0038_function_ret_type.rs
@@ -0,0 +1,2 @@
+fn foo() {}
+fn bar() -> () {}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0038_function_ret_type.txt b/crates/libsyntax2/tests/data/parser/inline/0038_function_ret_type.txt
new file mode 100644
index 000000000..58583eefe
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0038_function_ret_type.txt
@@ -0,0 +1,33 @@
+FILE@[0; 30)
+  FUNCTION@[0; 11)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 11)
+      L_CURLY@[9; 10)
+      R_CURLY@[10; 11)
+  WHITESPACE@[11; 12)
+  FUNCTION@[12; 29)
+    FN_KW@[12; 14)
+    WHITESPACE@[14; 15)
+    NAME@[15; 18)
+      IDENT@[15; 18) "bar"
+    PARAM_LIST@[18; 20)
+      L_PAREN@[18; 19)
+      R_PAREN@[19; 20)
+    WHITESPACE@[20; 21)
+    THIN_ARROW@[21; 23)
+    WHITESPACE@[23; 24)
+    TUPLE_TYPE@[24; 26)
+      L_PAREN@[24; 25)
+      R_PAREN@[25; 26)
+    WHITESPACE@[26; 27)
+    BLOCK_EXPR@[27; 29)
+      L_CURLY@[27; 28)
+      R_CURLY@[28; 29)
+  WHITESPACE@[29; 30)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0039_path_expr.rs b/crates/libsyntax2/tests/data/parser/inline/0039_path_expr.rs
new file mode 100644
index 000000000..333ebabef
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0039_path_expr.rs
@@ -0,0 +1,6 @@
+fn foo() {
+    let _ = a;
+    let _ = a::b;
+    let _ = ::a::<b>;
+    let _ = format!();
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0039_path_expr.txt b/crates/libsyntax2/tests/data/parser/inline/0039_path_expr.txt
new file mode 100644
index 000000000..8b505774f
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0039_path_expr.txt
@@ -0,0 +1,94 @@
+FILE@[0; 91)
+  FUNCTION@[0; 90)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 90)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      LET_STMT@[15; 25)
+        LET_KW@[15; 18)
+        WHITESPACE@[18; 19)
+        PLACEHOLDER_PAT@[19; 20)
+          UNDERSCORE@[19; 20)
+        WHITESPACE@[20; 21)
+        EQ@[21; 22)
+        WHITESPACE@[22; 23)
+        PATH_EXPR@[23; 24)
+          PATH@[23; 24)
+            PATH_SEGMENT@[23; 24)
+              NAME_REF@[23; 24)
+                IDENT@[23; 24) "a"
+        SEMI@[24; 25)
+      WHITESPACE@[25; 30)
+      LET_STMT@[30; 43)
+        LET_KW@[30; 33)
+        WHITESPACE@[33; 34)
+        PLACEHOLDER_PAT@[34; 35)
+          UNDERSCORE@[34; 35)
+        WHITESPACE@[35; 36)
+        EQ@[36; 37)
+        WHITESPACE@[37; 38)
+        PATH_EXPR@[38; 42)
+          PATH@[38; 42)
+            PATH@[38; 39)
+              PATH_SEGMENT@[38; 39)
+                NAME_REF@[38; 39)
+                  IDENT@[38; 39) "a"
+            COLONCOLON@[39; 41)
+            PATH_SEGMENT@[41; 42)
+              NAME_REF@[41; 42)
+                IDENT@[41; 42) "b"
+        SEMI@[42; 43)
+      WHITESPACE@[43; 48)
+      LET_STMT@[48; 65)
+        LET_KW@[48; 51)
+        WHITESPACE@[51; 52)
+        PLACEHOLDER_PAT@[52; 53)
+          UNDERSCORE@[52; 53)
+        WHITESPACE@[53; 54)
+        EQ@[54; 55)
+        WHITESPACE@[55; 56)
+        PATH_EXPR@[56; 64)
+          PATH@[56; 64)
+            PATH_SEGMENT@[56; 64)
+              COLONCOLON@[56; 58)
+              NAME_REF@[58; 59)
+                IDENT@[58; 59) "a"
+              TYPE_ARG_LIST@[59; 64)
+                COLONCOLON@[59; 61)
+                L_ANGLE@[61; 62)
+                TYPE_ARG@[62; 63)
+                  PATH_TYPE@[62; 63)
+                    PATH@[62; 63)
+                      PATH_SEGMENT@[62; 63)
+                        NAME_REF@[62; 63)
+                          IDENT@[62; 63) "b"
+                R_ANGLE@[63; 64)
+        SEMI@[64; 65)
+      WHITESPACE@[65; 70)
+      LET_STMT@[70; 88)
+        LET_KW@[70; 73)
+        WHITESPACE@[73; 74)
+        PLACEHOLDER_PAT@[74; 75)
+          UNDERSCORE@[74; 75)
+        WHITESPACE@[75; 76)
+        EQ@[76; 77)
+        WHITESPACE@[77; 78)
+        MACRO_CALL@[78; 87)
+          PATH@[78; 84)
+            PATH_SEGMENT@[78; 84)
+              NAME_REF@[78; 84)
+                IDENT@[78; 84) "format"
+          EXCL@[84; 85)
+          L_PAREN@[85; 86)
+          R_PAREN@[86; 87)
+        SEMI@[87; 88)
+      WHITESPACE@[88; 89)
+      R_CURLY@[89; 90)
+  WHITESPACE@[90; 91)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0040_expr_literals.rs b/crates/libsyntax2/tests/data/parser/inline/0040_expr_literals.rs
new file mode 100644
index 000000000..2e11a5a6e
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0040_expr_literals.rs
@@ -0,0 +1,12 @@
+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";
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0040_expr_literals.txt b/crates/libsyntax2/tests/data/parser/inline/0040_expr_literals.txt
new file mode 100644
index 000000000..192b62211
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0040_expr_literals.txt
@@ -0,0 +1,135 @@
+FILE@[0; 189)
+  FUNCTION@[0; 188)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 188)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      LET_STMT@[15; 28)
+        LET_KW@[15; 18)
+        WHITESPACE@[18; 19)
+        PLACEHOLDER_PAT@[19; 20)
+          UNDERSCORE@[19; 20)
+        WHITESPACE@[20; 21)
+        EQ@[21; 22)
+        WHITESPACE@[22; 23)
+        LITERAL@[23; 27)
+          TRUE_KW@[23; 27)
+        SEMI@[27; 28)
+      WHITESPACE@[28; 33)
+      LET_STMT@[33; 47)
+        LET_KW@[33; 36)
+        WHITESPACE@[36; 37)
+        PLACEHOLDER_PAT@[37; 38)
+          UNDERSCORE@[37; 38)
+        WHITESPACE@[38; 39)
+        EQ@[39; 40)
+        WHITESPACE@[40; 41)
+        LITERAL@[41; 46)
+          FALSE_KW@[41; 46)
+        SEMI@[46; 47)
+      WHITESPACE@[47; 52)
+      LET_STMT@[52; 62)
+        LET_KW@[52; 55)
+        WHITESPACE@[55; 56)
+        PLACEHOLDER_PAT@[56; 57)
+          UNDERSCORE@[56; 57)
+        WHITESPACE@[57; 58)
+        EQ@[58; 59)
+        WHITESPACE@[59; 60)
+        LITERAL@[60; 61)
+          INT_NUMBER@[60; 61) "1"
+        SEMI@[61; 62)
+      WHITESPACE@[62; 67)
+      LET_STMT@[67; 79)
+        LET_KW@[67; 70)
+        WHITESPACE@[70; 71)
+        PLACEHOLDER_PAT@[71; 72)
+          UNDERSCORE@[71; 72)
+        WHITESPACE@[72; 73)
+        EQ@[73; 74)
+        WHITESPACE@[74; 75)
+        LITERAL@[75; 78)
+          FLOAT_NUMBER@[75; 78) "2.0"
+        SEMI@[78; 79)
+      WHITESPACE@[79; 84)
+      LET_STMT@[84; 97)
+        LET_KW@[84; 87)
+        WHITESPACE@[87; 88)
+        PLACEHOLDER_PAT@[88; 89)
+          UNDERSCORE@[88; 89)
+        WHITESPACE@[89; 90)
+        EQ@[90; 91)
+        WHITESPACE@[91; 92)
+        LITERAL@[92; 96)
+          BYTE@[92; 96)
+        SEMI@[96; 97)
+      WHITESPACE@[97; 102)
+      LET_STMT@[102; 114)
+        LET_KW@[102; 105)
+        WHITESPACE@[105; 106)
+        PLACEHOLDER_PAT@[106; 107)
+          UNDERSCORE@[106; 107)
+        WHITESPACE@[107; 108)
+        EQ@[108; 109)
+        WHITESPACE@[109; 110)
+        LITERAL@[110; 113)
+          CHAR@[110; 113)
+        SEMI@[113; 114)
+      WHITESPACE@[114; 119)
+      LET_STMT@[119; 131)
+        LET_KW@[119; 122)
+        WHITESPACE@[122; 123)
+        PLACEHOLDER_PAT@[123; 124)
+          UNDERSCORE@[123; 124)
+        WHITESPACE@[124; 125)
+        EQ@[125; 126)
+        WHITESPACE@[126; 127)
+        LITERAL@[127; 130)
+          STRING@[127; 130)
+        SEMI@[130; 131)
+      WHITESPACE@[131; 136)
+      LET_STMT@[136; 149)
+        LET_KW@[136; 139)
+        WHITESPACE@[139; 140)
+        PLACEHOLDER_PAT@[140; 141)
+          UNDERSCORE@[140; 141)
+        WHITESPACE@[141; 142)
+        EQ@[142; 143)
+        WHITESPACE@[143; 144)
+        LITERAL@[144; 148)
+          RAW_STRING@[144; 148)
+        SEMI@[148; 149)
+      WHITESPACE@[149; 154)
+      LET_STMT@[154; 167)
+        LET_KW@[154; 157)
+        WHITESPACE@[157; 158)
+        PLACEHOLDER_PAT@[158; 159)
+          UNDERSCORE@[158; 159)
+        WHITESPACE@[159; 160)
+        EQ@[160; 161)
+        WHITESPACE@[161; 162)
+        LITERAL@[162; 166)
+          BYTE_STRING@[162; 166)
+        SEMI@[166; 167)
+      WHITESPACE@[167; 172)
+      LET_STMT@[172; 186)
+        LET_KW@[172; 175)
+        WHITESPACE@[175; 176)
+        PLACEHOLDER_PAT@[176; 177)
+          UNDERSCORE@[176; 177)
+        WHITESPACE@[177; 178)
+        EQ@[178; 179)
+        WHITESPACE@[179; 180)
+        LITERAL@[180; 185)
+          RAW_BYTE_STRING@[180; 185)
+        SEMI@[185; 186)
+      WHITESPACE@[186; 187)
+      R_CURLY@[187; 188)
+  WHITESPACE@[188; 189)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0041_type_param_bounds.rs b/crates/libsyntax2/tests/data/parser/inline/0041_type_param_bounds.rs
new file mode 100644
index 000000000..919bde0ee
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0041_type_param_bounds.rs
@@ -0,0 +1 @@
+struct S<T: 'a + ?Sized + (Copy)>;
diff --git a/crates/libsyntax2/tests/data/parser/inline/0041_type_param_bounds.txt b/crates/libsyntax2/tests/data/parser/inline/0041_type_param_bounds.txt
new file mode 100644
index 000000000..4996d6ace
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0041_type_param_bounds.txt
@@ -0,0 +1,34 @@
+FILE@[0; 35)
+  STRUCT_ITEM@[0; 34)
+    STRUCT_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    NAME@[7; 8)
+      IDENT@[7; 8) "S"
+    TYPE_PARAM_LIST@[8; 33)
+      L_ANGLE@[8; 9)
+      TYPE_PARAM@[9; 32)
+        NAME@[9; 10)
+          IDENT@[9; 10) "T"
+        COLON@[10; 11)
+        WHITESPACE@[11; 12)
+        LIFETIME@[12; 14) "'a"
+        WHITESPACE@[14; 15)
+        PLUS@[15; 16)
+        WHITESPACE@[16; 17)
+        QUESTION@[17; 18)
+        PATH@[18; 23)
+          PATH_SEGMENT@[18; 23)
+            NAME_REF@[18; 23)
+              IDENT@[18; 23) "Sized"
+        WHITESPACE@[23; 24)
+        PLUS@[24; 25)
+        WHITESPACE@[25; 26)
+        L_PAREN@[26; 27)
+        PATH@[27; 31)
+          PATH_SEGMENT@[27; 31)
+            NAME_REF@[27; 31)
+              IDENT@[27; 31) "Copy"
+        R_PAREN@[31; 32)
+      R_ANGLE@[32; 33)
+    SEMI@[33; 34)
+  WHITESPACE@[34; 35)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0042_type_param_default.rs b/crates/libsyntax2/tests/data/parser/inline/0042_type_param_default.rs
new file mode 100644
index 000000000..540eacb02
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0042_type_param_default.rs
@@ -0,0 +1 @@
+struct S<T = i32>;
diff --git a/crates/libsyntax2/tests/data/parser/inline/0042_type_param_default.txt b/crates/libsyntax2/tests/data/parser/inline/0042_type_param_default.txt
new file mode 100644
index 000000000..ec875e9a2
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0042_type_param_default.txt
@@ -0,0 +1,22 @@
+FILE@[0; 19)
+  STRUCT_ITEM@[0; 18)
+    STRUCT_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    NAME@[7; 8)
+      IDENT@[7; 8) "S"
+    TYPE_PARAM_LIST@[8; 17)
+      L_ANGLE@[8; 9)
+      TYPE_PARAM@[9; 16)
+        NAME@[9; 10)
+          IDENT@[9; 10) "T"
+        WHITESPACE@[10; 11)
+        EQ@[11; 12)
+        WHITESPACE@[12; 13)
+        PATH_TYPE@[13; 16)
+          PATH@[13; 16)
+            PATH_SEGMENT@[13; 16)
+              NAME_REF@[13; 16)
+                IDENT@[13; 16) "i32"
+      R_ANGLE@[16; 17)
+    SEMI@[17; 18)
+  WHITESPACE@[18; 19)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0043_call_expr.rs b/crates/libsyntax2/tests/data/parser/inline/0043_call_expr.rs
new file mode 100644
index 000000000..0c9a20718
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0043_call_expr.rs
@@ -0,0 +1,4 @@
+fn foo() {
+    let _ = f();
+    let _ = f()(1)(1, 2,);
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0043_call_expr.txt b/crates/libsyntax2/tests/data/parser/inline/0043_call_expr.txt
new file mode 100644
index 000000000..f4789d2d9
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0043_call_expr.txt
@@ -0,0 +1,70 @@
+FILE@[0; 57)
+  FUNCTION@[0; 56)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 56)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      LET_STMT@[15; 27)
+        LET_KW@[15; 18)
+        WHITESPACE@[18; 19)
+        PLACEHOLDER_PAT@[19; 20)
+          UNDERSCORE@[19; 20)
+        WHITESPACE@[20; 21)
+        EQ@[21; 22)
+        WHITESPACE@[22; 23)
+        CALL_EXPR@[23; 26)
+          PATH_EXPR@[23; 24)
+            PATH@[23; 24)
+              PATH_SEGMENT@[23; 24)
+                NAME_REF@[23; 24)
+                  IDENT@[23; 24) "f"
+          ARG_LIST@[24; 26)
+            L_PAREN@[24; 25)
+            R_PAREN@[25; 26)
+        SEMI@[26; 27)
+      WHITESPACE@[27; 32)
+      LET_STMT@[32; 54)
+        LET_KW@[32; 35)
+        WHITESPACE@[35; 36)
+        PLACEHOLDER_PAT@[36; 37)
+          UNDERSCORE@[36; 37)
+        WHITESPACE@[37; 38)
+        EQ@[38; 39)
+        WHITESPACE@[39; 40)
+        CALL_EXPR@[40; 53)
+          CALL_EXPR@[40; 46)
+            CALL_EXPR@[40; 43)
+              PATH_EXPR@[40; 41)
+                PATH@[40; 41)
+                  PATH_SEGMENT@[40; 41)
+                    NAME_REF@[40; 41)
+                      IDENT@[40; 41) "f"
+              ARG_LIST@[41; 43)
+                L_PAREN@[41; 42)
+                R_PAREN@[42; 43)
+            ARG_LIST@[43; 46)
+              L_PAREN@[43; 44)
+              LITERAL@[44; 45)
+                INT_NUMBER@[44; 45) "1"
+              R_PAREN@[45; 46)
+          ARG_LIST@[46; 53)
+            L_PAREN@[46; 47)
+            LITERAL@[47; 48)
+              INT_NUMBER@[47; 48) "1"
+            COMMA@[48; 49)
+            WHITESPACE@[49; 50)
+            LITERAL@[50; 51)
+              INT_NUMBER@[50; 51) "2"
+            COMMA@[51; 52)
+            R_PAREN@[52; 53)
+        SEMI@[53; 54)
+      WHITESPACE@[54; 55)
+      R_CURLY@[55; 56)
+  WHITESPACE@[56; 57)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0044_ref_expr.rs b/crates/libsyntax2/tests/data/parser/inline/0044_ref_expr.rs
new file mode 100644
index 000000000..2dac6be95
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0044_ref_expr.rs
@@ -0,0 +1,4 @@
+fn foo() {
+    let _ = &1;
+    let _ = &mut &f();
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0044_ref_expr.txt b/crates/libsyntax2/tests/data/parser/inline/0044_ref_expr.txt
new file mode 100644
index 000000000..05f6c015a
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0044_ref_expr.txt
@@ -0,0 +1,54 @@
+FILE@[0; 52)
+  FUNCTION@[0; 51)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 51)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      LET_STMT@[15; 26)
+        LET_KW@[15; 18)
+        WHITESPACE@[18; 19)
+        PLACEHOLDER_PAT@[19; 20)
+          UNDERSCORE@[19; 20)
+        WHITESPACE@[20; 21)
+        EQ@[21; 22)
+        WHITESPACE@[22; 23)
+        REF_EXPR@[23; 25)
+          AMP@[23; 24)
+          LITERAL@[24; 25)
+            INT_NUMBER@[24; 25) "1"
+        SEMI@[25; 26)
+      WHITESPACE@[26; 31)
+      LET_STMT@[31; 49)
+        LET_KW@[31; 34)
+        WHITESPACE@[34; 35)
+        PLACEHOLDER_PAT@[35; 36)
+          UNDERSCORE@[35; 36)
+        WHITESPACE@[36; 37)
+        EQ@[37; 38)
+        WHITESPACE@[38; 39)
+        REF_EXPR@[39; 48)
+          AMP@[39; 40)
+          MUT_KW@[40; 43)
+          WHITESPACE@[43; 44)
+          REF_EXPR@[44; 48)
+            AMP@[44; 45)
+            CALL_EXPR@[45; 48)
+              PATH_EXPR@[45; 46)
+                PATH@[45; 46)
+                  PATH_SEGMENT@[45; 46)
+                    NAME_REF@[45; 46)
+                      IDENT@[45; 46) "f"
+              ARG_LIST@[46; 48)
+                L_PAREN@[46; 47)
+                R_PAREN@[47; 48)
+        SEMI@[48; 49)
+      WHITESPACE@[49; 50)
+      R_CURLY@[50; 51)
+  WHITESPACE@[51; 52)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0045_block.rs b/crates/libsyntax2/tests/data/parser/inline/0045_block.rs
new file mode 100644
index 000000000..81f44c533
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0045_block.rs
@@ -0,0 +1,4 @@
+fn a() {}
+fn b() { let _ = 1; }
+fn c() { 1; 2; }
+fn d() { 1; 2 }
diff --git a/crates/libsyntax2/tests/data/parser/inline/0045_block.txt b/crates/libsyntax2/tests/data/parser/inline/0045_block.txt
new file mode 100644
index 000000000..8519101c3
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0045_block.txt
@@ -0,0 +1,86 @@
+FILE@[0; 65)
+  FUNCTION@[0; 9)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 4)
+      IDENT@[3; 4) "a"
+    PARAM_LIST@[4; 6)
+      L_PAREN@[4; 5)
+      R_PAREN@[5; 6)
+    WHITESPACE@[6; 7)
+    BLOCK_EXPR@[7; 9)
+      L_CURLY@[7; 8)
+      R_CURLY@[8; 9)
+  WHITESPACE@[9; 10)
+  FUNCTION@[10; 31)
+    FN_KW@[10; 12)
+    WHITESPACE@[12; 13)
+    NAME@[13; 14)
+      IDENT@[13; 14) "b"
+    PARAM_LIST@[14; 16)
+      L_PAREN@[14; 15)
+      R_PAREN@[15; 16)
+    WHITESPACE@[16; 17)
+    BLOCK_EXPR@[17; 31)
+      L_CURLY@[17; 18)
+      WHITESPACE@[18; 19)
+      LET_STMT@[19; 29)
+        LET_KW@[19; 22)
+        WHITESPACE@[22; 23)
+        PLACEHOLDER_PAT@[23; 24)
+          UNDERSCORE@[23; 24)
+        WHITESPACE@[24; 25)
+        EQ@[25; 26)
+        WHITESPACE@[26; 27)
+        LITERAL@[27; 28)
+          INT_NUMBER@[27; 28) "1"
+        SEMI@[28; 29)
+      WHITESPACE@[29; 30)
+      R_CURLY@[30; 31)
+  WHITESPACE@[31; 32)
+  FUNCTION@[32; 48)
+    FN_KW@[32; 34)
+    WHITESPACE@[34; 35)
+    NAME@[35; 36)
+      IDENT@[35; 36) "c"
+    PARAM_LIST@[36; 38)
+      L_PAREN@[36; 37)
+      R_PAREN@[37; 38)
+    WHITESPACE@[38; 39)
+    BLOCK_EXPR@[39; 48)
+      L_CURLY@[39; 40)
+      WHITESPACE@[40; 41)
+      EXPR_STMT@[41; 43)
+        LITERAL@[41; 42)
+          INT_NUMBER@[41; 42) "1"
+        SEMI@[42; 43)
+      WHITESPACE@[43; 44)
+      EXPR_STMT@[44; 46)
+        LITERAL@[44; 45)
+          INT_NUMBER@[44; 45) "2"
+        SEMI@[45; 46)
+      WHITESPACE@[46; 47)
+      R_CURLY@[47; 48)
+  WHITESPACE@[48; 49)
+  FUNCTION@[49; 64)
+    FN_KW@[49; 51)
+    WHITESPACE@[51; 52)
+    NAME@[52; 53)
+      IDENT@[52; 53) "d"
+    PARAM_LIST@[53; 55)
+      L_PAREN@[53; 54)
+      R_PAREN@[54; 55)
+    WHITESPACE@[55; 56)
+    BLOCK_EXPR@[56; 64)
+      L_CURLY@[56; 57)
+      WHITESPACE@[57; 58)
+      EXPR_STMT@[58; 60)
+        LITERAL@[58; 59)
+          INT_NUMBER@[58; 59) "1"
+        SEMI@[59; 60)
+      WHITESPACE@[60; 61)
+      LITERAL@[61; 62)
+        INT_NUMBER@[61; 62) "2"
+      WHITESPACE@[62; 63)
+      R_CURLY@[63; 64)
+  WHITESPACE@[64; 65)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0046_default_impl.rs b/crates/libsyntax2/tests/data/parser/inline/0046_default_impl.rs
new file mode 100644
index 000000000..ef6aa84a2
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0046_default_impl.rs
@@ -0,0 +1 @@
+default impl Foo {}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0046_default_impl.txt b/crates/libsyntax2/tests/data/parser/inline/0046_default_impl.txt
new file mode 100644
index 000000000..d5a27baf7
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0046_default_impl.txt
@@ -0,0 +1,15 @@
+FILE@[0; 20)
+  IMPL_ITEM@[0; 19)
+    DEFAULT_KW@[0; 7)
+    WHITESPACE@[7; 8)
+    IMPL_KW@[8; 12)
+    WHITESPACE@[12; 13)
+    PATH_TYPE@[13; 16)
+      PATH@[13; 16)
+        PATH_SEGMENT@[13; 16)
+          NAME_REF@[13; 16)
+            IDENT@[13; 16) "Foo"
+    WHITESPACE@[16; 17)
+    L_CURLY@[17; 18)
+    R_CURLY@[18; 19)
+  WHITESPACE@[19; 20)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0047_impl_item.rs b/crates/libsyntax2/tests/data/parser/inline/0047_impl_item.rs
new file mode 100644
index 000000000..d6337f6b3
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0047_impl_item.rs
@@ -0,0 +1 @@
+impl Foo {}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0047_impl_item.txt b/crates/libsyntax2/tests/data/parser/inline/0047_impl_item.txt
new file mode 100644
index 000000000..76b29f95d
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0047_impl_item.txt
@@ -0,0 +1,13 @@
+FILE@[0; 12)
+  IMPL_ITEM@[0; 11)
+    IMPL_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    PATH_TYPE@[5; 8)
+      PATH@[5; 8)
+        PATH_SEGMENT@[5; 8)
+          NAME_REF@[5; 8)
+            IDENT@[5; 8) "Foo"
+    WHITESPACE@[8; 9)
+    L_CURLY@[9; 10)
+    R_CURLY@[10; 11)
+  WHITESPACE@[11; 12)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0048_impl_item_neg.rs b/crates/libsyntax2/tests/data/parser/inline/0048_impl_item_neg.rs
new file mode 100644
index 000000000..b7527c870
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0048_impl_item_neg.rs
@@ -0,0 +1 @@
+impl !Send for X {}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0048_impl_item_neg.txt b/crates/libsyntax2/tests/data/parser/inline/0048_impl_item_neg.txt
new file mode 100644
index 000000000..2d01419c0
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0048_impl_item_neg.txt
@@ -0,0 +1,22 @@
+FILE@[0; 20)
+  IMPL_ITEM@[0; 19)
+    IMPL_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    EXCL@[5; 6)
+    PATH_TYPE@[6; 10)
+      PATH@[6; 10)
+        PATH_SEGMENT@[6; 10)
+          NAME_REF@[6; 10)
+            IDENT@[6; 10) "Send"
+    WHITESPACE@[10; 11)
+    FOR_KW@[11; 14)
+    WHITESPACE@[14; 15)
+    PATH_TYPE@[15; 16)
+      PATH@[15; 16)
+        PATH_SEGMENT@[15; 16)
+          NAME_REF@[15; 16)
+            IDENT@[15; 16) "X"
+    WHITESPACE@[16; 17)
+    L_CURLY@[17; 18)
+    R_CURLY@[18; 19)
+  WHITESPACE@[19; 20)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0050_let_stmt;.rs b/crates/libsyntax2/tests/data/parser/inline/0050_let_stmt;.rs
new file mode 100644
index 000000000..0a9af907f
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0050_let_stmt;.rs
@@ -0,0 +1,6 @@
+fn foo() {
+    let a;
+    let b: i32;
+    let c = 92;
+    let d: i32 = 92;
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0050_let_stmt;.txt b/crates/libsyntax2/tests/data/parser/inline/0050_let_stmt;.txt
new file mode 100644
index 000000000..44e357092
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0050_let_stmt;.txt
@@ -0,0 +1,71 @@
+FILE@[0; 77)
+  FUNCTION@[0; 76)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 76)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      LET_STMT@[15; 21)
+        LET_KW@[15; 18)
+        WHITESPACE@[18; 19)
+        BIND_PAT@[19; 20)
+          NAME@[19; 20)
+            IDENT@[19; 20) "a"
+        SEMI@[20; 21)
+      WHITESPACE@[21; 26)
+      LET_STMT@[26; 37)
+        LET_KW@[26; 29)
+        WHITESPACE@[29; 30)
+        BIND_PAT@[30; 31)
+          NAME@[30; 31)
+            IDENT@[30; 31) "b"
+        COLON@[31; 32)
+        WHITESPACE@[32; 33)
+        PATH_TYPE@[33; 36)
+          PATH@[33; 36)
+            PATH_SEGMENT@[33; 36)
+              NAME_REF@[33; 36)
+                IDENT@[33; 36) "i32"
+        SEMI@[36; 37)
+      WHITESPACE@[37; 42)
+      LET_STMT@[42; 53)
+        LET_KW@[42; 45)
+        WHITESPACE@[45; 46)
+        BIND_PAT@[46; 47)
+          NAME@[46; 47)
+            IDENT@[46; 47) "c"
+        WHITESPACE@[47; 48)
+        EQ@[48; 49)
+        WHITESPACE@[49; 50)
+        LITERAL@[50; 52)
+          INT_NUMBER@[50; 52) "92"
+        SEMI@[52; 53)
+      WHITESPACE@[53; 58)
+      LET_STMT@[58; 74)
+        LET_KW@[58; 61)
+        WHITESPACE@[61; 62)
+        BIND_PAT@[62; 63)
+          NAME@[62; 63)
+            IDENT@[62; 63) "d"
+        COLON@[63; 64)
+        WHITESPACE@[64; 65)
+        PATH_TYPE@[65; 68)
+          PATH@[65; 68)
+            PATH_SEGMENT@[65; 68)
+              NAME_REF@[65; 68)
+                IDENT@[65; 68) "i32"
+        WHITESPACE@[68; 69)
+        EQ@[69; 70)
+        WHITESPACE@[70; 71)
+        LITERAL@[71; 73)
+          INT_NUMBER@[71; 73) "92"
+        SEMI@[73; 74)
+      WHITESPACE@[74; 75)
+      R_CURLY@[75; 76)
+  WHITESPACE@[76; 77)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0051_method_call_expr.rs b/crates/libsyntax2/tests/data/parser/inline/0051_method_call_expr.rs
new file mode 100644
index 000000000..1a3aa35ae
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0051_method_call_expr.rs
@@ -0,0 +1,4 @@
+fn foo() {
+    x.foo();
+    y.bar::<T>(1, 2,);
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0051_method_call_expr.txt b/crates/libsyntax2/tests/data/parser/inline/0051_method_call_expr.txt
new file mode 100644
index 000000000..aafb2d5f1
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0051_method_call_expr.txt
@@ -0,0 +1,62 @@
+FILE@[0; 49)
+  FUNCTION@[0; 48)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 48)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      EXPR_STMT@[15; 23)
+        METHOD_CALL_EXPR@[15; 22)
+          PATH_EXPR@[15; 16)
+            PATH@[15; 16)
+              PATH_SEGMENT@[15; 16)
+                NAME_REF@[15; 16)
+                  IDENT@[15; 16) "x"
+          DOT@[16; 17)
+          NAME_REF@[17; 20)
+            IDENT@[17; 20) "foo"
+          ARG_LIST@[20; 22)
+            L_PAREN@[20; 21)
+            R_PAREN@[21; 22)
+        SEMI@[22; 23)
+      WHITESPACE@[23; 28)
+      EXPR_STMT@[28; 46)
+        METHOD_CALL_EXPR@[28; 45)
+          PATH_EXPR@[28; 29)
+            PATH@[28; 29)
+              PATH_SEGMENT@[28; 29)
+                NAME_REF@[28; 29)
+                  IDENT@[28; 29) "y"
+          DOT@[29; 30)
+          NAME_REF@[30; 33)
+            IDENT@[30; 33) "bar"
+          TYPE_ARG_LIST@[33; 38)
+            COLONCOLON@[33; 35)
+            L_ANGLE@[35; 36)
+            TYPE_ARG@[36; 37)
+              PATH_TYPE@[36; 37)
+                PATH@[36; 37)
+                  PATH_SEGMENT@[36; 37)
+                    NAME_REF@[36; 37)
+                      IDENT@[36; 37) "T"
+            R_ANGLE@[37; 38)
+          ARG_LIST@[38; 45)
+            L_PAREN@[38; 39)
+            LITERAL@[39; 40)
+              INT_NUMBER@[39; 40) "1"
+            COMMA@[40; 41)
+            WHITESPACE@[41; 42)
+            LITERAL@[42; 43)
+              INT_NUMBER@[42; 43) "2"
+            COMMA@[43; 44)
+            R_PAREN@[44; 45)
+        SEMI@[45; 46)
+      WHITESPACE@[46; 47)
+      R_CURLY@[47; 48)
+  WHITESPACE@[48; 49)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0052_field_expr.rs b/crates/libsyntax2/tests/data/parser/inline/0052_field_expr.rs
new file mode 100644
index 000000000..3e69538e5
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0052_field_expr.rs
@@ -0,0 +1,4 @@
+fn foo() {
+    x.foo;
+    x.0.bar;
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0052_field_expr.txt b/crates/libsyntax2/tests/data/parser/inline/0052_field_expr.txt
new file mode 100644
index 000000000..213884f90
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0052_field_expr.txt
@@ -0,0 +1,42 @@
+FILE@[0; 37)
+  FUNCTION@[0; 36)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 36)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      EXPR_STMT@[15; 21)
+        FIELD_EXPR@[15; 20)
+          PATH_EXPR@[15; 16)
+            PATH@[15; 16)
+              PATH_SEGMENT@[15; 16)
+                NAME_REF@[15; 16)
+                  IDENT@[15; 16) "x"
+          DOT@[16; 17)
+          NAME_REF@[17; 20)
+            IDENT@[17; 20) "foo"
+        SEMI@[20; 21)
+      WHITESPACE@[21; 26)
+      EXPR_STMT@[26; 34)
+        FIELD_EXPR@[26; 33)
+          FIELD_EXPR@[26; 29)
+            PATH_EXPR@[26; 27)
+              PATH@[26; 27)
+                PATH_SEGMENT@[26; 27)
+                  NAME_REF@[26; 27)
+                    IDENT@[26; 27) "x"
+            DOT@[27; 28)
+            INT_NUMBER@[28; 29) "0"
+          DOT@[29; 30)
+          NAME_REF@[30; 33)
+            IDENT@[30; 33) "bar"
+        SEMI@[33; 34)
+      WHITESPACE@[34; 35)
+      R_CURLY@[35; 36)
+  WHITESPACE@[36; 37)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0053_block_items.rs b/crates/libsyntax2/tests/data/parser/inline/0053_block_items.rs
new file mode 100644
index 000000000..d9868718c
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0053_block_items.rs
@@ -0,0 +1 @@
+fn a() { fn b() {} }
diff --git a/crates/libsyntax2/tests/data/parser/inline/0053_block_items.txt b/crates/libsyntax2/tests/data/parser/inline/0053_block_items.txt
new file mode 100644
index 000000000..c5498532b
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0053_block_items.txt
@@ -0,0 +1,28 @@
+FILE@[0; 21)
+  FUNCTION@[0; 20)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 4)
+      IDENT@[3; 4) "a"
+    PARAM_LIST@[4; 6)
+      L_PAREN@[4; 5)
+      R_PAREN@[5; 6)
+    WHITESPACE@[6; 7)
+    BLOCK_EXPR@[7; 20)
+      L_CURLY@[7; 8)
+      WHITESPACE@[8; 9)
+      FUNCTION@[9; 18)
+        FN_KW@[9; 11)
+        WHITESPACE@[11; 12)
+        NAME@[12; 13)
+          IDENT@[12; 13) "b"
+        PARAM_LIST@[13; 15)
+          L_PAREN@[13; 14)
+          R_PAREN@[14; 15)
+        WHITESPACE@[15; 16)
+        BLOCK_EXPR@[16; 18)
+          L_CURLY@[16; 17)
+          R_CURLY@[17; 18)
+      WHITESPACE@[18; 19)
+      R_CURLY@[19; 20)
+  WHITESPACE@[20; 21)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0054_impl_item_items.rs b/crates/libsyntax2/tests/data/parser/inline/0054_impl_item_items.rs
new file mode 100644
index 000000000..f10851487
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0054_impl_item_items.rs
@@ -0,0 +1,6 @@
+impl F {
+    type A = i32;
+    const B: i32 = 92;
+    fn foo() {}
+    fn bar(&self) {}
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0054_impl_item_items.txt b/crates/libsyntax2/tests/data/parser/inline/0054_impl_item_items.txt
new file mode 100644
index 000000000..739ecbbcd
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0054_impl_item_items.txt
@@ -0,0 +1,77 @@
+FILE@[0; 89)
+  IMPL_ITEM@[0; 88)
+    IMPL_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    PATH_TYPE@[5; 6)
+      PATH@[5; 6)
+        PATH_SEGMENT@[5; 6)
+          NAME_REF@[5; 6)
+            IDENT@[5; 6) "F"
+    WHITESPACE@[6; 7)
+    L_CURLY@[7; 8)
+    WHITESPACE@[8; 13)
+    TYPE_ITEM@[13; 26)
+      TYPE_KW@[13; 17)
+      WHITESPACE@[17; 18)
+      NAME@[18; 19)
+        IDENT@[18; 19) "A"
+      WHITESPACE@[19; 20)
+      EQ@[20; 21)
+      WHITESPACE@[21; 22)
+      PATH_TYPE@[22; 25)
+        PATH@[22; 25)
+          PATH_SEGMENT@[22; 25)
+            NAME_REF@[22; 25)
+              IDENT@[22; 25) "i32"
+      SEMI@[25; 26)
+    WHITESPACE@[26; 31)
+    CONST_ITEM@[31; 49)
+      CONST_KW@[31; 36)
+      WHITESPACE@[36; 37)
+      NAME@[37; 38)
+        IDENT@[37; 38) "B"
+      COLON@[38; 39)
+      WHITESPACE@[39; 40)
+      PATH_TYPE@[40; 43)
+        PATH@[40; 43)
+          PATH_SEGMENT@[40; 43)
+            NAME_REF@[40; 43)
+              IDENT@[40; 43) "i32"
+      WHITESPACE@[43; 44)
+      EQ@[44; 45)
+      WHITESPACE@[45; 46)
+      LITERAL@[46; 48)
+        INT_NUMBER@[46; 48) "92"
+      SEMI@[48; 49)
+    WHITESPACE@[49; 54)
+    FUNCTION@[54; 65)
+      FN_KW@[54; 56)
+      WHITESPACE@[56; 57)
+      NAME@[57; 60)
+        IDENT@[57; 60) "foo"
+      PARAM_LIST@[60; 62)
+        L_PAREN@[60; 61)
+        R_PAREN@[61; 62)
+      WHITESPACE@[62; 63)
+      BLOCK_EXPR@[63; 65)
+        L_CURLY@[63; 64)
+        R_CURLY@[64; 65)
+    WHITESPACE@[65; 70)
+    FUNCTION@[70; 86)
+      FN_KW@[70; 72)
+      WHITESPACE@[72; 73)
+      NAME@[73; 76)
+        IDENT@[73; 76) "bar"
+      PARAM_LIST@[76; 83)
+        L_PAREN@[76; 77)
+        SELF_PARAM@[77; 82)
+          AMP@[77; 78)
+          SELF_KW@[78; 82)
+        R_PAREN@[82; 83)
+      WHITESPACE@[83; 84)
+      BLOCK_EXPR@[84; 86)
+        L_CURLY@[84; 85)
+        R_CURLY@[85; 86)
+    WHITESPACE@[86; 87)
+    R_CURLY@[87; 88)
+  WHITESPACE@[88; 89)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0055_self_param.rs b/crates/libsyntax2/tests/data/parser/inline/0055_self_param.rs
new file mode 100644
index 000000000..7bb1ca50c
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0055_self_param.rs
@@ -0,0 +1,6 @@
+impl S {
+    fn a(self) {}
+    fn b(&self,) {}
+    fn c(&'a self,) {}
+    fn d(&'a mut self, x: i32) {}
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0055_self_param.txt b/crates/libsyntax2/tests/data/parser/inline/0055_self_param.txt
new file mode 100644
index 000000000..1275fb8b1
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0055_self_param.txt
@@ -0,0 +1,98 @@
+FILE@[0; 106)
+  IMPL_ITEM@[0; 105)
+    IMPL_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    PATH_TYPE@[5; 6)
+      PATH@[5; 6)
+        PATH_SEGMENT@[5; 6)
+          NAME_REF@[5; 6)
+            IDENT@[5; 6) "S"
+    WHITESPACE@[6; 7)
+    L_CURLY@[7; 8)
+    WHITESPACE@[8; 13)
+    FUNCTION@[13; 26)
+      FN_KW@[13; 15)
+      WHITESPACE@[15; 16)
+      NAME@[16; 17)
+        IDENT@[16; 17) "a"
+      PARAM_LIST@[17; 23)
+        L_PAREN@[17; 18)
+        SELF_PARAM@[18; 22)
+          SELF_KW@[18; 22)
+        R_PAREN@[22; 23)
+      WHITESPACE@[23; 24)
+      BLOCK_EXPR@[24; 26)
+        L_CURLY@[24; 25)
+        R_CURLY@[25; 26)
+    WHITESPACE@[26; 31)
+    FUNCTION@[31; 46)
+      FN_KW@[31; 33)
+      WHITESPACE@[33; 34)
+      NAME@[34; 35)
+        IDENT@[34; 35) "b"
+      PARAM_LIST@[35; 43)
+        L_PAREN@[35; 36)
+        SELF_PARAM@[36; 41)
+          AMP@[36; 37)
+          SELF_KW@[37; 41)
+        COMMA@[41; 42)
+        R_PAREN@[42; 43)
+      WHITESPACE@[43; 44)
+      BLOCK_EXPR@[44; 46)
+        L_CURLY@[44; 45)
+        R_CURLY@[45; 46)
+    WHITESPACE@[46; 51)
+    FUNCTION@[51; 69)
+      FN_KW@[51; 53)
+      WHITESPACE@[53; 54)
+      NAME@[54; 55)
+        IDENT@[54; 55) "c"
+      PARAM_LIST@[55; 66)
+        L_PAREN@[55; 56)
+        SELF_PARAM@[56; 64)
+          AMP@[56; 57)
+          LIFETIME@[57; 59) "'a"
+          WHITESPACE@[59; 60)
+          SELF_KW@[60; 64)
+        COMMA@[64; 65)
+        R_PAREN@[65; 66)
+      WHITESPACE@[66; 67)
+      BLOCK_EXPR@[67; 69)
+        L_CURLY@[67; 68)
+        R_CURLY@[68; 69)
+    WHITESPACE@[69; 74)
+    FUNCTION@[74; 103)
+      FN_KW@[74; 76)
+      WHITESPACE@[76; 77)
+      NAME@[77; 78)
+        IDENT@[77; 78) "d"
+      PARAM_LIST@[78; 100)
+        L_PAREN@[78; 79)
+        SELF_PARAM@[79; 91)
+          AMP@[79; 80)
+          LIFETIME@[80; 82) "'a"
+          WHITESPACE@[82; 83)
+          MUT_KW@[83; 86)
+          WHITESPACE@[86; 87)
+          SELF_KW@[87; 91)
+        COMMA@[91; 92)
+        WHITESPACE@[92; 93)
+        PARAM@[93; 99)
+          BIND_PAT@[93; 94)
+            NAME@[93; 94)
+              IDENT@[93; 94) "x"
+          COLON@[94; 95)
+          WHITESPACE@[95; 96)
+          PATH_TYPE@[96; 99)
+            PATH@[96; 99)
+              PATH_SEGMENT@[96; 99)
+                NAME_REF@[96; 99)
+                  IDENT@[96; 99) "i32"
+        R_PAREN@[99; 100)
+      WHITESPACE@[100; 101)
+      BLOCK_EXPR@[101; 103)
+        L_CURLY@[101; 102)
+        R_CURLY@[102; 103)
+    WHITESPACE@[103; 104)
+    R_CURLY@[104; 105)
+  WHITESPACE@[105; 106)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0056_trait_item.rs b/crates/libsyntax2/tests/data/parser/inline/0056_trait_item.rs
new file mode 100644
index 000000000..4385afca9
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0056_trait_item.rs
@@ -0,0 +1 @@
+trait T<U>: Hash + Clone where U: Copy {}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0056_trait_item.txt b/crates/libsyntax2/tests/data/parser/inline/0056_trait_item.txt
new file mode 100644
index 000000000..ba4e0ebc8
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0056_trait_item.txt
@@ -0,0 +1,45 @@
+FILE@[0; 42)
+  TRAIT_ITEM@[0; 41)
+    TRAIT_KW@[0; 5)
+    WHITESPACE@[5; 6)
+    NAME@[6; 7)
+      IDENT@[6; 7) "T"
+    TYPE_PARAM_LIST@[7; 10)
+      L_ANGLE@[7; 8)
+      TYPE_PARAM@[8; 9)
+        NAME@[8; 9)
+          IDENT@[8; 9) "U"
+      R_ANGLE@[9; 10)
+    COLON@[10; 11)
+    WHITESPACE@[11; 12)
+    PATH@[12; 16)
+      PATH_SEGMENT@[12; 16)
+        NAME_REF@[12; 16)
+          IDENT@[12; 16) "Hash"
+    WHITESPACE@[16; 17)
+    PLUS@[17; 18)
+    WHITESPACE@[18; 19)
+    PATH@[19; 24)
+      PATH_SEGMENT@[19; 24)
+        NAME_REF@[19; 24)
+          IDENT@[19; 24) "Clone"
+    WHITESPACE@[24; 25)
+    WHERE_CLAUSE@[25; 38)
+      WHERE_KW@[25; 30)
+      WHITESPACE@[30; 31)
+      WHERE_PRED@[31; 38)
+        PATH_TYPE@[31; 32)
+          PATH@[31; 32)
+            PATH_SEGMENT@[31; 32)
+              NAME_REF@[31; 32)
+                IDENT@[31; 32) "U"
+        COLON@[32; 33)
+        WHITESPACE@[33; 34)
+        PATH@[34; 38)
+          PATH_SEGMENT@[34; 38)
+            NAME_REF@[34; 38)
+              IDENT@[34; 38) "Copy"
+    WHITESPACE@[38; 39)
+    L_CURLY@[39; 40)
+    R_CURLY@[40; 41)
+  WHITESPACE@[41; 42)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0057_auto_trait.rs b/crates/libsyntax2/tests/data/parser/inline/0057_auto_trait.rs
new file mode 100644
index 000000000..72adf6035
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0057_auto_trait.rs
@@ -0,0 +1 @@
+auto trait T {}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0057_auto_trait.txt b/crates/libsyntax2/tests/data/parser/inline/0057_auto_trait.txt
new file mode 100644
index 000000000..6bb4ffdba
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0057_auto_trait.txt
@@ -0,0 +1,12 @@
+FILE@[0; 16)
+  TRAIT_ITEM@[0; 15)
+    AUTO_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    TRAIT_KW@[5; 10)
+    WHITESPACE@[10; 11)
+    NAME@[11; 12)
+      IDENT@[11; 12) "T"
+    WHITESPACE@[12; 13)
+    L_CURLY@[13; 14)
+    R_CURLY@[14; 15)
+  WHITESPACE@[15; 16)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0058_type_arg.rs b/crates/libsyntax2/tests/data/parser/inline/0058_type_arg.rs
new file mode 100644
index 000000000..f0c8cc3a8
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0058_type_arg.rs
@@ -0,0 +1 @@
+type A = B<'static, i32, Item=u64>
diff --git a/crates/libsyntax2/tests/data/parser/inline/0058_type_arg.txt b/crates/libsyntax2/tests/data/parser/inline/0058_type_arg.txt
new file mode 100644
index 000000000..f69ce4738
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0058_type_arg.txt
@@ -0,0 +1,40 @@
+FILE@[0; 35)
+  TYPE_ITEM@[0; 34)
+    TYPE_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 6)
+      IDENT@[5; 6) "A"
+    WHITESPACE@[6; 7)
+    EQ@[7; 8)
+    WHITESPACE@[8; 9)
+    PATH_TYPE@[9; 34)
+      PATH@[9; 34)
+        PATH_SEGMENT@[9; 34)
+          NAME_REF@[9; 10)
+            IDENT@[9; 10) "B"
+          TYPE_ARG_LIST@[10; 34)
+            L_ANGLE@[10; 11)
+            LIFETIME_ARG@[11; 18)
+              LIFETIME@[11; 18) "'static"
+            COMMA@[18; 19)
+            WHITESPACE@[19; 20)
+            TYPE_ARG@[20; 23)
+              PATH_TYPE@[20; 23)
+                PATH@[20; 23)
+                  PATH_SEGMENT@[20; 23)
+                    NAME_REF@[20; 23)
+                      IDENT@[20; 23) "i32"
+            COMMA@[23; 24)
+            WHITESPACE@[24; 25)
+            ASSOC_TYPE_ARG@[25; 33)
+              NAME_REF@[25; 29)
+                IDENT@[25; 29) "Item"
+              EQ@[29; 30)
+              PATH_TYPE@[30; 33)
+                PATH@[30; 33)
+                  PATH_SEGMENT@[30; 33)
+                    NAME_REF@[30; 33)
+                      IDENT@[30; 33) "u64"
+            R_ANGLE@[33; 34)
+            err: `expected SEMI`
+  WHITESPACE@[34; 35)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0059_function_where_clause.rs b/crates/libsyntax2/tests/data/parser/inline/0059_function_where_clause.rs
new file mode 100644
index 000000000..f0920b2a8
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0059_function_where_clause.rs
@@ -0,0 +1 @@
+fn foo<T>() where T: Copy {}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0059_function_where_clause.txt b/crates/libsyntax2/tests/data/parser/inline/0059_function_where_clause.txt
new file mode 100644
index 000000000..065b0fd21
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0059_function_where_clause.txt
@@ -0,0 +1,36 @@
+FILE@[0; 29)
+  FUNCTION@[0; 28)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    TYPE_PARAM_LIST@[6; 9)
+      L_ANGLE@[6; 7)
+      TYPE_PARAM@[7; 8)
+        NAME@[7; 8)
+          IDENT@[7; 8) "T"
+      R_ANGLE@[8; 9)
+    PARAM_LIST@[9; 11)
+      L_PAREN@[9; 10)
+      R_PAREN@[10; 11)
+    WHITESPACE@[11; 12)
+    WHERE_CLAUSE@[12; 25)
+      WHERE_KW@[12; 17)
+      WHITESPACE@[17; 18)
+      WHERE_PRED@[18; 25)
+        PATH_TYPE@[18; 19)
+          PATH@[18; 19)
+            PATH_SEGMENT@[18; 19)
+              NAME_REF@[18; 19)
+                IDENT@[18; 19) "T"
+        COLON@[19; 20)
+        WHITESPACE@[20; 21)
+        PATH@[21; 25)
+          PATH_SEGMENT@[21; 25)
+            NAME_REF@[21; 25)
+              IDENT@[21; 25) "Copy"
+    WHITESPACE@[25; 26)
+    BLOCK_EXPR@[26; 28)
+      L_CURLY@[26; 27)
+      R_CURLY@[27; 28)
+  WHITESPACE@[28; 29)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0060_function_type_params.rs b/crates/libsyntax2/tests/data/parser/inline/0060_function_type_params.rs
new file mode 100644
index 000000000..9df40ed39
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0060_function_type_params.rs
@@ -0,0 +1 @@
+fn foo<T: Clone + Copy>(){}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0060_function_type_params.txt b/crates/libsyntax2/tests/data/parser/inline/0060_function_type_params.txt
new file mode 100644
index 000000000..8809ebc04
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0060_function_type_params.txt
@@ -0,0 +1,32 @@
+FILE@[0; 28)
+  FUNCTION@[0; 27)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    TYPE_PARAM_LIST@[6; 23)
+      L_ANGLE@[6; 7)
+      TYPE_PARAM@[7; 22)
+        NAME@[7; 8)
+          IDENT@[7; 8) "T"
+        COLON@[8; 9)
+        WHITESPACE@[9; 10)
+        PATH@[10; 15)
+          PATH_SEGMENT@[10; 15)
+            NAME_REF@[10; 15)
+              IDENT@[10; 15) "Clone"
+        WHITESPACE@[15; 16)
+        PLUS@[16; 17)
+        WHITESPACE@[17; 18)
+        PATH@[18; 22)
+          PATH_SEGMENT@[18; 22)
+            NAME_REF@[18; 22)
+              IDENT@[18; 22) "Copy"
+      R_ANGLE@[22; 23)
+    PARAM_LIST@[23; 25)
+      L_PAREN@[23; 24)
+      R_PAREN@[24; 25)
+    BLOCK_EXPR@[25; 27)
+      L_CURLY@[25; 26)
+      R_CURLY@[26; 27)
+  WHITESPACE@[27; 28)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0061_struct_lit.rs b/crates/libsyntax2/tests/data/parser/inline/0061_struct_lit.rs
new file mode 100644
index 000000000..eb711f68a
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0061_struct_lit.rs
@@ -0,0 +1,5 @@
+fn foo() {
+    S {};
+    S { x, y: 32, };
+    S { x, y: 32, ..Default::default() };
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0061_struct_lit.txt b/crates/libsyntax2/tests/data/parser/inline/0061_struct_lit.txt
new file mode 100644
index 000000000..1d048c5ba
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0061_struct_lit.txt
@@ -0,0 +1,94 @@
+FILE@[0; 86)
+  FUNCTION@[0; 85)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 85)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      EXPR_STMT@[15; 20)
+        STRUCT_LIT@[15; 19)
+          PATH@[15; 16)
+            PATH_SEGMENT@[15; 16)
+              NAME_REF@[15; 16)
+                IDENT@[15; 16) "S"
+          WHITESPACE@[16; 17)
+          L_CURLY@[17; 18)
+          R_CURLY@[18; 19)
+        SEMI@[19; 20)
+      WHITESPACE@[20; 25)
+      EXPR_STMT@[25; 41)
+        STRUCT_LIT@[25; 40)
+          PATH@[25; 26)
+            PATH_SEGMENT@[25; 26)
+              NAME_REF@[25; 26)
+                IDENT@[25; 26) "S"
+          WHITESPACE@[26; 27)
+          L_CURLY@[27; 28)
+          WHITESPACE@[28; 29)
+          STRUCT_LIT_FIELD@[29; 30)
+            NAME_REF@[29; 30)
+              IDENT@[29; 30) "x"
+          COMMA@[30; 31)
+          WHITESPACE@[31; 32)
+          STRUCT_LIT_FIELD@[32; 37)
+            NAME_REF@[32; 33)
+              IDENT@[32; 33) "y"
+            COLON@[33; 34)
+            WHITESPACE@[34; 35)
+            LITERAL@[35; 37)
+              INT_NUMBER@[35; 37) "32"
+          COMMA@[37; 38)
+          WHITESPACE@[38; 39)
+          R_CURLY@[39; 40)
+        SEMI@[40; 41)
+      WHITESPACE@[41; 46)
+      EXPR_STMT@[46; 83)
+        STRUCT_LIT@[46; 82)
+          PATH@[46; 47)
+            PATH_SEGMENT@[46; 47)
+              NAME_REF@[46; 47)
+                IDENT@[46; 47) "S"
+          WHITESPACE@[47; 48)
+          L_CURLY@[48; 49)
+          WHITESPACE@[49; 50)
+          STRUCT_LIT_FIELD@[50; 51)
+            NAME_REF@[50; 51)
+              IDENT@[50; 51) "x"
+          COMMA@[51; 52)
+          WHITESPACE@[52; 53)
+          STRUCT_LIT_FIELD@[53; 58)
+            NAME_REF@[53; 54)
+              IDENT@[53; 54) "y"
+            COLON@[54; 55)
+            WHITESPACE@[55; 56)
+            LITERAL@[56; 58)
+              INT_NUMBER@[56; 58) "32"
+          COMMA@[58; 59)
+          WHITESPACE@[59; 60)
+          DOTDOT@[60; 62)
+          CALL_EXPR@[62; 80)
+            PATH_EXPR@[62; 78)
+              PATH@[62; 78)
+                PATH@[62; 69)
+                  PATH_SEGMENT@[62; 69)
+                    NAME_REF@[62; 69)
+                      IDENT@[62; 69) "Default"
+                COLONCOLON@[69; 71)
+                PATH_SEGMENT@[71; 78)
+                  NAME_REF@[71; 78)
+                    IDENT@[71; 78) "default"
+            ARG_LIST@[78; 80)
+              L_PAREN@[78; 79)
+              R_PAREN@[79; 80)
+          WHITESPACE@[80; 81)
+          R_CURLY@[81; 82)
+        SEMI@[82; 83)
+      WHITESPACE@[83; 84)
+      R_CURLY@[84; 85)
+  WHITESPACE@[85; 86)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0063_impl_trait_type.rs b/crates/libsyntax2/tests/data/parser/inline/0063_impl_trait_type.rs
new file mode 100644
index 000000000..54c5a7c46
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0063_impl_trait_type.rs
@@ -0,0 +1 @@
+type A = impl Iterator<Item=Foo<'a>> + 'a;
diff --git a/crates/libsyntax2/tests/data/parser/inline/0063_impl_trait_type.txt b/crates/libsyntax2/tests/data/parser/inline/0063_impl_trait_type.txt
new file mode 100644
index 000000000..bbebf1086
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0063_impl_trait_type.txt
@@ -0,0 +1,39 @@
+FILE@[0; 43)
+  TYPE_ITEM@[0; 42)
+    TYPE_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 6)
+      IDENT@[5; 6) "A"
+    WHITESPACE@[6; 7)
+    EQ@[7; 8)
+    WHITESPACE@[8; 9)
+    IMPL_TRAIT_TYPE@[9; 41)
+      IMPL_KW@[9; 13)
+      WHITESPACE@[13; 14)
+      PATH@[14; 36)
+        PATH_SEGMENT@[14; 36)
+          NAME_REF@[14; 22)
+            IDENT@[14; 22) "Iterator"
+          TYPE_ARG_LIST@[22; 36)
+            L_ANGLE@[22; 23)
+            ASSOC_TYPE_ARG@[23; 35)
+              NAME_REF@[23; 27)
+                IDENT@[23; 27) "Item"
+              EQ@[27; 28)
+              PATH_TYPE@[28; 35)
+                PATH@[28; 35)
+                  PATH_SEGMENT@[28; 35)
+                    NAME_REF@[28; 31)
+                      IDENT@[28; 31) "Foo"
+                    TYPE_ARG_LIST@[31; 35)
+                      L_ANGLE@[31; 32)
+                      LIFETIME_ARG@[32; 34)
+                        LIFETIME@[32; 34) "'a"
+                      R_ANGLE@[34; 35)
+            R_ANGLE@[35; 36)
+      WHITESPACE@[36; 37)
+      PLUS@[37; 38)
+      WHITESPACE@[38; 39)
+      LIFETIME@[39; 41) "'a"
+    SEMI@[41; 42)
+  WHITESPACE@[42; 43)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0063_lambda_expr.txt b/crates/libsyntax2/tests/data/parser/inline/0063_lambda_expr.txt
new file mode 100644
index 000000000..122a99e52
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0063_lambda_expr.txt
@@ -0,0 +1,91 @@
+FILE@[0; 74)
+  FUNCTION@[0; 74)
+    FN_KW@[0; 2)
+    NAME@[2; 6)
+      WHITESPACE@[2; 3)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 9)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+      WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 74)
+      L_CURLY@[9; 10)
+      EXPR_STMT@[10; 26)
+        LAMBDA_EXPR@[10; 20)
+          PARAM_LIST@[10; 18)
+            WHITESPACE@[10; 15)
+            PIPE@[15; 16)
+            PIPE@[16; 17)
+            WHITESPACE@[17; 18)
+          TUPLE_EXPR@[18; 20)
+            L_PAREN@[18; 19)
+            R_PAREN@[19; 20)
+        SEMI@[20; 21)
+        WHITESPACE@[21; 26)
+      EXPR_STMT@[26; 48)
+        LAMBDA_EXPR@[26; 42)
+          PARAM_LIST@[26; 29)
+            PIPE@[26; 27)
+            PIPE@[27; 28)
+            WHITESPACE@[28; 29)
+          THIN_ARROW@[29; 31)
+          PATH_TYPE@[31; 36)
+            PATH@[31; 36)
+              PATH_SEGMENT@[31; 36)
+                NAME_REF@[31; 36)
+                  WHITESPACE@[31; 32)
+                  IDENT@[32; 35) "i32"
+                  WHITESPACE@[35; 36)
+          BLOCK_EXPR@[36; 42)
+            L_CURLY@[36; 37)
+            LITERAL@[37; 41)
+              WHITESPACE@[37; 38)
+              INT_NUMBER@[38; 40) "92"
+              WHITESPACE@[40; 41)
+            R_CURLY@[41; 42)
+        SEMI@[42; 43)
+        WHITESPACE@[43; 48)
+      EXPR_STMT@[48; 59)
+        LAMBDA_EXPR@[48; 53)
+          PARAM_LIST@[48; 52)
+            PIPE@[48; 49)
+            PARAM@[49; 50)
+              BIND_PAT@[49; 50)
+                NAME@[49; 50)
+                  IDENT@[49; 50) "x"
+            PIPE@[50; 51)
+            WHITESPACE@[51; 52)
+          PATH_EXPR@[52; 53)
+            PATH@[52; 53)
+              PATH_SEGMENT@[52; 53)
+                NAME_REF@[52; 53)
+                  IDENT@[52; 53) "x"
+        SEMI@[53; 54)
+        WHITESPACE@[54; 59)
+      EXPR_STMT@[59; 72)
+        LAMBDA_EXPR@[59; 70)
+          PARAM_LIST@[59; 69)
+            PIPE@[59; 60)
+            PARAM@[60; 66)
+              BIND_PAT@[60; 61)
+                NAME@[60; 61)
+                  IDENT@[60; 61) "x"
+              COLON@[61; 62)
+              PATH_TYPE@[62; 66)
+                PATH@[62; 66)
+                  PATH_SEGMENT@[62; 66)
+                    NAME_REF@[62; 66)
+                      WHITESPACE@[62; 63)
+                      IDENT@[63; 66) "i32"
+            COMMA@[66; 67)
+            PIPE@[67; 68)
+            WHITESPACE@[68; 69)
+          PATH_EXPR@[69; 70)
+            PATH@[69; 70)
+              PATH_SEGMENT@[69; 70)
+                NAME_REF@[69; 70)
+                  IDENT@[69; 70) "x"
+        SEMI@[70; 71)
+        WHITESPACE@[71; 72)
+      R_CURLY@[72; 73)
+      WHITESPACE@[73; 74)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0064_param_list.rs b/crates/libsyntax2/tests/data/parser/inline/0064_param_list.rs
new file mode 100644
index 000000000..9d55bedbb
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0064_param_list.rs
@@ -0,0 +1,4 @@
+fn a() {}
+fn b(x: i32) {}
+fn c(x: i32, ) {}
+fn d(x: i32, y: ()) {}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0064_param_list.txt b/crates/libsyntax2/tests/data/parser/inline/0064_param_list.txt
new file mode 100644
index 000000000..14db495b9
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0064_param_list.txt
@@ -0,0 +1,99 @@
+FILE@[0; 67)
+  FUNCTION@[0; 9)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 4)
+      IDENT@[3; 4) "a"
+    PARAM_LIST@[4; 6)
+      L_PAREN@[4; 5)
+      R_PAREN@[5; 6)
+    WHITESPACE@[6; 7)
+    BLOCK_EXPR@[7; 9)
+      L_CURLY@[7; 8)
+      R_CURLY@[8; 9)
+  WHITESPACE@[9; 10)
+  FUNCTION@[10; 25)
+    FN_KW@[10; 12)
+    WHITESPACE@[12; 13)
+    NAME@[13; 14)
+      IDENT@[13; 14) "b"
+    PARAM_LIST@[14; 22)
+      L_PAREN@[14; 15)
+      PARAM@[15; 21)
+        BIND_PAT@[15; 16)
+          NAME@[15; 16)
+            IDENT@[15; 16) "x"
+        COLON@[16; 17)
+        WHITESPACE@[17; 18)
+        PATH_TYPE@[18; 21)
+          PATH@[18; 21)
+            PATH_SEGMENT@[18; 21)
+              NAME_REF@[18; 21)
+                IDENT@[18; 21) "i32"
+      R_PAREN@[21; 22)
+    WHITESPACE@[22; 23)
+    BLOCK_EXPR@[23; 25)
+      L_CURLY@[23; 24)
+      R_CURLY@[24; 25)
+  WHITESPACE@[25; 26)
+  FUNCTION@[26; 43)
+    FN_KW@[26; 28)
+    WHITESPACE@[28; 29)
+    NAME@[29; 30)
+      IDENT@[29; 30) "c"
+    PARAM_LIST@[30; 40)
+      L_PAREN@[30; 31)
+      PARAM@[31; 37)
+        BIND_PAT@[31; 32)
+          NAME@[31; 32)
+            IDENT@[31; 32) "x"
+        COLON@[32; 33)
+        WHITESPACE@[33; 34)
+        PATH_TYPE@[34; 37)
+          PATH@[34; 37)
+            PATH_SEGMENT@[34; 37)
+              NAME_REF@[34; 37)
+                IDENT@[34; 37) "i32"
+      COMMA@[37; 38)
+      WHITESPACE@[38; 39)
+      R_PAREN@[39; 40)
+    WHITESPACE@[40; 41)
+    BLOCK_EXPR@[41; 43)
+      L_CURLY@[41; 42)
+      R_CURLY@[42; 43)
+  WHITESPACE@[43; 44)
+  FUNCTION@[44; 66)
+    FN_KW@[44; 46)
+    WHITESPACE@[46; 47)
+    NAME@[47; 48)
+      IDENT@[47; 48) "d"
+    PARAM_LIST@[48; 63)
+      L_PAREN@[48; 49)
+      PARAM@[49; 55)
+        BIND_PAT@[49; 50)
+          NAME@[49; 50)
+            IDENT@[49; 50) "x"
+        COLON@[50; 51)
+        WHITESPACE@[51; 52)
+        PATH_TYPE@[52; 55)
+          PATH@[52; 55)
+            PATH_SEGMENT@[52; 55)
+              NAME_REF@[52; 55)
+                IDENT@[52; 55) "i32"
+      COMMA@[55; 56)
+      WHITESPACE@[56; 57)
+      PARAM@[57; 62)
+        BIND_PAT@[57; 58)
+          NAME@[57; 58)
+            IDENT@[57; 58) "y"
+        COLON@[58; 59)
+        WHITESPACE@[59; 60)
+        TUPLE_TYPE@[60; 62)
+          L_PAREN@[60; 61)
+          R_PAREN@[61; 62)
+      R_PAREN@[62; 63)
+    WHITESPACE@[63; 64)
+    BLOCK_EXPR@[64; 66)
+      L_CURLY@[64; 65)
+      R_CURLY@[65; 66)
+  WHITESPACE@[66; 67)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0065_if_expr.rs b/crates/libsyntax2/tests/data/parser/inline/0065_if_expr.rs
new file mode 100644
index 000000000..4b0d9af89
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0065_if_expr.rs
@@ -0,0 +1,6 @@
+fn foo() {
+    if true {};
+    if true {} else {};
+    if true {} else if false {} else {};
+    if S {};
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0065_if_expr.txt b/crates/libsyntax2/tests/data/parser/inline/0065_if_expr.txt
new file mode 100644
index 000000000..6ed53264a
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0065_if_expr.txt
@@ -0,0 +1,90 @@
+FILE@[0; 107)
+  FUNCTION@[0; 106)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 106)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      EXPR_STMT@[15; 26)
+        IF_EXPR@[15; 25)
+          IF_KW@[15; 17)
+          WHITESPACE@[17; 18)
+          LITERAL@[18; 22)
+            TRUE_KW@[18; 22)
+          WHITESPACE@[22; 23)
+          BLOCK_EXPR@[23; 25)
+            L_CURLY@[23; 24)
+            R_CURLY@[24; 25)
+        SEMI@[25; 26)
+      WHITESPACE@[26; 31)
+      EXPR_STMT@[31; 50)
+        IF_EXPR@[31; 49)
+          IF_KW@[31; 33)
+          WHITESPACE@[33; 34)
+          LITERAL@[34; 38)
+            TRUE_KW@[34; 38)
+          WHITESPACE@[38; 39)
+          BLOCK_EXPR@[39; 41)
+            L_CURLY@[39; 40)
+            R_CURLY@[40; 41)
+          WHITESPACE@[41; 42)
+          ELSE_KW@[42; 46)
+          WHITESPACE@[46; 47)
+          BLOCK_EXPR@[47; 49)
+            L_CURLY@[47; 48)
+            R_CURLY@[48; 49)
+        SEMI@[49; 50)
+      WHITESPACE@[50; 55)
+      EXPR_STMT@[55; 91)
+        IF_EXPR@[55; 90)
+          IF_KW@[55; 57)
+          WHITESPACE@[57; 58)
+          LITERAL@[58; 62)
+            TRUE_KW@[58; 62)
+          WHITESPACE@[62; 63)
+          BLOCK_EXPR@[63; 65)
+            L_CURLY@[63; 64)
+            R_CURLY@[64; 65)
+          WHITESPACE@[65; 66)
+          ELSE_KW@[66; 70)
+          WHITESPACE@[70; 71)
+          IF_EXPR@[71; 90)
+            IF_KW@[71; 73)
+            WHITESPACE@[73; 74)
+            LITERAL@[74; 79)
+              FALSE_KW@[74; 79)
+            WHITESPACE@[79; 80)
+            BLOCK_EXPR@[80; 82)
+              L_CURLY@[80; 81)
+              R_CURLY@[81; 82)
+            WHITESPACE@[82; 83)
+            ELSE_KW@[83; 87)
+            WHITESPACE@[87; 88)
+            BLOCK_EXPR@[88; 90)
+              L_CURLY@[88; 89)
+              R_CURLY@[89; 90)
+        SEMI@[90; 91)
+      WHITESPACE@[91; 96)
+      EXPR_STMT@[96; 104)
+        IF_EXPR@[96; 103)
+          IF_KW@[96; 98)
+          WHITESPACE@[98; 99)
+          PATH_EXPR@[99; 100)
+            PATH@[99; 100)
+              PATH_SEGMENT@[99; 100)
+                NAME_REF@[99; 100)
+                  IDENT@[99; 100) "S"
+          WHITESPACE@[100; 101)
+          BLOCK_EXPR@[101; 103)
+            L_CURLY@[101; 102)
+            R_CURLY@[102; 103)
+        SEMI@[103; 104)
+      WHITESPACE@[104; 105)
+      R_CURLY@[105; 106)
+  WHITESPACE@[106; 107)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0066_lambda_expr.rs b/crates/libsyntax2/tests/data/parser/inline/0066_lambda_expr.rs
new file mode 100644
index 000000000..c20d29751
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0066_lambda_expr.rs
@@ -0,0 +1,6 @@
+fn foo() {
+    || ();
+    || -> i32 { 92 };
+    |x| x;
+    move |x: i32,| x;
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0066_lambda_expr.txt b/crates/libsyntax2/tests/data/parser/inline/0066_lambda_expr.txt
new file mode 100644
index 000000000..6d9aeb331
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0066_lambda_expr.txt
@@ -0,0 +1,93 @@
+FILE@[0; 79)
+  FUNCTION@[0; 78)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 78)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      EXPR_STMT@[15; 21)
+        LAMBDA_EXPR@[15; 20)
+          PARAM_LIST@[15; 17)
+            PIPE@[15; 16)
+            PIPE@[16; 17)
+          WHITESPACE@[17; 18)
+          TUPLE_EXPR@[18; 20)
+            L_PAREN@[18; 19)
+            R_PAREN@[19; 20)
+        SEMI@[20; 21)
+      WHITESPACE@[21; 26)
+      EXPR_STMT@[26; 43)
+        LAMBDA_EXPR@[26; 42)
+          PARAM_LIST@[26; 28)
+            PIPE@[26; 27)
+            PIPE@[27; 28)
+          WHITESPACE@[28; 29)
+          THIN_ARROW@[29; 31)
+          WHITESPACE@[31; 32)
+          PATH_TYPE@[32; 35)
+            PATH@[32; 35)
+              PATH_SEGMENT@[32; 35)
+                NAME_REF@[32; 35)
+                  IDENT@[32; 35) "i32"
+          WHITESPACE@[35; 36)
+          BLOCK_EXPR@[36; 42)
+            L_CURLY@[36; 37)
+            WHITESPACE@[37; 38)
+            LITERAL@[38; 40)
+              INT_NUMBER@[38; 40) "92"
+            WHITESPACE@[40; 41)
+            R_CURLY@[41; 42)
+        SEMI@[42; 43)
+      WHITESPACE@[43; 48)
+      EXPR_STMT@[48; 54)
+        LAMBDA_EXPR@[48; 53)
+          PARAM_LIST@[48; 51)
+            PIPE@[48; 49)
+            PARAM@[49; 50)
+              BIND_PAT@[49; 50)
+                NAME@[49; 50)
+                  IDENT@[49; 50) "x"
+            PIPE@[50; 51)
+          WHITESPACE@[51; 52)
+          PATH_EXPR@[52; 53)
+            PATH@[52; 53)
+              PATH_SEGMENT@[52; 53)
+                NAME_REF@[52; 53)
+                  IDENT@[52; 53) "x"
+        SEMI@[53; 54)
+      WHITESPACE@[54; 59)
+      EXPR_STMT@[59; 76)
+        LAMBDA_EXPR@[59; 75)
+          MOVE_KW@[59; 63)
+          WHITESPACE@[63; 64)
+          PARAM_LIST@[64; 73)
+            PIPE@[64; 65)
+            PARAM@[65; 71)
+              BIND_PAT@[65; 66)
+                NAME@[65; 66)
+                  IDENT@[65; 66) "x"
+              COLON@[66; 67)
+              WHITESPACE@[67; 68)
+              PATH_TYPE@[68; 71)
+                PATH@[68; 71)
+                  PATH_SEGMENT@[68; 71)
+                    NAME_REF@[68; 71)
+                      IDENT@[68; 71) "i32"
+            COMMA@[71; 72)
+            PIPE@[72; 73)
+          WHITESPACE@[73; 74)
+          PATH_EXPR@[74; 75)
+            PATH@[74; 75)
+              PATH_SEGMENT@[74; 75)
+                NAME_REF@[74; 75)
+                  IDENT@[74; 75) "x"
+        SEMI@[75; 76)
+      WHITESPACE@[76; 77)
+      R_CURLY@[77; 78)
+  WHITESPACE@[78; 79)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0067_block_expr.rs b/crates/libsyntax2/tests/data/parser/inline/0067_block_expr.rs
new file mode 100644
index 000000000..ec3780a04
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0067_block_expr.rs
@@ -0,0 +1,4 @@
+fn foo() {
+    {};
+    unsafe {};
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0067_block_expr.txt b/crates/libsyntax2/tests/data/parser/inline/0067_block_expr.txt
new file mode 100644
index 000000000..981f39e6e
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0067_block_expr.txt
@@ -0,0 +1,29 @@
+FILE@[0; 36)
+  FUNCTION@[0; 35)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 35)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      EXPR_STMT@[15; 18)
+        BLOCK_EXPR@[15; 17)
+          L_CURLY@[15; 16)
+          R_CURLY@[16; 17)
+        SEMI@[17; 18)
+      WHITESPACE@[18; 23)
+      EXPR_STMT@[23; 33)
+        BLOCK_EXPR@[23; 32)
+          UNSAFE_KW@[23; 29)
+          WHITESPACE@[29; 30)
+          L_CURLY@[30; 31)
+          R_CURLY@[31; 32)
+        SEMI@[32; 33)
+      WHITESPACE@[33; 34)
+      R_CURLY@[34; 35)
+  WHITESPACE@[35; 36)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0068_pub_expr.rs b/crates/libsyntax2/tests/data/parser/inline/0068_pub_expr.rs
new file mode 100644
index 000000000..d9d99d2d3
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0068_pub_expr.rs
@@ -0,0 +1 @@
+fn foo() { pub 92; } //FIXME
diff --git a/crates/libsyntax2/tests/data/parser/inline/0068_pub_expr.txt b/crates/libsyntax2/tests/data/parser/inline/0068_pub_expr.txt
new file mode 100644
index 000000000..92e58938b
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0068_pub_expr.txt
@@ -0,0 +1,25 @@
+FILE@[0; 29)
+  FUNCTION@[0; 20)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 20)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 11)
+      EXPR_STMT@[11; 18)
+        VISIBILITY@[11; 14)
+          PUB_KW@[11; 14)
+        WHITESPACE@[14; 15)
+        LITERAL@[15; 17)
+          INT_NUMBER@[15; 17) "92"
+        SEMI@[17; 18)
+      WHITESPACE@[18; 19)
+      R_CURLY@[19; 20)
+  WHITESPACE@[20; 21)
+  COMMENT@[21; 28)
+  WHITESPACE@[28; 29)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0068_return_expr.rs b/crates/libsyntax2/tests/data/parser/inline/0068_return_expr.rs
new file mode 100644
index 000000000..5733666b6
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0068_return_expr.rs
@@ -0,0 +1,4 @@
+fn foo() {
+    return;
+    return 92;
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0068_return_expr.txt b/crates/libsyntax2/tests/data/parser/inline/0068_return_expr.txt
new file mode 100644
index 000000000..4e4ec85b6
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0068_return_expr.txt
@@ -0,0 +1,28 @@
+FILE@[0; 40)
+  FUNCTION@[0; 39)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 39)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      EXPR_STMT@[15; 22)
+        RETURN_EXPR@[15; 21)
+          RETURN_KW@[15; 21)
+        SEMI@[21; 22)
+      WHITESPACE@[22; 27)
+      EXPR_STMT@[27; 37)
+        RETURN_EXPR@[27; 36)
+          RETURN_KW@[27; 33)
+          WHITESPACE@[33; 34)
+          LITERAL@[34; 36)
+            INT_NUMBER@[34; 36) "92"
+        SEMI@[36; 37)
+      WHITESPACE@[37; 38)
+      R_CURLY@[38; 39)
+  WHITESPACE@[39; 40)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0069_match_arm.rs b/crates/libsyntax2/tests/data/parser/inline/0069_match_arm.rs
new file mode 100644
index 000000000..2c0e88414
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0069_match_arm.rs
@@ -0,0 +1,6 @@
+fn foo() {
+    match () {
+        _ => (),
+        X | Y if Z => (),
+    };
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0069_match_arm.txt b/crates/libsyntax2/tests/data/parser/inline/0069_match_arm.txt
new file mode 100644
index 000000000..3377e8342
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0069_match_arm.txt
@@ -0,0 +1,65 @@
+FILE@[0; 78)
+  FUNCTION@[0; 77)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 77)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      EXPR_STMT@[15; 75)
+        MATCH_EXPR@[15; 74)
+          MATCH_KW@[15; 20)
+          WHITESPACE@[20; 21)
+          TUPLE_EXPR@[21; 23)
+            L_PAREN@[21; 22)
+            R_PAREN@[22; 23)
+          WHITESPACE@[23; 24)
+          L_CURLY@[24; 25)
+          WHITESPACE@[25; 34)
+          MATCH_ARM@[34; 41)
+            PLACEHOLDER_PAT@[34; 35)
+              UNDERSCORE@[34; 35)
+            WHITESPACE@[35; 36)
+            FAT_ARROW@[36; 38)
+            WHITESPACE@[38; 39)
+            TUPLE_EXPR@[39; 41)
+              L_PAREN@[39; 40)
+              R_PAREN@[40; 41)
+          COMMA@[41; 42)
+          WHITESPACE@[42; 51)
+          MATCH_ARM@[51; 67)
+            BIND_PAT@[51; 52)
+              NAME@[51; 52)
+                IDENT@[51; 52) "X"
+            WHITESPACE@[52; 53)
+            PIPE@[53; 54)
+            WHITESPACE@[54; 55)
+            BIND_PAT@[55; 56)
+              NAME@[55; 56)
+                IDENT@[55; 56) "Y"
+            WHITESPACE@[56; 57)
+            IF_KW@[57; 59)
+            WHITESPACE@[59; 60)
+            PATH_EXPR@[60; 61)
+              PATH@[60; 61)
+                PATH_SEGMENT@[60; 61)
+                  NAME_REF@[60; 61)
+                    IDENT@[60; 61) "Z"
+            WHITESPACE@[61; 62)
+            FAT_ARROW@[62; 64)
+            WHITESPACE@[64; 65)
+            TUPLE_EXPR@[65; 67)
+              L_PAREN@[65; 66)
+              R_PAREN@[66; 67)
+          COMMA@[67; 68)
+          WHITESPACE@[68; 73)
+          R_CURLY@[73; 74)
+        SEMI@[74; 75)
+      WHITESPACE@[75; 76)
+      R_CURLY@[76; 77)
+  WHITESPACE@[77; 78)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0070_match_expr.rs b/crates/libsyntax2/tests/data/parser/inline/0070_match_expr.rs
new file mode 100644
index 000000000..c9205dfa3
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0070_match_expr.rs
@@ -0,0 +1,4 @@
+fn foo() {
+    match () { };
+    match S {};
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0070_match_expr.txt b/crates/libsyntax2/tests/data/parser/inline/0070_match_expr.txt
new file mode 100644
index 000000000..f9ba54486
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0070_match_expr.txt
@@ -0,0 +1,42 @@
+FILE@[0; 47)
+  FUNCTION@[0; 46)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 46)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      EXPR_STMT@[15; 28)
+        MATCH_EXPR@[15; 27)
+          MATCH_KW@[15; 20)
+          WHITESPACE@[20; 21)
+          TUPLE_EXPR@[21; 23)
+            L_PAREN@[21; 22)
+            R_PAREN@[22; 23)
+          WHITESPACE@[23; 24)
+          L_CURLY@[24; 25)
+          WHITESPACE@[25; 26)
+          R_CURLY@[26; 27)
+        SEMI@[27; 28)
+      WHITESPACE@[28; 33)
+      EXPR_STMT@[33; 44)
+        MATCH_EXPR@[33; 43)
+          MATCH_KW@[33; 38)
+          WHITESPACE@[38; 39)
+          PATH_EXPR@[39; 40)
+            PATH@[39; 40)
+              PATH_SEGMENT@[39; 40)
+                NAME_REF@[39; 40)
+                  IDENT@[39; 40) "S"
+          WHITESPACE@[40; 41)
+          L_CURLY@[41; 42)
+          R_CURLY@[42; 43)
+        SEMI@[43; 44)
+      WHITESPACE@[44; 45)
+      R_CURLY@[45; 46)
+  WHITESPACE@[46; 47)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0071_tuple_pat_fields.rs b/crates/libsyntax2/tests/data/parser/inline/0071_tuple_pat_fields.rs
new file mode 100644
index 000000000..0dfe63629
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0071_tuple_pat_fields.rs
@@ -0,0 +1,6 @@
+fn foo() {
+    let S() = ();
+    let S(_) = ();
+    let S(_,) = ();
+    let S(_, .. , x) = ();
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0071_tuple_pat_fields.txt b/crates/libsyntax2/tests/data/parser/inline/0071_tuple_pat_fields.txt
new file mode 100644
index 000000000..f54835277
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0071_tuple_pat_fields.txt
@@ -0,0 +1,103 @@
+FILE@[0; 97)
+  FUNCTION@[0; 96)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 96)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      LET_STMT@[15; 28)
+        LET_KW@[15; 18)
+        WHITESPACE@[18; 19)
+        TUPLE_STRUCT_PAT@[19; 22)
+          PATH@[19; 20)
+            PATH_SEGMENT@[19; 20)
+              NAME_REF@[19; 20)
+                IDENT@[19; 20) "S"
+          L_PAREN@[20; 21)
+          R_PAREN@[21; 22)
+        WHITESPACE@[22; 23)
+        EQ@[23; 24)
+        WHITESPACE@[24; 25)
+        TUPLE_EXPR@[25; 27)
+          L_PAREN@[25; 26)
+          R_PAREN@[26; 27)
+        SEMI@[27; 28)
+      WHITESPACE@[28; 33)
+      LET_STMT@[33; 47)
+        LET_KW@[33; 36)
+        WHITESPACE@[36; 37)
+        TUPLE_STRUCT_PAT@[37; 41)
+          PATH@[37; 38)
+            PATH_SEGMENT@[37; 38)
+              NAME_REF@[37; 38)
+                IDENT@[37; 38) "S"
+          L_PAREN@[38; 39)
+          PLACEHOLDER_PAT@[39; 40)
+            UNDERSCORE@[39; 40)
+          R_PAREN@[40; 41)
+        WHITESPACE@[41; 42)
+        EQ@[42; 43)
+        WHITESPACE@[43; 44)
+        TUPLE_EXPR@[44; 46)
+          L_PAREN@[44; 45)
+          R_PAREN@[45; 46)
+        SEMI@[46; 47)
+      WHITESPACE@[47; 52)
+      LET_STMT@[52; 67)
+        LET_KW@[52; 55)
+        WHITESPACE@[55; 56)
+        TUPLE_STRUCT_PAT@[56; 61)
+          PATH@[56; 57)
+            PATH_SEGMENT@[56; 57)
+              NAME_REF@[56; 57)
+                IDENT@[56; 57) "S"
+          L_PAREN@[57; 58)
+          PLACEHOLDER_PAT@[58; 59)
+            UNDERSCORE@[58; 59)
+          COMMA@[59; 60)
+          R_PAREN@[60; 61)
+        WHITESPACE@[61; 62)
+        EQ@[62; 63)
+        WHITESPACE@[63; 64)
+        TUPLE_EXPR@[64; 66)
+          L_PAREN@[64; 65)
+          R_PAREN@[65; 66)
+        SEMI@[66; 67)
+      WHITESPACE@[67; 72)
+      LET_STMT@[72; 94)
+        LET_KW@[72; 75)
+        WHITESPACE@[75; 76)
+        TUPLE_STRUCT_PAT@[76; 88)
+          PATH@[76; 77)
+            PATH_SEGMENT@[76; 77)
+              NAME_REF@[76; 77)
+                IDENT@[76; 77) "S"
+          L_PAREN@[77; 78)
+          PLACEHOLDER_PAT@[78; 79)
+            UNDERSCORE@[78; 79)
+          COMMA@[79; 80)
+          WHITESPACE@[80; 81)
+          DOTDOT@[81; 83)
+          WHITESPACE@[83; 84)
+          COMMA@[84; 85)
+          WHITESPACE@[85; 86)
+          BIND_PAT@[86; 87)
+            NAME@[86; 87)
+              IDENT@[86; 87) "x"
+          R_PAREN@[87; 88)
+        WHITESPACE@[88; 89)
+        EQ@[89; 90)
+        WHITESPACE@[90; 91)
+        TUPLE_EXPR@[91; 93)
+          L_PAREN@[91; 92)
+          R_PAREN@[92; 93)
+        SEMI@[93; 94)
+      WHITESPACE@[94; 95)
+      R_CURLY@[95; 96)
+  WHITESPACE@[96; 97)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0072_path_part.rs b/crates/libsyntax2/tests/data/parser/inline/0072_path_part.rs
new file mode 100644
index 000000000..f6e32c7c1
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0072_path_part.rs
@@ -0,0 +1,6 @@
+fn foo() {
+    let foo::Bar = ();
+    let ::Bar = ();
+    let Bar { .. } = ();
+    let Bar(..) = ();
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0072_path_part.txt b/crates/libsyntax2/tests/data/parser/inline/0072_path_part.txt
new file mode 100644
index 000000000..20da5de86
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0072_path_part.txt
@@ -0,0 +1,94 @@
+FILE@[0; 103)
+  FUNCTION@[0; 102)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 102)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      LET_STMT@[15; 33)
+        LET_KW@[15; 18)
+        WHITESPACE@[18; 19)
+        PATH_PAT@[19; 27)
+          PATH@[19; 27)
+            PATH@[19; 22)
+              PATH_SEGMENT@[19; 22)
+                NAME_REF@[19; 22)
+                  IDENT@[19; 22) "foo"
+            COLONCOLON@[22; 24)
+            PATH_SEGMENT@[24; 27)
+              NAME_REF@[24; 27)
+                IDENT@[24; 27) "Bar"
+        WHITESPACE@[27; 28)
+        EQ@[28; 29)
+        WHITESPACE@[29; 30)
+        TUPLE_EXPR@[30; 32)
+          L_PAREN@[30; 31)
+          R_PAREN@[31; 32)
+        SEMI@[32; 33)
+      WHITESPACE@[33; 38)
+      LET_STMT@[38; 53)
+        LET_KW@[38; 41)
+        WHITESPACE@[41; 42)
+        PATH_PAT@[42; 47)
+          PATH@[42; 47)
+            PATH_SEGMENT@[42; 47)
+              COLONCOLON@[42; 44)
+              NAME_REF@[44; 47)
+                IDENT@[44; 47) "Bar"
+        WHITESPACE@[47; 48)
+        EQ@[48; 49)
+        WHITESPACE@[49; 50)
+        TUPLE_EXPR@[50; 52)
+          L_PAREN@[50; 51)
+          R_PAREN@[51; 52)
+        SEMI@[52; 53)
+      WHITESPACE@[53; 58)
+      LET_STMT@[58; 78)
+        LET_KW@[58; 61)
+        WHITESPACE@[61; 62)
+        STRUCT_PAT@[62; 72)
+          PATH@[62; 65)
+            PATH_SEGMENT@[62; 65)
+              NAME_REF@[62; 65)
+                IDENT@[62; 65) "Bar"
+          WHITESPACE@[65; 66)
+          L_CURLY@[66; 67)
+          WHITESPACE@[67; 68)
+          DOTDOT@[68; 70)
+          WHITESPACE@[70; 71)
+          R_CURLY@[71; 72)
+        WHITESPACE@[72; 73)
+        EQ@[73; 74)
+        WHITESPACE@[74; 75)
+        TUPLE_EXPR@[75; 77)
+          L_PAREN@[75; 76)
+          R_PAREN@[76; 77)
+        SEMI@[77; 78)
+      WHITESPACE@[78; 83)
+      LET_STMT@[83; 100)
+        LET_KW@[83; 86)
+        WHITESPACE@[86; 87)
+        TUPLE_STRUCT_PAT@[87; 94)
+          PATH@[87; 90)
+            PATH_SEGMENT@[87; 90)
+              NAME_REF@[87; 90)
+                IDENT@[87; 90) "Bar"
+          L_PAREN@[90; 91)
+          DOTDOT@[91; 93)
+          R_PAREN@[93; 94)
+        WHITESPACE@[94; 95)
+        EQ@[95; 96)
+        WHITESPACE@[96; 97)
+        TUPLE_EXPR@[97; 99)
+          L_PAREN@[97; 98)
+          R_PAREN@[98; 99)
+        SEMI@[99; 100)
+      WHITESPACE@[100; 101)
+      R_CURLY@[101; 102)
+  WHITESPACE@[102; 103)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0073_struct_pat_fields.rs b/crates/libsyntax2/tests/data/parser/inline/0073_struct_pat_fields.rs
new file mode 100644
index 000000000..da3412fa8
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0073_struct_pat_fields.rs
@@ -0,0 +1,6 @@
+fn foo() {
+    let S {} = ();
+    let S { f, ref mut g } = ();
+    let S { h: _, ..} = ();
+    let S { h: _, } = ();
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0073_struct_pat_fields.txt b/crates/libsyntax2/tests/data/parser/inline/0073_struct_pat_fields.txt
new file mode 100644
index 000000000..fc0d44f7a
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0073_struct_pat_fields.txt
@@ -0,0 +1,122 @@
+FILE@[0; 119)
+  FUNCTION@[0; 118)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 118)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      LET_STMT@[15; 29)
+        LET_KW@[15; 18)
+        WHITESPACE@[18; 19)
+        STRUCT_PAT@[19; 23)
+          PATH@[19; 20)
+            PATH_SEGMENT@[19; 20)
+              NAME_REF@[19; 20)
+                IDENT@[19; 20) "S"
+          WHITESPACE@[20; 21)
+          L_CURLY@[21; 22)
+          R_CURLY@[22; 23)
+        WHITESPACE@[23; 24)
+        EQ@[24; 25)
+        WHITESPACE@[25; 26)
+        TUPLE_EXPR@[26; 28)
+          L_PAREN@[26; 27)
+          R_PAREN@[27; 28)
+        SEMI@[28; 29)
+      WHITESPACE@[29; 34)
+      LET_STMT@[34; 62)
+        LET_KW@[34; 37)
+        WHITESPACE@[37; 38)
+        STRUCT_PAT@[38; 56)
+          PATH@[38; 39)
+            PATH_SEGMENT@[38; 39)
+              NAME_REF@[38; 39)
+                IDENT@[38; 39) "S"
+          WHITESPACE@[39; 40)
+          L_CURLY@[40; 41)
+          WHITESPACE@[41; 42)
+          BIND_PAT@[42; 43)
+            NAME@[42; 43)
+              IDENT@[42; 43) "f"
+          COMMA@[43; 44)
+          WHITESPACE@[44; 45)
+          BIND_PAT@[45; 54)
+            REF_KW@[45; 48)
+            WHITESPACE@[48; 49)
+            MUT_KW@[49; 52)
+            WHITESPACE@[52; 53)
+            NAME@[53; 54)
+              IDENT@[53; 54) "g"
+          WHITESPACE@[54; 55)
+          R_CURLY@[55; 56)
+        WHITESPACE@[56; 57)
+        EQ@[57; 58)
+        WHITESPACE@[58; 59)
+        TUPLE_EXPR@[59; 61)
+          L_PAREN@[59; 60)
+          R_PAREN@[60; 61)
+        SEMI@[61; 62)
+      WHITESPACE@[62; 67)
+      LET_STMT@[67; 90)
+        LET_KW@[67; 70)
+        WHITESPACE@[70; 71)
+        STRUCT_PAT@[71; 84)
+          PATH@[71; 72)
+            PATH_SEGMENT@[71; 72)
+              NAME_REF@[71; 72)
+                IDENT@[71; 72) "S"
+          WHITESPACE@[72; 73)
+          L_CURLY@[73; 74)
+          WHITESPACE@[74; 75)
+          IDENT@[75; 76) "h"
+          COLON@[76; 77)
+          WHITESPACE@[77; 78)
+          PLACEHOLDER_PAT@[78; 79)
+            UNDERSCORE@[78; 79)
+          COMMA@[79; 80)
+          WHITESPACE@[80; 81)
+          DOTDOT@[81; 83)
+          R_CURLY@[83; 84)
+        WHITESPACE@[84; 85)
+        EQ@[85; 86)
+        WHITESPACE@[86; 87)
+        TUPLE_EXPR@[87; 89)
+          L_PAREN@[87; 88)
+          R_PAREN@[88; 89)
+        SEMI@[89; 90)
+      WHITESPACE@[90; 95)
+      LET_STMT@[95; 116)
+        LET_KW@[95; 98)
+        WHITESPACE@[98; 99)
+        STRUCT_PAT@[99; 110)
+          PATH@[99; 100)
+            PATH_SEGMENT@[99; 100)
+              NAME_REF@[99; 100)
+                IDENT@[99; 100) "S"
+          WHITESPACE@[100; 101)
+          L_CURLY@[101; 102)
+          WHITESPACE@[102; 103)
+          IDENT@[103; 104) "h"
+          COLON@[104; 105)
+          WHITESPACE@[105; 106)
+          PLACEHOLDER_PAT@[106; 107)
+            UNDERSCORE@[106; 107)
+          COMMA@[107; 108)
+          WHITESPACE@[108; 109)
+          R_CURLY@[109; 110)
+        WHITESPACE@[110; 111)
+        EQ@[111; 112)
+        WHITESPACE@[112; 113)
+        TUPLE_EXPR@[113; 115)
+          L_PAREN@[113; 114)
+          R_PAREN@[114; 115)
+        SEMI@[115; 116)
+      WHITESPACE@[116; 117)
+      R_CURLY@[117; 118)
+  WHITESPACE@[118; 119)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0074_unary_expr.rs b/crates/libsyntax2/tests/data/parser/inline/0074_unary_expr.rs
new file mode 100644
index 000000000..f1c3f7118
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0074_unary_expr.rs
@@ -0,0 +1,5 @@
+fn foo() {
+    **&1;
+    !!true;
+    --1;
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0074_unary_expr.txt b/crates/libsyntax2/tests/data/parser/inline/0074_unary_expr.txt
new file mode 100644
index 000000000..e0b4ff964
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0074_unary_expr.txt
@@ -0,0 +1,44 @@
+FILE@[0; 44)
+  FUNCTION@[0; 43)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 43)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      EXPR_STMT@[15; 20)
+        PREFIX_EXPR@[15; 19)
+          STAR@[15; 16)
+          PREFIX_EXPR@[16; 19)
+            STAR@[16; 17)
+            REF_EXPR@[17; 19)
+              AMP@[17; 18)
+              LITERAL@[18; 19)
+                INT_NUMBER@[18; 19) "1"
+        SEMI@[19; 20)
+      WHITESPACE@[20; 25)
+      EXPR_STMT@[25; 32)
+        PREFIX_EXPR@[25; 31)
+          EXCL@[25; 26)
+          PREFIX_EXPR@[26; 31)
+            EXCL@[26; 27)
+            LITERAL@[27; 31)
+              TRUE_KW@[27; 31)
+        SEMI@[31; 32)
+      WHITESPACE@[32; 37)
+      EXPR_STMT@[37; 41)
+        PREFIX_EXPR@[37; 40)
+          MINUS@[37; 38)
+          PREFIX_EXPR@[38; 40)
+            MINUS@[38; 39)
+            LITERAL@[39; 40)
+              INT_NUMBER@[39; 40) "1"
+        SEMI@[40; 41)
+      WHITESPACE@[41; 42)
+      R_CURLY@[42; 43)
+  WHITESPACE@[43; 44)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0075_try_expr.rs b/crates/libsyntax2/tests/data/parser/inline/0075_try_expr.rs
new file mode 100644
index 000000000..8b74f7bc8
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0075_try_expr.rs
@@ -0,0 +1,3 @@
+fn foo() {
+    x?;
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0075_try_expr.txt b/crates/libsyntax2/tests/data/parser/inline/0075_try_expr.txt
new file mode 100644
index 000000000..f7b86f269
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0075_try_expr.txt
@@ -0,0 +1,25 @@
+FILE@[0; 21)
+  FUNCTION@[0; 20)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 20)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      EXPR_STMT@[15; 18)
+        TRY_EXPR@[15; 17)
+          PATH_EXPR@[15; 16)
+            PATH@[15; 16)
+              PATH_SEGMENT@[15; 16)
+                NAME_REF@[15; 16)
+                  IDENT@[15; 16) "x"
+          QUESTION@[16; 17)
+        SEMI@[17; 18)
+      WHITESPACE@[18; 19)
+      R_CURLY@[19; 20)
+  WHITESPACE@[20; 21)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0076_cond.rs b/crates/libsyntax2/tests/data/parser/inline/0076_cond.rs
new file mode 100644
index 000000000..fdb37ee6f
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0076_cond.rs
@@ -0,0 +1 @@
+fn foo() { if let Some(_) = None {} }
diff --git a/crates/libsyntax2/tests/data/parser/inline/0076_cond.txt b/crates/libsyntax2/tests/data/parser/inline/0076_cond.txt
new file mode 100644
index 000000000..0cde88a90
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0076_cond.txt
@@ -0,0 +1,42 @@
+FILE@[0; 38)
+  FUNCTION@[0; 37)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 37)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 11)
+      IF_EXPR@[11; 35)
+        IF_KW@[11; 13)
+        WHITESPACE@[13; 14)
+        LET_KW@[14; 17)
+        WHITESPACE@[17; 18)
+        TUPLE_STRUCT_PAT@[18; 25)
+          PATH@[18; 22)
+            PATH_SEGMENT@[18; 22)
+              NAME_REF@[18; 22)
+                IDENT@[18; 22) "Some"
+          L_PAREN@[22; 23)
+          PLACEHOLDER_PAT@[23; 24)
+            UNDERSCORE@[23; 24)
+          R_PAREN@[24; 25)
+        WHITESPACE@[25; 26)
+        EQ@[26; 27)
+        WHITESPACE@[27; 28)
+        PATH_EXPR@[28; 32)
+          PATH@[28; 32)
+            PATH_SEGMENT@[28; 32)
+              NAME_REF@[28; 32)
+                IDENT@[28; 32) "None"
+        WHITESPACE@[32; 33)
+        BLOCK_EXPR@[33; 35)
+          L_CURLY@[33; 34)
+          R_CURLY@[34; 35)
+      WHITESPACE@[35; 36)
+      R_CURLY@[36; 37)
+  WHITESPACE@[37; 38)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0077_while_expr.rs b/crates/libsyntax2/tests/data/parser/inline/0077_while_expr.rs
new file mode 100644
index 000000000..293046a04
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0077_while_expr.rs
@@ -0,0 +1,4 @@
+fn foo() {
+    while true {};
+    while let Some(x) = it.next() {};
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0077_while_expr.txt b/crates/libsyntax2/tests/data/parser/inline/0077_while_expr.txt
new file mode 100644
index 000000000..82e63fd46
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0077_while_expr.txt
@@ -0,0 +1,64 @@
+FILE@[0; 70)
+  FUNCTION@[0; 69)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 69)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      EXPR_STMT@[15; 29)
+        WHILE_EXPR@[15; 28)
+          WHILE_KW@[15; 20)
+          WHITESPACE@[20; 21)
+          LITERAL@[21; 25)
+            TRUE_KW@[21; 25)
+          WHITESPACE@[25; 26)
+          BLOCK_EXPR@[26; 28)
+            L_CURLY@[26; 27)
+            R_CURLY@[27; 28)
+        SEMI@[28; 29)
+      WHITESPACE@[29; 34)
+      EXPR_STMT@[34; 67)
+        WHILE_EXPR@[34; 66)
+          WHILE_KW@[34; 39)
+          WHITESPACE@[39; 40)
+          LET_KW@[40; 43)
+          WHITESPACE@[43; 44)
+          TUPLE_STRUCT_PAT@[44; 51)
+            PATH@[44; 48)
+              PATH_SEGMENT@[44; 48)
+                NAME_REF@[44; 48)
+                  IDENT@[44; 48) "Some"
+            L_PAREN@[48; 49)
+            BIND_PAT@[49; 50)
+              NAME@[49; 50)
+                IDENT@[49; 50) "x"
+            R_PAREN@[50; 51)
+          WHITESPACE@[51; 52)
+          EQ@[52; 53)
+          WHITESPACE@[53; 54)
+          METHOD_CALL_EXPR@[54; 63)
+            PATH_EXPR@[54; 56)
+              PATH@[54; 56)
+                PATH_SEGMENT@[54; 56)
+                  NAME_REF@[54; 56)
+                    IDENT@[54; 56) "it"
+            DOT@[56; 57)
+            NAME_REF@[57; 61)
+              IDENT@[57; 61) "next"
+            ARG_LIST@[61; 63)
+              L_PAREN@[61; 62)
+              R_PAREN@[62; 63)
+          WHITESPACE@[63; 64)
+          BLOCK_EXPR@[64; 66)
+            L_CURLY@[64; 65)
+            R_CURLY@[65; 66)
+        SEMI@[66; 67)
+      WHITESPACE@[67; 68)
+      R_CURLY@[68; 69)
+  WHITESPACE@[69; 70)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0078_mod_contents.rs b/crates/libsyntax2/tests/data/parser/inline/0078_mod_contents.rs
new file mode 100644
index 000000000..24a15c5c5
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0078_mod_contents.rs
@@ -0,0 +1,5 @@
+fn foo() {}
+macro_rules! foo {}
+foo::bar!();
+super::baz! {}
+struct S;
diff --git a/crates/libsyntax2/tests/data/parser/inline/0078_mod_contents.txt b/crates/libsyntax2/tests/data/parser/inline/0078_mod_contents.txt
new file mode 100644
index 000000000..c003d24e1
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0078_mod_contents.txt
@@ -0,0 +1,62 @@
+FILE@[0; 70)
+  FUNCTION@[0; 11)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 11)
+      L_CURLY@[9; 10)
+      R_CURLY@[10; 11)
+  WHITESPACE@[11; 12)
+  MACRO_CALL@[12; 31)
+    PATH@[12; 23)
+      PATH_SEGMENT@[12; 23)
+        NAME_REF@[12; 23)
+          IDENT@[12; 23) "macro_rules"
+    EXCL@[23; 24)
+    WHITESPACE@[24; 25)
+    IDENT@[25; 28) "foo"
+    WHITESPACE@[28; 29)
+    L_CURLY@[29; 30)
+    R_CURLY@[30; 31)
+  WHITESPACE@[31; 32)
+  MACRO_CALL@[32; 44)
+    PATH@[32; 40)
+      PATH@[32; 35)
+        PATH_SEGMENT@[32; 35)
+          NAME_REF@[32; 35)
+            IDENT@[32; 35) "foo"
+      COLONCOLON@[35; 37)
+      PATH_SEGMENT@[37; 40)
+        NAME_REF@[37; 40)
+          IDENT@[37; 40) "bar"
+    EXCL@[40; 41)
+    L_PAREN@[41; 42)
+    R_PAREN@[42; 43)
+    SEMI@[43; 44)
+  WHITESPACE@[44; 45)
+  MACRO_CALL@[45; 59)
+    PATH@[45; 55)
+      PATH@[45; 50)
+        PATH_SEGMENT@[45; 50)
+          SUPER_KW@[45; 50)
+      COLONCOLON@[50; 52)
+      PATH_SEGMENT@[52; 55)
+        NAME_REF@[52; 55)
+          IDENT@[52; 55) "baz"
+    EXCL@[55; 56)
+    WHITESPACE@[56; 57)
+    L_CURLY@[57; 58)
+    R_CURLY@[58; 59)
+  WHITESPACE@[59; 60)
+  STRUCT_ITEM@[60; 69)
+    STRUCT_KW@[60; 66)
+    WHITESPACE@[66; 67)
+    NAME@[67; 68)
+      IDENT@[67; 68) "S"
+    SEMI@[68; 69)
+  WHITESPACE@[69; 70)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0079_cast_expr.rs b/crates/libsyntax2/tests/data/parser/inline/0079_cast_expr.rs
new file mode 100644
index 000000000..3e53d56d6
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0079_cast_expr.rs
@@ -0,0 +1,3 @@
+fn foo() {
+    82 as i32;
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0079_cast_expr.txt b/crates/libsyntax2/tests/data/parser/inline/0079_cast_expr.txt
new file mode 100644
index 000000000..642557e15
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0079_cast_expr.txt
@@ -0,0 +1,29 @@
+FILE@[0; 28)
+  FUNCTION@[0; 27)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 27)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      EXPR_STMT@[15; 25)
+        CAST_EXPR@[15; 24)
+          LITERAL@[15; 17)
+            INT_NUMBER@[15; 17) "82"
+          WHITESPACE@[17; 18)
+          AS_KW@[18; 20)
+          WHITESPACE@[20; 21)
+          PATH_TYPE@[21; 24)
+            PATH@[21; 24)
+              PATH_SEGMENT@[21; 24)
+                NAME_REF@[21; 24)
+                  IDENT@[21; 24) "i32"
+        SEMI@[24; 25)
+      WHITESPACE@[25; 26)
+      R_CURLY@[26; 27)
+  WHITESPACE@[27; 28)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0080_tuple_expr.rs b/crates/libsyntax2/tests/data/parser/inline/0080_tuple_expr.rs
new file mode 100644
index 000000000..e4f774280
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0080_tuple_expr.rs
@@ -0,0 +1,5 @@
+fn foo() {
+    ();
+    (1);
+    (1,);
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0080_tuple_expr.txt b/crates/libsyntax2/tests/data/parser/inline/0080_tuple_expr.txt
new file mode 100644
index 000000000..728ba6ec7
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0080_tuple_expr.txt
@@ -0,0 +1,38 @@
+FILE@[0; 40)
+  FUNCTION@[0; 39)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 39)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      EXPR_STMT@[15; 18)
+        TUPLE_EXPR@[15; 17)
+          L_PAREN@[15; 16)
+          R_PAREN@[16; 17)
+        SEMI@[17; 18)
+      WHITESPACE@[18; 23)
+      EXPR_STMT@[23; 27)
+        PAREN_EXPR@[23; 26)
+          L_PAREN@[23; 24)
+          LITERAL@[24; 25)
+            INT_NUMBER@[24; 25) "1"
+          R_PAREN@[25; 26)
+        SEMI@[26; 27)
+      WHITESPACE@[27; 32)
+      EXPR_STMT@[32; 37)
+        TUPLE_EXPR@[32; 36)
+          L_PAREN@[32; 33)
+          LITERAL@[33; 34)
+            INT_NUMBER@[33; 34) "1"
+          COMMA@[34; 35)
+          R_PAREN@[35; 36)
+        SEMI@[36; 37)
+      WHITESPACE@[37; 38)
+      R_CURLY@[38; 39)
+  WHITESPACE@[39; 40)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0081_index_expr.rs b/crates/libsyntax2/tests/data/parser/inline/0081_index_expr.rs
new file mode 100644
index 000000000..b9ba78a6c
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0081_index_expr.rs
@@ -0,0 +1,3 @@
+fn foo() {
+    x[1][2];
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0081_index_expr.txt b/crates/libsyntax2/tests/data/parser/inline/0081_index_expr.txt
new file mode 100644
index 000000000..80af4caed
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0081_index_expr.txt
@@ -0,0 +1,33 @@
+FILE@[0; 26)
+  FUNCTION@[0; 25)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 25)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      EXPR_STMT@[15; 23)
+        INDEX_EXPR@[15; 22)
+          INDEX_EXPR@[15; 19)
+            PATH_EXPR@[15; 16)
+              PATH@[15; 16)
+                PATH_SEGMENT@[15; 16)
+                  NAME_REF@[15; 16)
+                    IDENT@[15; 16) "x"
+            L_BRACK@[16; 17)
+            LITERAL@[17; 18)
+              INT_NUMBER@[17; 18) "1"
+            R_BRACK@[18; 19)
+          L_BRACK@[19; 20)
+          LITERAL@[20; 21)
+            INT_NUMBER@[20; 21) "2"
+          R_BRACK@[21; 22)
+        SEMI@[22; 23)
+      WHITESPACE@[23; 24)
+      R_CURLY@[24; 25)
+  WHITESPACE@[25; 26)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0082_tuple_pat.rs b/crates/libsyntax2/tests/data/parser/inline/0082_tuple_pat.rs
new file mode 100644
index 000000000..f785acd36
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0082_tuple_pat.rs
@@ -0,0 +1,3 @@
+fn main() {
+    let (a, b, ..) = ();
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0082_tuple_pat.txt b/crates/libsyntax2/tests/data/parser/inline/0082_tuple_pat.txt
new file mode 100644
index 000000000..d8314b5d8
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0082_tuple_pat.txt
@@ -0,0 +1,40 @@
+FILE@[0; 39)
+  FUNCTION@[0; 38)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8)
+      R_PAREN@[8; 9)
+    WHITESPACE@[9; 10)
+    BLOCK_EXPR@[10; 38)
+      L_CURLY@[10; 11)
+      WHITESPACE@[11; 16)
+      LET_STMT@[16; 36)
+        LET_KW@[16; 19)
+        WHITESPACE@[19; 20)
+        TUPLE_PAT@[20; 30)
+          L_PAREN@[20; 21)
+          BIND_PAT@[21; 22)
+            NAME@[21; 22)
+              IDENT@[21; 22) "a"
+          COMMA@[22; 23)
+          WHITESPACE@[23; 24)
+          BIND_PAT@[24; 25)
+            NAME@[24; 25)
+              IDENT@[24; 25) "b"
+          COMMA@[25; 26)
+          WHITESPACE@[26; 27)
+          DOTDOT@[27; 29)
+          R_PAREN@[29; 30)
+        WHITESPACE@[30; 31)
+        EQ@[31; 32)
+        WHITESPACE@[32; 33)
+        TUPLE_EXPR@[33; 35)
+          L_PAREN@[33; 34)
+          R_PAREN@[34; 35)
+        SEMI@[35; 36)
+      WHITESPACE@[36; 37)
+      R_CURLY@[37; 38)
+  WHITESPACE@[38; 39)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0083_postfix_range.rs b/crates/libsyntax2/tests/data/parser/inline/0083_postfix_range.rs
new file mode 100644
index 000000000..c39fe8e68
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0083_postfix_range.rs
@@ -0,0 +1 @@
+fn foo() { let x = 1..; }
diff --git a/crates/libsyntax2/tests/data/parser/inline/0083_postfix_range.txt b/crates/libsyntax2/tests/data/parser/inline/0083_postfix_range.txt
new file mode 100644
index 000000000..bf9b2c695
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0083_postfix_range.txt
@@ -0,0 +1,30 @@
+FILE@[0; 26)
+  FUNCTION@[0; 25)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 25)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 11)
+      LET_STMT@[11; 23)
+        LET_KW@[11; 14)
+        WHITESPACE@[14; 15)
+        BIND_PAT@[15; 16)
+          NAME@[15; 16)
+            IDENT@[15; 16) "x"
+        WHITESPACE@[16; 17)
+        EQ@[17; 18)
+        WHITESPACE@[18; 19)
+        RANGE_EXPR@[19; 22)
+          LITERAL@[19; 20)
+            INT_NUMBER@[19; 20) "1"
+          DOTDOT@[20; 22)
+        SEMI@[22; 23)
+      WHITESPACE@[23; 24)
+      R_CURLY@[24; 25)
+  WHITESPACE@[25; 26)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0084_loop_expr.rs b/crates/libsyntax2/tests/data/parser/inline/0084_loop_expr.rs
new file mode 100644
index 000000000..9f078fa48
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0084_loop_expr.rs
@@ -0,0 +1,3 @@
+fn foo() {
+    loop {};
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0084_loop_expr.txt b/crates/libsyntax2/tests/data/parser/inline/0084_loop_expr.txt
new file mode 100644
index 000000000..5e0de55d4
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0084_loop_expr.txt
@@ -0,0 +1,24 @@
+FILE@[0; 26)
+  FUNCTION@[0; 25)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 25)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      EXPR_STMT@[15; 23)
+        LOOP_EXPR@[15; 22)
+          LOOP_KW@[15; 19)
+          WHITESPACE@[19; 20)
+          BLOCK_EXPR@[20; 22)
+            L_CURLY@[20; 21)
+            R_CURLY@[21; 22)
+        SEMI@[22; 23)
+      WHITESPACE@[23; 24)
+      R_CURLY@[24; 25)
+  WHITESPACE@[25; 26)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0085_for_expr.rs b/crates/libsyntax2/tests/data/parser/inline/0085_for_expr.rs
new file mode 100644
index 000000000..972197d2a
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0085_for_expr.rs
@@ -0,0 +1,3 @@
+fn foo() {
+    for x in [] {};
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0085_for_expr.txt b/crates/libsyntax2/tests/data/parser/inline/0085_for_expr.txt
new file mode 100644
index 000000000..3a378cfcf
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0085_for_expr.txt
@@ -0,0 +1,34 @@
+FILE@[0; 33)
+  FUNCTION@[0; 32)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 32)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      EXPR_STMT@[15; 30)
+        FOR_EXPR@[15; 29)
+          FOR_KW@[15; 18)
+          WHITESPACE@[18; 19)
+          BIND_PAT@[19; 20)
+            NAME@[19; 20)
+              IDENT@[19; 20) "x"
+          WHITESPACE@[20; 21)
+          IN_KW@[21; 23)
+          WHITESPACE@[23; 24)
+          ARRAY_EXPR@[24; 26)
+            L_BRACK@[24; 25)
+            R_BRACK@[25; 26)
+          WHITESPACE@[26; 27)
+          BLOCK_EXPR@[27; 29)
+            L_CURLY@[27; 28)
+            R_CURLY@[28; 29)
+        SEMI@[29; 30)
+      WHITESPACE@[30; 31)
+      R_CURLY@[31; 32)
+  WHITESPACE@[32; 33)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0085_match_arms_commas.rs b/crates/libsyntax2/tests/data/parser/inline/0085_match_arms_commas.rs
new file mode 100644
index 000000000..1f25d577a
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0085_match_arms_commas.rs
@@ -0,0 +1,7 @@
+fn foo() {
+    match () {
+        _ => (),
+        _ => {}
+        _ => ()
+    }
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0085_match_arms_commas.txt b/crates/libsyntax2/tests/data/parser/inline/0085_match_arms_commas.txt
new file mode 100644
index 000000000..5465a3797
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0085_match_arms_commas.txt
@@ -0,0 +1,57 @@
+FILE@[0; 83)
+  FUNCTION@[0; 82)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 82)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      MATCH_EXPR@[15; 80)
+        MATCH_KW@[15; 20)
+        WHITESPACE@[20; 21)
+        TUPLE_EXPR@[21; 23)
+          L_PAREN@[21; 22)
+          R_PAREN@[22; 23)
+        WHITESPACE@[23; 24)
+        L_CURLY@[24; 25)
+        WHITESPACE@[25; 34)
+        MATCH_ARM@[34; 41)
+          PLACEHOLDER_PAT@[34; 35)
+            UNDERSCORE@[34; 35)
+          WHITESPACE@[35; 36)
+          FAT_ARROW@[36; 38)
+          WHITESPACE@[38; 39)
+          TUPLE_EXPR@[39; 41)
+            L_PAREN@[39; 40)
+            R_PAREN@[40; 41)
+        COMMA@[41; 42)
+        WHITESPACE@[42; 51)
+        MATCH_ARM@[51; 58)
+          PLACEHOLDER_PAT@[51; 52)
+            UNDERSCORE@[51; 52)
+          WHITESPACE@[52; 53)
+          FAT_ARROW@[53; 55)
+          WHITESPACE@[55; 56)
+          BLOCK_EXPR@[56; 58)
+            L_CURLY@[56; 57)
+            R_CURLY@[57; 58)
+        WHITESPACE@[58; 67)
+        MATCH_ARM@[67; 74)
+          PLACEHOLDER_PAT@[67; 68)
+            UNDERSCORE@[67; 68)
+          WHITESPACE@[68; 69)
+          FAT_ARROW@[69; 71)
+          WHITESPACE@[71; 72)
+          TUPLE_EXPR@[72; 74)
+            L_PAREN@[72; 73)
+            R_PAREN@[73; 74)
+        WHITESPACE@[74; 79)
+        R_CURLY@[79; 80)
+      WHITESPACE@[80; 81)
+      R_CURLY@[81; 82)
+  WHITESPACE@[82; 83)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0086_array_expr.rs b/crates/libsyntax2/tests/data/parser/inline/0086_array_expr.rs
new file mode 100644
index 000000000..4dc1999d1
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0086_array_expr.rs
@@ -0,0 +1,6 @@
+fn foo() {
+    [];
+    [1];
+    [1, 2,];
+    [1; 2];
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0086_array_expr.txt b/crates/libsyntax2/tests/data/parser/inline/0086_array_expr.txt
new file mode 100644
index 000000000..9a5f56edf
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0086_array_expr.txt
@@ -0,0 +1,54 @@
+FILE@[0; 55)
+  FUNCTION@[0; 54)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 54)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      EXPR_STMT@[15; 18)
+        ARRAY_EXPR@[15; 17)
+          L_BRACK@[15; 16)
+          R_BRACK@[16; 17)
+        SEMI@[17; 18)
+      WHITESPACE@[18; 23)
+      EXPR_STMT@[23; 27)
+        ARRAY_EXPR@[23; 26)
+          L_BRACK@[23; 24)
+          LITERAL@[24; 25)
+            INT_NUMBER@[24; 25) "1"
+          R_BRACK@[25; 26)
+        SEMI@[26; 27)
+      WHITESPACE@[27; 32)
+      EXPR_STMT@[32; 40)
+        ARRAY_EXPR@[32; 39)
+          L_BRACK@[32; 33)
+          LITERAL@[33; 34)
+            INT_NUMBER@[33; 34) "1"
+          COMMA@[34; 35)
+          WHITESPACE@[35; 36)
+          LITERAL@[36; 37)
+            INT_NUMBER@[36; 37) "2"
+          COMMA@[37; 38)
+          R_BRACK@[38; 39)
+        SEMI@[39; 40)
+      WHITESPACE@[40; 45)
+      EXPR_STMT@[45; 52)
+        ARRAY_EXPR@[45; 51)
+          L_BRACK@[45; 46)
+          LITERAL@[46; 47)
+            INT_NUMBER@[46; 47) "1"
+          SEMI@[47; 48)
+          WHITESPACE@[48; 49)
+          LITERAL@[49; 50)
+            INT_NUMBER@[49; 50) "2"
+          R_BRACK@[50; 51)
+        SEMI@[51; 52)
+      WHITESPACE@[52; 53)
+      R_CURLY@[53; 54)
+  WHITESPACE@[54; 55)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0086_no_semi_after_block.rs b/crates/libsyntax2/tests/data/parser/inline/0086_no_semi_after_block.rs
new file mode 100644
index 000000000..d769da43d
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0086_no_semi_after_block.rs
@@ -0,0 +1,9 @@
+fn foo() {
+    if true {}
+    loop {}
+    match () {}
+    while true {}
+    for _ in () {}
+    {}
+    {}
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0086_no_semi_after_block.txt b/crates/libsyntax2/tests/data/parser/inline/0086_no_semi_after_block.txt
new file mode 100644
index 000000000..d19a270ac
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0086_no_semi_after_block.txt
@@ -0,0 +1,82 @@
+FILE@[0; 107)
+  FUNCTION@[0; 106)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 106)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      EXPR_STMT@[15; 25)
+        IF_EXPR@[15; 25)
+          IF_KW@[15; 17)
+          WHITESPACE@[17; 18)
+          LITERAL@[18; 22)
+            TRUE_KW@[18; 22)
+          WHITESPACE@[22; 23)
+          BLOCK_EXPR@[23; 25)
+            L_CURLY@[23; 24)
+            R_CURLY@[24; 25)
+      WHITESPACE@[25; 30)
+      EXPR_STMT@[30; 37)
+        LOOP_EXPR@[30; 37)
+          LOOP_KW@[30; 34)
+          WHITESPACE@[34; 35)
+          BLOCK_EXPR@[35; 37)
+            L_CURLY@[35; 36)
+            R_CURLY@[36; 37)
+      WHITESPACE@[37; 42)
+      EXPR_STMT@[42; 53)
+        MATCH_EXPR@[42; 53)
+          MATCH_KW@[42; 47)
+          WHITESPACE@[47; 48)
+          TUPLE_EXPR@[48; 50)
+            L_PAREN@[48; 49)
+            R_PAREN@[49; 50)
+          WHITESPACE@[50; 51)
+          L_CURLY@[51; 52)
+          R_CURLY@[52; 53)
+      WHITESPACE@[53; 58)
+      EXPR_STMT@[58; 71)
+        WHILE_EXPR@[58; 71)
+          WHILE_KW@[58; 63)
+          WHITESPACE@[63; 64)
+          LITERAL@[64; 68)
+            TRUE_KW@[64; 68)
+          WHITESPACE@[68; 69)
+          BLOCK_EXPR@[69; 71)
+            L_CURLY@[69; 70)
+            R_CURLY@[70; 71)
+      WHITESPACE@[71; 76)
+      EXPR_STMT@[76; 90)
+        FOR_EXPR@[76; 90)
+          FOR_KW@[76; 79)
+          WHITESPACE@[79; 80)
+          PLACEHOLDER_PAT@[80; 81)
+            UNDERSCORE@[80; 81)
+          WHITESPACE@[81; 82)
+          IN_KW@[82; 84)
+          WHITESPACE@[84; 85)
+          TUPLE_EXPR@[85; 87)
+            L_PAREN@[85; 86)
+            R_PAREN@[86; 87)
+          WHITESPACE@[87; 88)
+          BLOCK_EXPR@[88; 90)
+            L_CURLY@[88; 89)
+            R_CURLY@[89; 90)
+      WHITESPACE@[90; 95)
+      EXPR_STMT@[95; 97)
+        BLOCK_EXPR@[95; 97)
+          L_CURLY@[95; 96)
+          R_CURLY@[96; 97)
+      WHITESPACE@[97; 102)
+      BLOCK_EXPR@[102; 104)
+        L_CURLY@[102; 103)
+        R_CURLY@[103; 104)
+      WHITESPACE@[104; 105)
+      R_CURLY@[105; 106)
+  WHITESPACE@[106; 107)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0087_stmt_postfix_expr_ambiguity.rs b/crates/libsyntax2/tests/data/parser/inline/0087_stmt_postfix_expr_ambiguity.rs
new file mode 100644
index 000000000..2edd578f9
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0087_stmt_postfix_expr_ambiguity.rs
@@ -0,0 +1,7 @@
+fn foo() {
+    match () {
+        _ => {}
+        () => {}
+        [] => {}
+    }
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0087_stmt_postfix_expr_ambiguity.txt b/crates/libsyntax2/tests/data/parser/inline/0087_stmt_postfix_expr_ambiguity.txt
new file mode 100644
index 000000000..e83b6d183
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0087_stmt_postfix_expr_ambiguity.txt
@@ -0,0 +1,58 @@
+FILE@[0; 84)
+  FUNCTION@[0; 83)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 83)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      MATCH_EXPR@[15; 81)
+        MATCH_KW@[15; 20)
+        WHITESPACE@[20; 21)
+        TUPLE_EXPR@[21; 23)
+          L_PAREN@[21; 22)
+          R_PAREN@[22; 23)
+        WHITESPACE@[23; 24)
+        L_CURLY@[24; 25)
+        WHITESPACE@[25; 34)
+        MATCH_ARM@[34; 41)
+          PLACEHOLDER_PAT@[34; 35)
+            UNDERSCORE@[34; 35)
+          WHITESPACE@[35; 36)
+          FAT_ARROW@[36; 38)
+          WHITESPACE@[38; 39)
+          BLOCK_EXPR@[39; 41)
+            L_CURLY@[39; 40)
+            R_CURLY@[40; 41)
+        WHITESPACE@[41; 50)
+        MATCH_ARM@[50; 58)
+          TUPLE_PAT@[50; 52)
+            L_PAREN@[50; 51)
+            R_PAREN@[51; 52)
+          WHITESPACE@[52; 53)
+          FAT_ARROW@[53; 55)
+          WHITESPACE@[55; 56)
+          BLOCK_EXPR@[56; 58)
+            L_CURLY@[56; 57)
+            R_CURLY@[57; 58)
+        WHITESPACE@[58; 67)
+        MATCH_ARM@[67; 75)
+          SLICE_PAT@[67; 69)
+            L_BRACK@[67; 68)
+            R_BRACK@[68; 69)
+          WHITESPACE@[69; 70)
+          FAT_ARROW@[70; 72)
+          WHITESPACE@[72; 73)
+          BLOCK_EXPR@[73; 75)
+            L_CURLY@[73; 74)
+            R_CURLY@[74; 75)
+        WHITESPACE@[75; 80)
+        R_CURLY@[80; 81)
+      WHITESPACE@[81; 82)
+      R_CURLY@[82; 83)
+  WHITESPACE@[83; 84)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0088_stmt_bin_expr_ambiguity.rs b/crates/libsyntax2/tests/data/parser/inline/0088_stmt_bin_expr_ambiguity.rs
new file mode 100644
index 000000000..37b843742
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0088_stmt_bin_expr_ambiguity.rs
@@ -0,0 +1,4 @@
+fn foo() {
+    let _ = {1} & 2;
+    {1} &2;
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0088_stmt_bin_expr_ambiguity.txt b/crates/libsyntax2/tests/data/parser/inline/0088_stmt_bin_expr_ambiguity.txt
new file mode 100644
index 000000000..df4c20b0e
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0088_stmt_bin_expr_ambiguity.txt
@@ -0,0 +1,50 @@
+FILE@[0; 46)
+  FUNCTION@[0; 45)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 45)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      LET_STMT@[15; 31)
+        LET_KW@[15; 18)
+        WHITESPACE@[18; 19)
+        PLACEHOLDER_PAT@[19; 20)
+          UNDERSCORE@[19; 20)
+        WHITESPACE@[20; 21)
+        EQ@[21; 22)
+        WHITESPACE@[22; 23)
+        BIN_EXPR@[23; 30)
+          BLOCK_EXPR@[23; 26)
+            L_CURLY@[23; 24)
+            LITERAL@[24; 25)
+              INT_NUMBER@[24; 25) "1"
+            R_CURLY@[25; 26)
+          WHITESPACE@[26; 27)
+          AMP@[27; 28)
+          WHITESPACE@[28; 29)
+          LITERAL@[29; 30)
+            INT_NUMBER@[29; 30) "2"
+        SEMI@[30; 31)
+      WHITESPACE@[31; 36)
+      EXPR_STMT@[36; 39)
+        BLOCK_EXPR@[36; 39)
+          L_CURLY@[36; 37)
+          LITERAL@[37; 38)
+            INT_NUMBER@[37; 38) "1"
+          R_CURLY@[38; 39)
+      WHITESPACE@[39; 40)
+      EXPR_STMT@[40; 43)
+        REF_EXPR@[40; 42)
+          AMP@[40; 41)
+          LITERAL@[41; 42)
+            INT_NUMBER@[41; 42) "2"
+        SEMI@[42; 43)
+      WHITESPACE@[43; 44)
+      R_CURLY@[44; 45)
+  WHITESPACE@[45; 46)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0089_slice_pat.rs b/crates/libsyntax2/tests/data/parser/inline/0089_slice_pat.rs
new file mode 100644
index 000000000..7955973b9
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0089_slice_pat.rs
@@ -0,0 +1,3 @@
+fn main() {
+    let [a, b, ..] = [];
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0089_slice_pat.txt b/crates/libsyntax2/tests/data/parser/inline/0089_slice_pat.txt
new file mode 100644
index 000000000..8379df33b
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0089_slice_pat.txt
@@ -0,0 +1,40 @@
+FILE@[0; 39)
+  FUNCTION@[0; 38)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8)
+      R_PAREN@[8; 9)
+    WHITESPACE@[9; 10)
+    BLOCK_EXPR@[10; 38)
+      L_CURLY@[10; 11)
+      WHITESPACE@[11; 16)
+      LET_STMT@[16; 36)
+        LET_KW@[16; 19)
+        WHITESPACE@[19; 20)
+        SLICE_PAT@[20; 30)
+          L_BRACK@[20; 21)
+          BIND_PAT@[21; 22)
+            NAME@[21; 22)
+              IDENT@[21; 22) "a"
+          COMMA@[22; 23)
+          WHITESPACE@[23; 24)
+          BIND_PAT@[24; 25)
+            NAME@[24; 25)
+              IDENT@[24; 25) "b"
+          COMMA@[25; 26)
+          WHITESPACE@[26; 27)
+          DOTDOT@[27; 29)
+          R_BRACK@[29; 30)
+        WHITESPACE@[30; 31)
+        EQ@[31; 32)
+        WHITESPACE@[32; 33)
+        ARRAY_EXPR@[33; 35)
+          L_BRACK@[33; 34)
+          R_BRACK@[34; 35)
+        SEMI@[35; 36)
+      WHITESPACE@[36; 37)
+      R_CURLY@[37; 38)
+  WHITESPACE@[38; 39)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0090_trait_item_items.rs b/crates/libsyntax2/tests/data/parser/inline/0090_trait_item_items.rs
new file mode 100644
index 000000000..a5ec3239f
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0090_trait_item_items.rs
@@ -0,0 +1,6 @@
+impl F {
+    type A: Clone;
+    const B: i32;
+    fn foo() {}
+    fn bar(&self);
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0090_trait_item_items.txt b/crates/libsyntax2/tests/data/parser/inline/0090_trait_item_items.txt
new file mode 100644
index 000000000..c04c48588
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0090_trait_item_items.txt
@@ -0,0 +1,67 @@
+FILE@[0; 83)
+  IMPL_ITEM@[0; 82)
+    IMPL_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    PATH_TYPE@[5; 6)
+      PATH@[5; 6)
+        PATH_SEGMENT@[5; 6)
+          NAME_REF@[5; 6)
+            IDENT@[5; 6) "F"
+    WHITESPACE@[6; 7)
+    L_CURLY@[7; 8)
+    WHITESPACE@[8; 13)
+    TYPE_ITEM@[13; 27)
+      TYPE_KW@[13; 17)
+      WHITESPACE@[17; 18)
+      NAME@[18; 19)
+        IDENT@[18; 19) "A"
+      COLON@[19; 20)
+      WHITESPACE@[20; 21)
+      PATH@[21; 26)
+        PATH_SEGMENT@[21; 26)
+          NAME_REF@[21; 26)
+            IDENT@[21; 26) "Clone"
+      SEMI@[26; 27)
+    WHITESPACE@[27; 32)
+    CONST_ITEM@[32; 45)
+      CONST_KW@[32; 37)
+      WHITESPACE@[37; 38)
+      NAME@[38; 39)
+        IDENT@[38; 39) "B"
+      COLON@[39; 40)
+      WHITESPACE@[40; 41)
+      PATH_TYPE@[41; 44)
+        PATH@[41; 44)
+          PATH_SEGMENT@[41; 44)
+            NAME_REF@[41; 44)
+              IDENT@[41; 44) "i32"
+      SEMI@[44; 45)
+    WHITESPACE@[45; 50)
+    FUNCTION@[50; 61)
+      FN_KW@[50; 52)
+      WHITESPACE@[52; 53)
+      NAME@[53; 56)
+        IDENT@[53; 56) "foo"
+      PARAM_LIST@[56; 58)
+        L_PAREN@[56; 57)
+        R_PAREN@[57; 58)
+      WHITESPACE@[58; 59)
+      BLOCK_EXPR@[59; 61)
+        L_CURLY@[59; 60)
+        R_CURLY@[60; 61)
+    WHITESPACE@[61; 66)
+    FUNCTION@[66; 80)
+      FN_KW@[66; 68)
+      WHITESPACE@[68; 69)
+      NAME@[69; 72)
+        IDENT@[69; 72) "bar"
+      PARAM_LIST@[72; 79)
+        L_PAREN@[72; 73)
+        SELF_PARAM@[73; 78)
+          AMP@[73; 74)
+          SELF_KW@[74; 78)
+        R_PAREN@[78; 79)
+      SEMI@[79; 80)
+    WHITESPACE@[80; 81)
+    R_CURLY@[81; 82)
+  WHITESPACE@[82; 83)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0091_fn_decl.rs b/crates/libsyntax2/tests/data/parser/inline/0091_fn_decl.rs
new file mode 100644
index 000000000..c9f74f7f5
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0091_fn_decl.rs
@@ -0,0 +1 @@
+trait T { fn foo(); }
diff --git a/crates/libsyntax2/tests/data/parser/inline/0091_fn_decl.txt b/crates/libsyntax2/tests/data/parser/inline/0091_fn_decl.txt
new file mode 100644
index 000000000..5a76af652
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0091_fn_decl.txt
@@ -0,0 +1,21 @@
+FILE@[0; 22)
+  TRAIT_ITEM@[0; 21)
+    TRAIT_KW@[0; 5)
+    WHITESPACE@[5; 6)
+    NAME@[6; 7)
+      IDENT@[6; 7) "T"
+    WHITESPACE@[7; 8)
+    L_CURLY@[8; 9)
+    WHITESPACE@[9; 10)
+    FUNCTION@[10; 19)
+      FN_KW@[10; 12)
+      WHITESPACE@[12; 13)
+      NAME@[13; 16)
+        IDENT@[13; 16) "foo"
+      PARAM_LIST@[16; 18)
+        L_PAREN@[16; 17)
+        R_PAREN@[17; 18)
+      SEMI@[18; 19)
+    WHITESPACE@[19; 20)
+    R_CURLY@[20; 21)
+  WHITESPACE@[21; 22)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0092_literal_pattern.rs b/crates/libsyntax2/tests/data/parser/inline/0092_literal_pattern.rs
new file mode 100644
index 000000000..16f674d9d
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0092_literal_pattern.rs
@@ -0,0 +1,7 @@
+fn main() {
+    match () {
+        92 => (),
+        'c' => (),
+        "hello" => (),
+    }
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0092_literal_pattern.txt b/crates/libsyntax2/tests/data/parser/inline/0092_literal_pattern.txt
new file mode 100644
index 000000000..a2f985408
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0092_literal_pattern.txt
@@ -0,0 +1,59 @@
+FILE@[0; 95)
+  FUNCTION@[0; 94)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8)
+      R_PAREN@[8; 9)
+    WHITESPACE@[9; 10)
+    BLOCK_EXPR@[10; 94)
+      L_CURLY@[10; 11)
+      WHITESPACE@[11; 16)
+      MATCH_EXPR@[16; 92)
+        MATCH_KW@[16; 21)
+        WHITESPACE@[21; 22)
+        TUPLE_EXPR@[22; 24)
+          L_PAREN@[22; 23)
+          R_PAREN@[23; 24)
+        WHITESPACE@[24; 25)
+        L_CURLY@[25; 26)
+        WHITESPACE@[26; 35)
+        MATCH_ARM@[35; 43)
+          LITERAL@[35; 37)
+            INT_NUMBER@[35; 37) "92"
+          WHITESPACE@[37; 38)
+          FAT_ARROW@[38; 40)
+          WHITESPACE@[40; 41)
+          TUPLE_EXPR@[41; 43)
+            L_PAREN@[41; 42)
+            R_PAREN@[42; 43)
+        COMMA@[43; 44)
+        WHITESPACE@[44; 53)
+        MATCH_ARM@[53; 62)
+          LITERAL@[53; 56)
+            CHAR@[53; 56)
+          WHITESPACE@[56; 57)
+          FAT_ARROW@[57; 59)
+          WHITESPACE@[59; 60)
+          TUPLE_EXPR@[60; 62)
+            L_PAREN@[60; 61)
+            R_PAREN@[61; 62)
+        COMMA@[62; 63)
+        WHITESPACE@[63; 72)
+        MATCH_ARM@[72; 85)
+          LITERAL@[72; 79)
+            STRING@[72; 79)
+          WHITESPACE@[79; 80)
+          FAT_ARROW@[80; 82)
+          WHITESPACE@[82; 83)
+          TUPLE_EXPR@[83; 85)
+            L_PAREN@[83; 84)
+            R_PAREN@[84; 85)
+        COMMA@[85; 86)
+        WHITESPACE@[86; 91)
+        R_CURLY@[91; 92)
+      WHITESPACE@[92; 93)
+      R_CURLY@[93; 94)
+  WHITESPACE@[94; 95)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0093_path_fn_trait_args.rs b/crates/libsyntax2/tests/data/parser/inline/0093_path_fn_trait_args.rs
new file mode 100644
index 000000000..aef45e561
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0093_path_fn_trait_args.rs
@@ -0,0 +1 @@
+type F = Box<Fn(x: i32) -> ()>;
diff --git a/crates/libsyntax2/tests/data/parser/inline/0093_path_fn_trait_args.txt b/crates/libsyntax2/tests/data/parser/inline/0093_path_fn_trait_args.txt
new file mode 100644
index 000000000..800a4ac14
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0093_path_fn_trait_args.txt
@@ -0,0 +1,45 @@
+FILE@[0; 32)
+  TYPE_ITEM@[0; 31)
+    TYPE_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 6)
+      IDENT@[5; 6) "F"
+    WHITESPACE@[6; 7)
+    EQ@[7; 8)
+    WHITESPACE@[8; 9)
+    PATH_TYPE@[9; 30)
+      PATH@[9; 30)
+        PATH_SEGMENT@[9; 30)
+          NAME_REF@[9; 12)
+            IDENT@[9; 12) "Box"
+          TYPE_ARG_LIST@[12; 30)
+            L_ANGLE@[12; 13)
+            TYPE_ARG@[13; 29)
+              PATH_TYPE@[13; 29)
+                PATH@[13; 29)
+                  PATH_SEGMENT@[13; 29)
+                    NAME_REF@[13; 15)
+                      IDENT@[13; 15) "Fn"
+                    PARAM_LIST@[15; 23)
+                      L_PAREN@[15; 16)
+                      PARAM@[16; 22)
+                        BIND_PAT@[16; 17)
+                          NAME@[16; 17)
+                            IDENT@[16; 17) "x"
+                        COLON@[17; 18)
+                        WHITESPACE@[18; 19)
+                        PATH_TYPE@[19; 22)
+                          PATH@[19; 22)
+                            PATH_SEGMENT@[19; 22)
+                              NAME_REF@[19; 22)
+                                IDENT@[19; 22) "i32"
+                      R_PAREN@[22; 23)
+                    WHITESPACE@[23; 24)
+                    THIN_ARROW@[24; 26)
+                    WHITESPACE@[26; 27)
+                    TUPLE_TYPE@[27; 29)
+                      L_PAREN@[27; 28)
+                      R_PAREN@[28; 29)
+            R_ANGLE@[29; 30)
+    SEMI@[30; 31)
+  WHITESPACE@[31; 32)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0094_range_pat.rs b/crates/libsyntax2/tests/data/parser/inline/0094_range_pat.rs
new file mode 100644
index 000000000..657467e75
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0094_range_pat.rs
@@ -0,0 +1,3 @@
+fn main() {
+    match 92 { 0 ... 100 => () }
+}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0094_range_pat.txt b/crates/libsyntax2/tests/data/parser/inline/0094_range_pat.txt
new file mode 100644
index 000000000..cb858044a
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0094_range_pat.txt
@@ -0,0 +1,41 @@
+FILE@[0; 47)
+  FUNCTION@[0; 46)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8)
+      R_PAREN@[8; 9)
+    WHITESPACE@[9; 10)
+    BLOCK_EXPR@[10; 46)
+      L_CURLY@[10; 11)
+      WHITESPACE@[11; 16)
+      MATCH_EXPR@[16; 44)
+        MATCH_KW@[16; 21)
+        WHITESPACE@[21; 22)
+        LITERAL@[22; 24)
+          INT_NUMBER@[22; 24) "92"
+        WHITESPACE@[24; 25)
+        L_CURLY@[25; 26)
+        WHITESPACE@[26; 27)
+        MATCH_ARM@[27; 42)
+          RANGE_PAT@[27; 36)
+            LITERAL@[27; 28)
+              INT_NUMBER@[27; 28) "0"
+            WHITESPACE@[28; 29)
+            DOTDOTDOT@[29; 32)
+            WHITESPACE@[32; 33)
+            LITERAL@[33; 36)
+              INT_NUMBER@[33; 36) "100"
+          WHITESPACE@[36; 37)
+          FAT_ARROW@[37; 39)
+          WHITESPACE@[39; 40)
+          TUPLE_EXPR@[40; 42)
+            L_PAREN@[40; 41)
+            R_PAREN@[41; 42)
+        WHITESPACE@[42; 43)
+        R_CURLY@[43; 44)
+      WHITESPACE@[44; 45)
+      R_CURLY@[45; 46)
+  WHITESPACE@[46; 47)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0095_path_type_with_bounds.rs b/crates/libsyntax2/tests/data/parser/inline/0095_path_type_with_bounds.rs
new file mode 100644
index 000000000..215210e27
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0095_path_type_with_bounds.rs
@@ -0,0 +1 @@
+fn foo() -> Box<T + 'f> {}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0095_path_type_with_bounds.txt b/crates/libsyntax2/tests/data/parser/inline/0095_path_type_with_bounds.txt
new file mode 100644
index 000000000..57c38e7ee
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0095_path_type_with_bounds.txt
@@ -0,0 +1,35 @@
+FILE@[0; 27)
+  FUNCTION@[0; 26)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    THIN_ARROW@[9; 11)
+    WHITESPACE@[11; 12)
+    PATH_TYPE@[12; 23)
+      PATH@[12; 23)
+        PATH_SEGMENT@[12; 23)
+          NAME_REF@[12; 15)
+            IDENT@[12; 15) "Box"
+          TYPE_ARG_LIST@[15; 23)
+            L_ANGLE@[15; 16)
+            TYPE_ARG@[16; 22)
+              PATH_TYPE@[16; 22)
+                PATH@[16; 17)
+                  PATH_SEGMENT@[16; 17)
+                    NAME_REF@[16; 17)
+                      IDENT@[16; 17) "T"
+                WHITESPACE@[17; 18)
+                PLUS@[18; 19)
+                WHITESPACE@[19; 20)
+                LIFETIME@[20; 22) "'f"
+            R_ANGLE@[22; 23)
+    WHITESPACE@[23; 24)
+    BLOCK_EXPR@[24; 26)
+      L_CURLY@[24; 25)
+      R_CURLY@[25; 26)
+  WHITESPACE@[26; 27)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0096_value_parameters_no_patterns.rs b/crates/libsyntax2/tests/data/parser/inline/0096_value_parameters_no_patterns.rs
new file mode 100644
index 000000000..d8c23c76a
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0096_value_parameters_no_patterns.rs
@@ -0,0 +1 @@
+type F = Box<Fn(a: i32, &b: &i32, &mut c: &i32, ())>;
diff --git a/crates/libsyntax2/tests/data/parser/inline/0096_value_parameters_no_patterns.txt b/crates/libsyntax2/tests/data/parser/inline/0096_value_parameters_no_patterns.txt
new file mode 100644
index 000000000..c3f9bf685
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0096_value_parameters_no_patterns.txt
@@ -0,0 +1,81 @@
+FILE@[0; 54)
+  TYPE_ITEM@[0; 53)
+    TYPE_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 6)
+      IDENT@[5; 6) "F"
+    WHITESPACE@[6; 7)
+    EQ@[7; 8)
+    WHITESPACE@[8; 9)
+    PATH_TYPE@[9; 52)
+      PATH@[9; 52)
+        PATH_SEGMENT@[9; 52)
+          NAME_REF@[9; 12)
+            IDENT@[9; 12) "Box"
+          TYPE_ARG_LIST@[12; 52)
+            L_ANGLE@[12; 13)
+            TYPE_ARG@[13; 51)
+              PATH_TYPE@[13; 51)
+                PATH@[13; 51)
+                  PATH_SEGMENT@[13; 51)
+                    NAME_REF@[13; 15)
+                      IDENT@[13; 15) "Fn"
+                    PARAM_LIST@[15; 51)
+                      L_PAREN@[15; 16)
+                      PARAM@[16; 22)
+                        BIND_PAT@[16; 17)
+                          NAME@[16; 17)
+                            IDENT@[16; 17) "a"
+                        COLON@[17; 18)
+                        WHITESPACE@[18; 19)
+                        PATH_TYPE@[19; 22)
+                          PATH@[19; 22)
+                            PATH_SEGMENT@[19; 22)
+                              NAME_REF@[19; 22)
+                                IDENT@[19; 22) "i32"
+                      COMMA@[22; 23)
+                      WHITESPACE@[23; 24)
+                      PARAM@[24; 32)
+                        REF_PAT@[24; 26)
+                          AMP@[24; 25)
+                          BIND_PAT@[25; 26)
+                            NAME@[25; 26)
+                              IDENT@[25; 26) "b"
+                        COLON@[26; 27)
+                        WHITESPACE@[27; 28)
+                        REFERENCE_TYPE@[28; 32)
+                          AMP@[28; 29)
+                          PATH_TYPE@[29; 32)
+                            PATH@[29; 32)
+                              PATH_SEGMENT@[29; 32)
+                                NAME_REF@[29; 32)
+                                  IDENT@[29; 32) "i32"
+                      COMMA@[32; 33)
+                      WHITESPACE@[33; 34)
+                      PARAM@[34; 46)
+                        REF_PAT@[34; 40)
+                          AMP@[34; 35)
+                          MUT_KW@[35; 38)
+                          WHITESPACE@[38; 39)
+                          BIND_PAT@[39; 40)
+                            NAME@[39; 40)
+                              IDENT@[39; 40) "c"
+                        COLON@[40; 41)
+                        WHITESPACE@[41; 42)
+                        REFERENCE_TYPE@[42; 46)
+                          AMP@[42; 43)
+                          PATH_TYPE@[43; 46)
+                            PATH@[43; 46)
+                              PATH_SEGMENT@[43; 46)
+                                NAME_REF@[43; 46)
+                                  IDENT@[43; 46) "i32"
+                      COMMA@[46; 47)
+                      WHITESPACE@[47; 48)
+                      PARAM@[48; 50)
+                        TUPLE_TYPE@[48; 50)
+                          L_PAREN@[48; 49)
+                          R_PAREN@[49; 50)
+                      R_PAREN@[50; 51)
+            R_ANGLE@[51; 52)
+    SEMI@[52; 53)
+  WHITESPACE@[53; 54)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0097_param_list_opt_patterns.rs b/crates/libsyntax2/tests/data/parser/inline/0097_param_list_opt_patterns.rs
new file mode 100644
index 000000000..9b93442c0
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0097_param_list_opt_patterns.rs
@@ -0,0 +1 @@
+fn foo<F: FnMut(&mut Foo<'a>)>(){}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0097_param_list_opt_patterns.txt b/crates/libsyntax2/tests/data/parser/inline/0097_param_list_opt_patterns.txt
new file mode 100644
index 000000000..4cb3bdac5
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0097_param_list_opt_patterns.txt
@@ -0,0 +1,43 @@
+FILE@[0; 35)
+  FUNCTION@[0; 34)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    TYPE_PARAM_LIST@[6; 30)
+      L_ANGLE@[6; 7)
+      TYPE_PARAM@[7; 29)
+        NAME@[7; 8)
+          IDENT@[7; 8) "F"
+        COLON@[8; 9)
+        WHITESPACE@[9; 10)
+        PATH@[10; 29)
+          PATH_SEGMENT@[10; 29)
+            NAME_REF@[10; 15)
+              IDENT@[10; 15) "FnMut"
+            PARAM_LIST@[15; 29)
+              L_PAREN@[15; 16)
+              PARAM@[16; 28)
+                REFERENCE_TYPE@[16; 28)
+                  AMP@[16; 17)
+                  MUT_KW@[17; 20)
+                  WHITESPACE@[20; 21)
+                  PATH_TYPE@[21; 28)
+                    PATH@[21; 28)
+                      PATH_SEGMENT@[21; 28)
+                        NAME_REF@[21; 24)
+                          IDENT@[21; 24) "Foo"
+                        TYPE_ARG_LIST@[24; 28)
+                          L_ANGLE@[24; 25)
+                          LIFETIME_ARG@[25; 27)
+                            LIFETIME@[25; 27) "'a"
+                          R_ANGLE@[27; 28)
+              R_PAREN@[28; 29)
+      R_ANGLE@[29; 30)
+    PARAM_LIST@[30; 32)
+      L_PAREN@[30; 31)
+      R_PAREN@[31; 32)
+    BLOCK_EXPR@[32; 34)
+      L_CURLY@[32; 33)
+      R_CURLY@[33; 34)
+  WHITESPACE@[34; 35)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0098_where_clause.rs b/crates/libsyntax2/tests/data/parser/inline/0098_where_clause.rs
new file mode 100644
index 000000000..592a005f9
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0098_where_clause.rs
@@ -0,0 +1,6 @@
+fn foo()
+where
+   'a: 'b + 'c,
+   T: Clone + Copy + 'static,
+   Iterator::Item: 'a,
+{}
diff --git a/crates/libsyntax2/tests/data/parser/inline/0098_where_clause.txt b/crates/libsyntax2/tests/data/parser/inline/0098_where_clause.txt
new file mode 100644
index 000000000..150f125a7
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0098_where_clause.txt
@@ -0,0 +1,69 @@
+FILE@[0; 87)
+  FUNCTION@[0; 86)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    WHERE_CLAUSE@[9; 83)
+      WHERE_KW@[9; 14)
+      WHITESPACE@[14; 18)
+      WHERE_PRED@[18; 29)
+        LIFETIME@[18; 20) "'a"
+        COLON@[20; 21)
+        WHITESPACE@[21; 22)
+        LIFETIME@[22; 24) "'b"
+        WHITESPACE@[24; 25)
+        PLUS@[25; 26)
+        WHITESPACE@[26; 27)
+        LIFETIME@[27; 29) "'c"
+      COMMA@[29; 30)
+      WHITESPACE@[30; 34)
+      WHERE_PRED@[34; 59)
+        PATH_TYPE@[34; 35)
+          PATH@[34; 35)
+            PATH_SEGMENT@[34; 35)
+              NAME_REF@[34; 35)
+                IDENT@[34; 35) "T"
+        COLON@[35; 36)
+        WHITESPACE@[36; 37)
+        PATH@[37; 42)
+          PATH_SEGMENT@[37; 42)
+            NAME_REF@[37; 42)
+              IDENT@[37; 42) "Clone"
+        WHITESPACE@[42; 43)
+        PLUS@[43; 44)
+        WHITESPACE@[44; 45)
+        PATH@[45; 49)
+          PATH_SEGMENT@[45; 49)
+            NAME_REF@[45; 49)
+              IDENT@[45; 49) "Copy"
+        WHITESPACE@[49; 50)
+        PLUS@[50; 51)
+        WHITESPACE@[51; 52)
+        LIFETIME@[52; 59) "'static"
+      COMMA@[59; 60)
+      WHITESPACE@[60; 64)
+      WHERE_PRED@[64; 82)
+        PATH_TYPE@[64; 78)
+          PATH@[64; 78)
+            PATH@[64; 72)
+              PATH_SEGMENT@[64; 72)
+                NAME_REF@[64; 72)
+                  IDENT@[64; 72) "Iterator"
+            COLONCOLON@[72; 74)
+            PATH_SEGMENT@[74; 78)
+              NAME_REF@[74; 78)
+                IDENT@[74; 78) "Item"
+        COLON@[78; 79)
+        WHITESPACE@[79; 80)
+        LIFETIME@[80; 82) "'a"
+      COMMA@[82; 83)
+    WHITESPACE@[83; 84)
+    BLOCK_EXPR@[84; 86)
+      L_CURLY@[84; 85)
+      R_CURLY@[85; 86)
+  WHITESPACE@[86; 87)
diff --git a/crates/libsyntax2/tests/data/parser/inline/0099_crate_keyword_vis.rs b/crates/libsyntax2/tests/data/parser/inline/0099_crate_keyword_vis.rs
new file mode 100644
index 000000000..660d927cf
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0099_crate_keyword_vis.rs
@@ -0,0 +1 @@
+crate fn main() { }
diff --git a/crates/libsyntax2/tests/data/parser/inline/0099_crate_keyword_vis.txt b/crates/libsyntax2/tests/data/parser/inline/0099_crate_keyword_vis.txt
new file mode 100644
index 000000000..a830d99d9
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/inline/0099_crate_keyword_vis.txt
@@ -0,0 +1,18 @@
+FILE@[0; 20)
+  FUNCTION@[0; 19)
+    VISIBILITY@[0; 5)
+      CRATE_KW@[0; 5)
+    WHITESPACE@[5; 6)
+    FN_KW@[6; 8)
+    WHITESPACE@[8; 9)
+    NAME@[9; 13)
+      IDENT@[9; 13) "main"
+    PARAM_LIST@[13; 15)
+      L_PAREN@[13; 14)
+      R_PAREN@[14; 15)
+    WHITESPACE@[15; 16)
+    BLOCK_EXPR@[16; 19)
+      L_CURLY@[16; 17)
+      WHITESPACE@[17; 18)
+      R_CURLY@[18; 19)
+  WHITESPACE@[19; 20)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0000_empty.rs b/crates/libsyntax2/tests/data/parser/ok/0000_empty.rs
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0000_empty.rs
diff --git a/crates/libsyntax2/tests/data/parser/ok/0000_empty.txt b/crates/libsyntax2/tests/data/parser/ok/0000_empty.txt
new file mode 100644
index 000000000..54be3e7bc
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0000_empty.txt
@@ -0,0 +1 @@
+FILE@[0; 0)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0001_struct_item.rs b/crates/libsyntax2/tests/data/parser/ok/0001_struct_item.rs
new file mode 100644
index 000000000..d3a8c1d23
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0001_struct_item.rs
@@ -0,0 +1,3 @@
+struct S {
+
+}
\ No newline at end of file
diff --git a/crates/libsyntax2/tests/data/parser/ok/0001_struct_item.txt b/crates/libsyntax2/tests/data/parser/ok/0001_struct_item.txt
new file mode 100644
index 000000000..3d5b5cb7f
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0001_struct_item.txt
@@ -0,0 +1,10 @@
+FILE@[0; 13)
+  STRUCT_ITEM@[0; 13)
+    STRUCT_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    NAME@[7; 8)
+      IDENT@[7; 8) "S"
+    WHITESPACE@[8; 9)
+    L_CURLY@[9; 10)
+    WHITESPACE@[10; 12)
+    R_CURLY@[12; 13)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0002_struct_item_field.rs b/crates/libsyntax2/tests/data/parser/ok/0002_struct_item_field.rs
new file mode 100644
index 000000000..cc3866d25
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0002_struct_item_field.rs
@@ -0,0 +1,3 @@
+struct S {
+    foo: u32
+}
\ No newline at end of file
diff --git a/crates/libsyntax2/tests/data/parser/ok/0002_struct_item_field.txt b/crates/libsyntax2/tests/data/parser/ok/0002_struct_item_field.txt
new file mode 100644
index 000000000..1129ce39e
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0002_struct_item_field.txt
@@ -0,0 +1,21 @@
+FILE@[0; 25)
+  STRUCT_ITEM@[0; 25)
+    STRUCT_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    NAME@[7; 8)
+      IDENT@[7; 8) "S"
+    WHITESPACE@[8; 9)
+    L_CURLY@[9; 10)
+    WHITESPACE@[10; 15)
+    NAMED_FIELD@[15; 23)
+      NAME@[15; 18)
+        IDENT@[15; 18) "foo"
+      COLON@[18; 19)
+      WHITESPACE@[19; 20)
+      PATH_TYPE@[20; 23)
+        PATH@[20; 23)
+          PATH_SEGMENT@[20; 23)
+            NAME_REF@[20; 23)
+              IDENT@[20; 23) "u32"
+    WHITESPACE@[23; 24)
+    R_CURLY@[24; 25)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0004_file_shebang.rs b/crates/libsyntax2/tests/data/parser/ok/0004_file_shebang.rs
new file mode 100644
index 000000000..53dc9e617
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0004_file_shebang.rs
@@ -0,0 +1 @@
+#!/use/bin/env rusti
\ No newline at end of file
diff --git a/crates/libsyntax2/tests/data/parser/ok/0004_file_shebang.txt b/crates/libsyntax2/tests/data/parser/ok/0004_file_shebang.txt
new file mode 100644
index 000000000..33055cf3d
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0004_file_shebang.txt
@@ -0,0 +1,2 @@
+FILE@[0; 20)
+  SHEBANG@[0; 20)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0005_fn_item.rs b/crates/libsyntax2/tests/data/parser/ok/0005_fn_item.rs
new file mode 100644
index 000000000..03210551c
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0005_fn_item.rs
@@ -0,0 +1,2 @@
+fn foo() {
+}
diff --git a/crates/libsyntax2/tests/data/parser/ok/0005_fn_item.txt b/crates/libsyntax2/tests/data/parser/ok/0005_fn_item.txt
new file mode 100644
index 000000000..4ab93d408
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0005_fn_item.txt
@@ -0,0 +1,15 @@
+FILE@[0; 13)
+  FUNCTION@[0; 12)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 12)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 11)
+      R_CURLY@[11; 12)
+  WHITESPACE@[12; 13)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0006_inner_attributes.rs b/crates/libsyntax2/tests/data/parser/ok/0006_inner_attributes.rs
new file mode 100644
index 000000000..e81f8b1e8
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0006_inner_attributes.rs
@@ -0,0 +1,10 @@
+#![attr]
+#![attr(true)]
+#![attr(ident)]
+#![attr(ident, 100, true, "true", ident = 100, ident = "hello", ident(100))]
+#![attr(100)]
+#![attr(enabled = true)]
+#![enabled(true)]
+#![attr("hello")]
+#![repr(C, align = 4)]
+#![repr(C, align(4))]
\ No newline at end of file
diff --git a/crates/libsyntax2/tests/data/parser/ok/0006_inner_attributes.txt b/crates/libsyntax2/tests/data/parser/ok/0006_inner_attributes.txt
new file mode 100644
index 000000000..562c8d917
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0006_inner_attributes.txt
@@ -0,0 +1,176 @@
+FILE@[0; 236)
+  ATTR@[0; 8)
+    POUND@[0; 1)
+    EXCL@[1; 2)
+    L_BRACK@[2; 3)
+    META_ITEM@[3; 7)
+      IDENT@[3; 7) "attr"
+    R_BRACK@[7; 8)
+  WHITESPACE@[8; 9)
+  ATTR@[9; 23)
+    POUND@[9; 10)
+    EXCL@[10; 11)
+    L_BRACK@[11; 12)
+    META_ITEM@[12; 22)
+      IDENT@[12; 16) "attr"
+      L_PAREN@[16; 17)
+      LITERAL@[17; 21)
+        TRUE_KW@[17; 21)
+      R_PAREN@[21; 22)
+    R_BRACK@[22; 23)
+  WHITESPACE@[23; 24)
+  ATTR@[24; 39)
+    POUND@[24; 25)
+    EXCL@[25; 26)
+    L_BRACK@[26; 27)
+    META_ITEM@[27; 38)
+      IDENT@[27; 31) "attr"
+      L_PAREN@[31; 32)
+      META_ITEM@[32; 37)
+        IDENT@[32; 37) "ident"
+      R_PAREN@[37; 38)
+    R_BRACK@[38; 39)
+  WHITESPACE@[39; 40)
+  ATTR@[40; 116)
+    POUND@[40; 41)
+    EXCL@[41; 42)
+    L_BRACK@[42; 43)
+    META_ITEM@[43; 115)
+      IDENT@[43; 47) "attr"
+      L_PAREN@[47; 48)
+      META_ITEM@[48; 53)
+        IDENT@[48; 53) "ident"
+      COMMA@[53; 54)
+      WHITESPACE@[54; 55)
+      LITERAL@[55; 58)
+        INT_NUMBER@[55; 58) "100"
+      COMMA@[58; 59)
+      WHITESPACE@[59; 60)
+      LITERAL@[60; 64)
+        TRUE_KW@[60; 64)
+      COMMA@[64; 65)
+      WHITESPACE@[65; 66)
+      LITERAL@[66; 72)
+        STRING@[66; 72)
+      COMMA@[72; 73)
+      WHITESPACE@[73; 74)
+      META_ITEM@[74; 85)
+        IDENT@[74; 79) "ident"
+        WHITESPACE@[79; 80)
+        EQ@[80; 81)
+        WHITESPACE@[81; 82)
+        LITERAL@[82; 85)
+          INT_NUMBER@[82; 85) "100"
+      COMMA@[85; 86)
+      WHITESPACE@[86; 87)
+      META_ITEM@[87; 102)
+        IDENT@[87; 92) "ident"
+        WHITESPACE@[92; 93)
+        EQ@[93; 94)
+        WHITESPACE@[94; 95)
+        LITERAL@[95; 102)
+          STRING@[95; 102)
+      COMMA@[102; 103)
+      WHITESPACE@[103; 104)
+      META_ITEM@[104; 114)
+        IDENT@[104; 109) "ident"
+        L_PAREN@[109; 110)
+        LITERAL@[110; 113)
+          INT_NUMBER@[110; 113) "100"
+        R_PAREN@[113; 114)
+      R_PAREN@[114; 115)
+    R_BRACK@[115; 116)
+  WHITESPACE@[116; 117)
+  ATTR@[117; 130)
+    POUND@[117; 118)
+    EXCL@[118; 119)
+    L_BRACK@[119; 120)
+    META_ITEM@[120; 129)
+      IDENT@[120; 124) "attr"
+      L_PAREN@[124; 125)
+      LITERAL@[125; 128)
+        INT_NUMBER@[125; 128) "100"
+      R_PAREN@[128; 129)
+    R_BRACK@[129; 130)
+  WHITESPACE@[130; 131)
+  ATTR@[131; 155)
+    POUND@[131; 132)
+    EXCL@[132; 133)
+    L_BRACK@[133; 134)
+    META_ITEM@[134; 154)
+      IDENT@[134; 138) "attr"
+      L_PAREN@[138; 139)
+      META_ITEM@[139; 153)
+        IDENT@[139; 146) "enabled"
+        WHITESPACE@[146; 147)
+        EQ@[147; 148)
+        WHITESPACE@[148; 149)
+        LITERAL@[149; 153)
+          TRUE_KW@[149; 153)
+      R_PAREN@[153; 154)
+    R_BRACK@[154; 155)
+  WHITESPACE@[155; 156)
+  ATTR@[156; 173)
+    POUND@[156; 157)
+    EXCL@[157; 158)
+    L_BRACK@[158; 159)
+    META_ITEM@[159; 172)
+      IDENT@[159; 166) "enabled"
+      L_PAREN@[166; 167)
+      LITERAL@[167; 171)
+        TRUE_KW@[167; 171)
+      R_PAREN@[171; 172)
+    R_BRACK@[172; 173)
+  WHITESPACE@[173; 174)
+  ATTR@[174; 191)
+    POUND@[174; 175)
+    EXCL@[175; 176)
+    L_BRACK@[176; 177)
+    META_ITEM@[177; 190)
+      IDENT@[177; 181) "attr"
+      L_PAREN@[181; 182)
+      LITERAL@[182; 189)
+        STRING@[182; 189)
+      R_PAREN@[189; 190)
+    R_BRACK@[190; 191)
+  WHITESPACE@[191; 192)
+  ATTR@[192; 214)
+    POUND@[192; 193)
+    EXCL@[193; 194)
+    L_BRACK@[194; 195)
+    META_ITEM@[195; 213)
+      IDENT@[195; 199) "repr"
+      L_PAREN@[199; 200)
+      META_ITEM@[200; 201)
+        IDENT@[200; 201) "C"
+      COMMA@[201; 202)
+      WHITESPACE@[202; 203)
+      META_ITEM@[203; 212)
+        IDENT@[203; 208) "align"
+        WHITESPACE@[208; 209)
+        EQ@[209; 210)
+        WHITESPACE@[210; 211)
+        LITERAL@[211; 212)
+          INT_NUMBER@[211; 212) "4"
+      R_PAREN@[212; 213)
+    R_BRACK@[213; 214)
+  WHITESPACE@[214; 215)
+  ATTR@[215; 236)
+    POUND@[215; 216)
+    EXCL@[216; 217)
+    L_BRACK@[217; 218)
+    META_ITEM@[218; 235)
+      IDENT@[218; 222) "repr"
+      L_PAREN@[222; 223)
+      META_ITEM@[223; 224)
+        IDENT@[223; 224) "C"
+      COMMA@[224; 225)
+      WHITESPACE@[225; 226)
+      META_ITEM@[226; 234)
+        IDENT@[226; 231) "align"
+        L_PAREN@[231; 232)
+        LITERAL@[232; 233)
+          INT_NUMBER@[232; 233) "4"
+        R_PAREN@[233; 234)
+      R_PAREN@[234; 235)
+    R_BRACK@[235; 236)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0007_extern_crate.rs b/crates/libsyntax2/tests/data/parser/ok/0007_extern_crate.rs
new file mode 100644
index 000000000..3ce336676
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0007_extern_crate.rs
@@ -0,0 +1,2 @@
+extern crate foo;
+extern crate foo as bar;
diff --git a/crates/libsyntax2/tests/data/parser/ok/0007_extern_crate.txt b/crates/libsyntax2/tests/data/parser/ok/0007_extern_crate.txt
new file mode 100644
index 000000000..533af33c4
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0007_extern_crate.txt
@@ -0,0 +1,25 @@
+FILE@[0; 43)
+  EXTERN_CRATE_ITEM@[0; 17)
+    EXTERN_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    CRATE_KW@[7; 12)
+    WHITESPACE@[12; 13)
+    NAME@[13; 16)
+      IDENT@[13; 16) "foo"
+    SEMI@[16; 17)
+  WHITESPACE@[17; 18)
+  EXTERN_CRATE_ITEM@[18; 42)
+    EXTERN_KW@[18; 24)
+    WHITESPACE@[24; 25)
+    CRATE_KW@[25; 30)
+    WHITESPACE@[30; 31)
+    NAME@[31; 34)
+      IDENT@[31; 34) "foo"
+    WHITESPACE@[34; 35)
+    ALIAS@[35; 41)
+      AS_KW@[35; 37)
+      WHITESPACE@[37; 38)
+      NAME@[38; 41)
+        IDENT@[38; 41) "bar"
+    SEMI@[41; 42)
+  WHITESPACE@[42; 43)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0008_mod_item.rs b/crates/libsyntax2/tests/data/parser/ok/0008_mod_item.rs
new file mode 100644
index 000000000..d22993bc1
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0008_mod_item.rs
@@ -0,0 +1,17 @@
+mod a;
+
+mod b {
+}
+
+mod c {
+    fn foo() {
+    }
+    struct S {}
+}
+
+mod d {
+    #![attr]
+    mod e;
+    mod f {
+    }
+}
\ No newline at end of file
diff --git a/crates/libsyntax2/tests/data/parser/ok/0008_mod_item.txt b/crates/libsyntax2/tests/data/parser/ok/0008_mod_item.txt
new file mode 100644
index 000000000..1dcaaedce
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0008_mod_item.txt
@@ -0,0 +1,85 @@
+FILE@[0; 118)
+  MOD_ITEM@[0; 6)
+    MOD_KW@[0; 3)
+    WHITESPACE@[3; 4)
+    NAME@[4; 5)
+      IDENT@[4; 5) "a"
+    SEMI@[5; 6)
+  WHITESPACE@[6; 8)
+  MOD_ITEM@[8; 17)
+    MOD_KW@[8; 11)
+    WHITESPACE@[11; 12)
+    NAME@[12; 13)
+      IDENT@[12; 13) "b"
+    WHITESPACE@[13; 14)
+    L_CURLY@[14; 15)
+    WHITESPACE@[15; 16)
+    R_CURLY@[16; 17)
+  WHITESPACE@[17; 19)
+  MOD_ITEM@[19; 65)
+    MOD_KW@[19; 22)
+    WHITESPACE@[22; 23)
+    NAME@[23; 24)
+      IDENT@[23; 24) "c"
+    WHITESPACE@[24; 25)
+    L_CURLY@[25; 26)
+    WHITESPACE@[26; 31)
+    FUNCTION@[31; 47)
+      FN_KW@[31; 33)
+      WHITESPACE@[33; 34)
+      NAME@[34; 37)
+        IDENT@[34; 37) "foo"
+      PARAM_LIST@[37; 39)
+        L_PAREN@[37; 38)
+        R_PAREN@[38; 39)
+      WHITESPACE@[39; 40)
+      BLOCK_EXPR@[40; 47)
+        L_CURLY@[40; 41)
+        WHITESPACE@[41; 46)
+        R_CURLY@[46; 47)
+    WHITESPACE@[47; 52)
+    STRUCT_ITEM@[52; 63)
+      STRUCT_KW@[52; 58)
+      WHITESPACE@[58; 59)
+      NAME@[59; 60)
+        IDENT@[59; 60) "S"
+      WHITESPACE@[60; 61)
+      L_CURLY@[61; 62)
+      R_CURLY@[62; 63)
+    WHITESPACE@[63; 64)
+    R_CURLY@[64; 65)
+  WHITESPACE@[65; 67)
+  MOD_ITEM@[67; 118)
+    MOD_KW@[67; 70)
+    WHITESPACE@[70; 71)
+    NAME@[71; 72)
+      IDENT@[71; 72) "d"
+    WHITESPACE@[72; 73)
+    L_CURLY@[73; 74)
+    WHITESPACE@[74; 79)
+    ATTR@[79; 87)
+      POUND@[79; 80)
+      EXCL@[80; 81)
+      L_BRACK@[81; 82)
+      META_ITEM@[82; 86)
+        IDENT@[82; 86) "attr"
+      R_BRACK@[86; 87)
+    WHITESPACE@[87; 92)
+    MOD_ITEM@[92; 98)
+      MOD_KW@[92; 95)
+      WHITESPACE@[95; 96)
+      NAME@[96; 97)
+        IDENT@[96; 97) "e"
+      SEMI@[97; 98)
+    WHITESPACE@[98; 103)
+    MOD_ITEM@[103; 116)
+      MOD_KW@[103; 106)
+      WHITESPACE@[106; 107)
+      NAME@[107; 108)
+        IDENT@[107; 108) "f"
+      WHITESPACE@[108; 109)
+      L_CURLY@[109; 110)
+      WHITESPACE@[110; 115)
+      R_CURLY@[115; 116)
+    WHITESPACE@[116; 117)
+    R_CURLY@[117; 118)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0009_use_item.rs b/crates/libsyntax2/tests/data/parser/ok/0009_use_item.rs
new file mode 100644
index 000000000..05a6aff83
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0009_use_item.rs
@@ -0,0 +1,2 @@
+use foo;
+use ::bar;
\ No newline at end of file
diff --git a/crates/libsyntax2/tests/data/parser/ok/0009_use_item.txt b/crates/libsyntax2/tests/data/parser/ok/0009_use_item.txt
new file mode 100644
index 000000000..8f850cd1c
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0009_use_item.txt
@@ -0,0 +1,21 @@
+FILE@[0; 19)
+  USE_ITEM@[0; 8)
+    USE_KW@[0; 3)
+    WHITESPACE@[3; 4)
+    USE_TREE@[4; 7)
+      PATH@[4; 7)
+        PATH_SEGMENT@[4; 7)
+          NAME_REF@[4; 7)
+            IDENT@[4; 7) "foo"
+    SEMI@[7; 8)
+  WHITESPACE@[8; 9)
+  USE_ITEM@[9; 19)
+    USE_KW@[9; 12)
+    WHITESPACE@[12; 13)
+    USE_TREE@[13; 18)
+      PATH@[13; 18)
+        PATH_SEGMENT@[13; 18)
+          COLONCOLON@[13; 15)
+          NAME_REF@[15; 18)
+            IDENT@[15; 18) "bar"
+    SEMI@[18; 19)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0010_use_path_segments.rs b/crates/libsyntax2/tests/data/parser/ok/0010_use_path_segments.rs
new file mode 100644
index 000000000..1e71b7a6c
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0010_use_path_segments.rs
@@ -0,0 +1,2 @@
+use ::foo::bar::baz;
+use foo::bar::baz;
diff --git a/crates/libsyntax2/tests/data/parser/ok/0010_use_path_segments.txt b/crates/libsyntax2/tests/data/parser/ok/0010_use_path_segments.txt
new file mode 100644
index 000000000..03ec342c2
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0010_use_path_segments.txt
@@ -0,0 +1,42 @@
+FILE@[0; 40)
+  USE_ITEM@[0; 20)
+    USE_KW@[0; 3)
+    WHITESPACE@[3; 4)
+    USE_TREE@[4; 19)
+      PATH@[4; 19)
+        PATH@[4; 14)
+          PATH@[4; 9)
+            PATH_SEGMENT@[4; 9)
+              COLONCOLON@[4; 6)
+              NAME_REF@[6; 9)
+                IDENT@[6; 9) "foo"
+          COLONCOLON@[9; 11)
+          PATH_SEGMENT@[11; 14)
+            NAME_REF@[11; 14)
+              IDENT@[11; 14) "bar"
+        COLONCOLON@[14; 16)
+        PATH_SEGMENT@[16; 19)
+          NAME_REF@[16; 19)
+            IDENT@[16; 19) "baz"
+    SEMI@[19; 20)
+  WHITESPACE@[20; 21)
+  USE_ITEM@[21; 39)
+    USE_KW@[21; 24)
+    WHITESPACE@[24; 25)
+    USE_TREE@[25; 38)
+      PATH@[25; 38)
+        PATH@[25; 33)
+          PATH@[25; 28)
+            PATH_SEGMENT@[25; 28)
+              NAME_REF@[25; 28)
+                IDENT@[25; 28) "foo"
+          COLONCOLON@[28; 30)
+          PATH_SEGMENT@[30; 33)
+            NAME_REF@[30; 33)
+              IDENT@[30; 33) "bar"
+        COLONCOLON@[33; 35)
+        PATH_SEGMENT@[35; 38)
+          NAME_REF@[35; 38)
+            IDENT@[35; 38) "baz"
+    SEMI@[38; 39)
+  WHITESPACE@[39; 40)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0011_outer_attribute.rs b/crates/libsyntax2/tests/data/parser/ok/0011_outer_attribute.rs
new file mode 100644
index 000000000..8b80c0d90
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0011_outer_attribute.rs
@@ -0,0 +1,3 @@
+#[cfg(test)]
+#[ignore]
+fn foo() {}
diff --git a/crates/libsyntax2/tests/data/parser/ok/0011_outer_attribute.txt b/crates/libsyntax2/tests/data/parser/ok/0011_outer_attribute.txt
new file mode 100644
index 000000000..9824c9083
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0011_outer_attribute.txt
@@ -0,0 +1,32 @@
+FILE@[0; 35)
+  FUNCTION@[0; 34)
+    ATTR@[0; 12)
+      POUND@[0; 1)
+      L_BRACK@[1; 2)
+      META_ITEM@[2; 11)
+        IDENT@[2; 5) "cfg"
+        L_PAREN@[5; 6)
+        META_ITEM@[6; 10)
+          IDENT@[6; 10) "test"
+        R_PAREN@[10; 11)
+      R_BRACK@[11; 12)
+    WHITESPACE@[12; 13)
+    ATTR@[13; 22)
+      POUND@[13; 14)
+      L_BRACK@[14; 15)
+      META_ITEM@[15; 21)
+        IDENT@[15; 21) "ignore"
+      R_BRACK@[21; 22)
+    WHITESPACE@[22; 23)
+    FN_KW@[23; 25)
+    WHITESPACE@[25; 26)
+    NAME@[26; 29)
+      IDENT@[26; 29) "foo"
+    PARAM_LIST@[29; 31)
+      L_PAREN@[29; 30)
+      R_PAREN@[30; 31)
+    WHITESPACE@[31; 32)
+    BLOCK_EXPR@[32; 34)
+      L_CURLY@[32; 33)
+      R_CURLY@[33; 34)
+  WHITESPACE@[34; 35)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0012_visibility.rs b/crates/libsyntax2/tests/data/parser/ok/0012_visibility.rs
new file mode 100644
index 000000000..75b1db121
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0012_visibility.rs
@@ -0,0 +1,5 @@
+fn a() {}
+pub fn b() {}
+pub(crate) fn c() {}
+pub(super) fn d() {}
+pub(in foo::bar::baz) fn e() {}
diff --git a/crates/libsyntax2/tests/data/parser/ok/0012_visibility.txt b/crates/libsyntax2/tests/data/parser/ok/0012_visibility.txt
new file mode 100644
index 000000000..af0c59543
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0012_visibility.txt
@@ -0,0 +1,102 @@
+FILE@[0; 98)
+  FUNCTION@[0; 9)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 4)
+      IDENT@[3; 4) "a"
+    PARAM_LIST@[4; 6)
+      L_PAREN@[4; 5)
+      R_PAREN@[5; 6)
+    WHITESPACE@[6; 7)
+    BLOCK_EXPR@[7; 9)
+      L_CURLY@[7; 8)
+      R_CURLY@[8; 9)
+  WHITESPACE@[9; 10)
+  FUNCTION@[10; 23)
+    VISIBILITY@[10; 13)
+      PUB_KW@[10; 13)
+    WHITESPACE@[13; 14)
+    FN_KW@[14; 16)
+    WHITESPACE@[16; 17)
+    NAME@[17; 18)
+      IDENT@[17; 18) "b"
+    PARAM_LIST@[18; 20)
+      L_PAREN@[18; 19)
+      R_PAREN@[19; 20)
+    WHITESPACE@[20; 21)
+    BLOCK_EXPR@[21; 23)
+      L_CURLY@[21; 22)
+      R_CURLY@[22; 23)
+  WHITESPACE@[23; 24)
+  FUNCTION@[24; 44)
+    VISIBILITY@[24; 34)
+      PUB_KW@[24; 27)
+      L_PAREN@[27; 28)
+      CRATE_KW@[28; 33)
+      R_PAREN@[33; 34)
+    WHITESPACE@[34; 35)
+    FN_KW@[35; 37)
+    WHITESPACE@[37; 38)
+    NAME@[38; 39)
+      IDENT@[38; 39) "c"
+    PARAM_LIST@[39; 41)
+      L_PAREN@[39; 40)
+      R_PAREN@[40; 41)
+    WHITESPACE@[41; 42)
+    BLOCK_EXPR@[42; 44)
+      L_CURLY@[42; 43)
+      R_CURLY@[43; 44)
+  WHITESPACE@[44; 45)
+  FUNCTION@[45; 65)
+    VISIBILITY@[45; 55)
+      PUB_KW@[45; 48)
+      L_PAREN@[48; 49)
+      SUPER_KW@[49; 54)
+      R_PAREN@[54; 55)
+    WHITESPACE@[55; 56)
+    FN_KW@[56; 58)
+    WHITESPACE@[58; 59)
+    NAME@[59; 60)
+      IDENT@[59; 60) "d"
+    PARAM_LIST@[60; 62)
+      L_PAREN@[60; 61)
+      R_PAREN@[61; 62)
+    WHITESPACE@[62; 63)
+    BLOCK_EXPR@[63; 65)
+      L_CURLY@[63; 64)
+      R_CURLY@[64; 65)
+  WHITESPACE@[65; 66)
+  FUNCTION@[66; 97)
+    VISIBILITY@[66; 87)
+      PUB_KW@[66; 69)
+      L_PAREN@[69; 70)
+      IN_KW@[70; 72)
+      WHITESPACE@[72; 73)
+      PATH@[73; 86)
+        PATH@[73; 81)
+          PATH@[73; 76)
+            PATH_SEGMENT@[73; 76)
+              NAME_REF@[73; 76)
+                IDENT@[73; 76) "foo"
+          COLONCOLON@[76; 78)
+          PATH_SEGMENT@[78; 81)
+            NAME_REF@[78; 81)
+              IDENT@[78; 81) "bar"
+        COLONCOLON@[81; 83)
+        PATH_SEGMENT@[83; 86)
+          NAME_REF@[83; 86)
+            IDENT@[83; 86) "baz"
+      R_PAREN@[86; 87)
+    WHITESPACE@[87; 88)
+    FN_KW@[88; 90)
+    WHITESPACE@[90; 91)
+    NAME@[91; 92)
+      IDENT@[91; 92) "e"
+    PARAM_LIST@[92; 94)
+      L_PAREN@[92; 93)
+      R_PAREN@[93; 94)
+    WHITESPACE@[94; 95)
+    BLOCK_EXPR@[95; 97)
+      L_CURLY@[95; 96)
+      R_CURLY@[96; 97)
+  WHITESPACE@[97; 98)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0013_use_path_self_super.rs b/crates/libsyntax2/tests/data/parser/ok/0013_use_path_self_super.rs
new file mode 100644
index 000000000..faf6a42c7
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0013_use_path_self_super.rs
@@ -0,0 +1,3 @@
+use self::foo;
+use super::super::bar;
+use ::self::a::super::bar;
diff --git a/crates/libsyntax2/tests/data/parser/ok/0013_use_path_self_super.txt b/crates/libsyntax2/tests/data/parser/ok/0013_use_path_self_super.txt
new file mode 100644
index 000000000..5ed27ca37
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0013_use_path_self_super.txt
@@ -0,0 +1,57 @@
+FILE@[0; 65)
+  USE_ITEM@[0; 14)
+    USE_KW@[0; 3)
+    WHITESPACE@[3; 4)
+    USE_TREE@[4; 13)
+      PATH@[4; 13)
+        PATH@[4; 8)
+          PATH_SEGMENT@[4; 8)
+            SELF_KW@[4; 8)
+        COLONCOLON@[8; 10)
+        PATH_SEGMENT@[10; 13)
+          NAME_REF@[10; 13)
+            IDENT@[10; 13) "foo"
+    SEMI@[13; 14)
+  WHITESPACE@[14; 15)
+  USE_ITEM@[15; 37)
+    USE_KW@[15; 18)
+    WHITESPACE@[18; 19)
+    USE_TREE@[19; 36)
+      PATH@[19; 36)
+        PATH@[19; 31)
+          PATH@[19; 24)
+            PATH_SEGMENT@[19; 24)
+              SUPER_KW@[19; 24)
+          COLONCOLON@[24; 26)
+          PATH_SEGMENT@[26; 31)
+            SUPER_KW@[26; 31)
+        COLONCOLON@[31; 33)
+        PATH_SEGMENT@[33; 36)
+          NAME_REF@[33; 36)
+            IDENT@[33; 36) "bar"
+    SEMI@[36; 37)
+  WHITESPACE@[37; 38)
+  USE_ITEM@[38; 64)
+    USE_KW@[38; 41)
+    WHITESPACE@[41; 42)
+    USE_TREE@[42; 63)
+      PATH@[42; 63)
+        PATH@[42; 58)
+          PATH@[42; 51)
+            PATH@[42; 48)
+              PATH_SEGMENT@[42; 48)
+                COLONCOLON@[42; 44)
+                SELF_KW@[44; 48)
+            COLONCOLON@[48; 50)
+            PATH_SEGMENT@[50; 51)
+              NAME_REF@[50; 51)
+                IDENT@[50; 51) "a"
+          COLONCOLON@[51; 53)
+          PATH_SEGMENT@[53; 58)
+            SUPER_KW@[53; 58)
+        COLONCOLON@[58; 60)
+        PATH_SEGMENT@[60; 63)
+          NAME_REF@[60; 63)
+            IDENT@[60; 63) "bar"
+    SEMI@[63; 64)
+  WHITESPACE@[64; 65)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0014_use_tree.rs b/crates/libsyntax2/tests/data/parser/ok/0014_use_tree.rs
new file mode 100644
index 000000000..5e4aa3a33
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0014_use_tree.rs
@@ -0,0 +1,7 @@
+use *;
+use ::*;
+use ::{};
+use {};
+use foo::*;
+use foo::{};
+use ::foo::{a, b, c};
diff --git a/crates/libsyntax2/tests/data/parser/ok/0014_use_tree.txt b/crates/libsyntax2/tests/data/parser/ok/0014_use_tree.txt
new file mode 100644
index 000000000..730d5539b
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0014_use_tree.txt
@@ -0,0 +1,91 @@
+FILE@[0; 81)
+  USE_ITEM@[0; 6)
+    USE_KW@[0; 3)
+    WHITESPACE@[3; 4)
+    USE_TREE@[4; 5)
+      STAR@[4; 5)
+    SEMI@[5; 6)
+  WHITESPACE@[6; 7)
+  USE_ITEM@[7; 15)
+    USE_KW@[7; 10)
+    WHITESPACE@[10; 11)
+    USE_TREE@[11; 14)
+      COLONCOLON@[11; 13)
+      STAR@[13; 14)
+    SEMI@[14; 15)
+  WHITESPACE@[15; 16)
+  USE_ITEM@[16; 25)
+    USE_KW@[16; 19)
+    WHITESPACE@[19; 20)
+    USE_TREE@[20; 24)
+      COLONCOLON@[20; 22)
+      L_CURLY@[22; 23)
+      R_CURLY@[23; 24)
+    SEMI@[24; 25)
+  WHITESPACE@[25; 26)
+  USE_ITEM@[26; 33)
+    USE_KW@[26; 29)
+    WHITESPACE@[29; 30)
+    USE_TREE@[30; 32)
+      L_CURLY@[30; 31)
+      R_CURLY@[31; 32)
+    SEMI@[32; 33)
+  WHITESPACE@[33; 34)
+  USE_ITEM@[34; 45)
+    USE_KW@[34; 37)
+    WHITESPACE@[37; 38)
+    USE_TREE@[38; 44)
+      PATH@[38; 41)
+        PATH_SEGMENT@[38; 41)
+          NAME_REF@[38; 41)
+            IDENT@[38; 41) "foo"
+      COLONCOLON@[41; 43)
+      STAR@[43; 44)
+    SEMI@[44; 45)
+  WHITESPACE@[45; 46)
+  USE_ITEM@[46; 58)
+    USE_KW@[46; 49)
+    WHITESPACE@[49; 50)
+    USE_TREE@[50; 57)
+      PATH@[50; 53)
+        PATH_SEGMENT@[50; 53)
+          NAME_REF@[50; 53)
+            IDENT@[50; 53) "foo"
+      COLONCOLON@[53; 55)
+      L_CURLY@[55; 56)
+      R_CURLY@[56; 57)
+    SEMI@[57; 58)
+  WHITESPACE@[58; 59)
+  USE_ITEM@[59; 80)
+    USE_KW@[59; 62)
+    WHITESPACE@[62; 63)
+    USE_TREE@[63; 79)
+      PATH@[63; 68)
+        PATH_SEGMENT@[63; 68)
+          COLONCOLON@[63; 65)
+          NAME_REF@[65; 68)
+            IDENT@[65; 68) "foo"
+      COLONCOLON@[68; 70)
+      L_CURLY@[70; 71)
+      USE_TREE@[71; 72)
+        PATH@[71; 72)
+          PATH_SEGMENT@[71; 72)
+            NAME_REF@[71; 72)
+              IDENT@[71; 72) "a"
+      COMMA@[72; 73)
+      WHITESPACE@[73; 74)
+      USE_TREE@[74; 75)
+        PATH@[74; 75)
+          PATH_SEGMENT@[74; 75)
+            NAME_REF@[74; 75)
+              IDENT@[74; 75) "b"
+      COMMA@[75; 76)
+      WHITESPACE@[76; 77)
+      USE_TREE@[77; 78)
+        PATH@[77; 78)
+          PATH_SEGMENT@[77; 78)
+            NAME_REF@[77; 78)
+              IDENT@[77; 78) "c"
+      R_CURLY@[78; 79)
+    SEMI@[79; 80)
+  WHITESPACE@[80; 81)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0015_use_tree.rs b/crates/libsyntax2/tests/data/parser/ok/0015_use_tree.rs
new file mode 100644
index 000000000..46a0783a2
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0015_use_tree.rs
@@ -0,0 +1,2 @@
+use foo as bar;
+use foo::{a as b, *, ::*, ::foo as x};
diff --git a/crates/libsyntax2/tests/data/parser/ok/0015_use_tree.txt b/crates/libsyntax2/tests/data/parser/ok/0015_use_tree.txt
new file mode 100644
index 000000000..4438e417b
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0015_use_tree.txt
@@ -0,0 +1,64 @@
+FILE@[0; 55)
+  USE_ITEM@[0; 15)
+    USE_KW@[0; 3)
+    WHITESPACE@[3; 4)
+    USE_TREE@[4; 14)
+      PATH@[4; 7)
+        PATH_SEGMENT@[4; 7)
+          NAME_REF@[4; 7)
+            IDENT@[4; 7) "foo"
+      WHITESPACE@[7; 8)
+      ALIAS@[8; 14)
+        AS_KW@[8; 10)
+        WHITESPACE@[10; 11)
+        NAME@[11; 14)
+          IDENT@[11; 14) "bar"
+    SEMI@[14; 15)
+  WHITESPACE@[15; 16)
+  USE_ITEM@[16; 54)
+    USE_KW@[16; 19)
+    WHITESPACE@[19; 20)
+    USE_TREE@[20; 53)
+      PATH@[20; 23)
+        PATH_SEGMENT@[20; 23)
+          NAME_REF@[20; 23)
+            IDENT@[20; 23) "foo"
+      COLONCOLON@[23; 25)
+      L_CURLY@[25; 26)
+      USE_TREE@[26; 32)
+        PATH@[26; 27)
+          PATH_SEGMENT@[26; 27)
+            NAME_REF@[26; 27)
+              IDENT@[26; 27) "a"
+        WHITESPACE@[27; 28)
+        ALIAS@[28; 32)
+          AS_KW@[28; 30)
+          WHITESPACE@[30; 31)
+          NAME@[31; 32)
+            IDENT@[31; 32) "b"
+      COMMA@[32; 33)
+      WHITESPACE@[33; 34)
+      USE_TREE@[34; 35)
+        STAR@[34; 35)
+      COMMA@[35; 36)
+      WHITESPACE@[36; 37)
+      USE_TREE@[37; 40)
+        COLONCOLON@[37; 39)
+        STAR@[39; 40)
+      COMMA@[40; 41)
+      WHITESPACE@[41; 42)
+      USE_TREE@[42; 52)
+        PATH@[42; 47)
+          PATH_SEGMENT@[42; 47)
+            COLONCOLON@[42; 44)
+            NAME_REF@[44; 47)
+              IDENT@[44; 47) "foo"
+        WHITESPACE@[47; 48)
+        ALIAS@[48; 52)
+          AS_KW@[48; 50)
+          WHITESPACE@[50; 51)
+          NAME@[51; 52)
+            IDENT@[51; 52) "x"
+      R_CURLY@[52; 53)
+    SEMI@[53; 54)
+  WHITESPACE@[54; 55)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0016_struct_flavors.rs b/crates/libsyntax2/tests/data/parser/ok/0016_struct_flavors.rs
new file mode 100644
index 000000000..69638350c
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0016_struct_flavors.rs
@@ -0,0 +1,10 @@
+struct A;
+struct B {}
+struct C();
+
+struct D {
+    a: u32,
+    pub b: u32
+}
+
+struct E(pub x, y,);
diff --git a/crates/libsyntax2/tests/data/parser/ok/0016_struct_flavors.txt b/crates/libsyntax2/tests/data/parser/ok/0016_struct_flavors.txt
new file mode 100644
index 000000000..5dd480d1b
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0016_struct_flavors.txt
@@ -0,0 +1,89 @@
+FILE@[0; 97)
+  STRUCT_ITEM@[0; 9)
+    STRUCT_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    NAME@[7; 8)
+      IDENT@[7; 8) "A"
+    SEMI@[8; 9)
+  WHITESPACE@[9; 10)
+  STRUCT_ITEM@[10; 21)
+    STRUCT_KW@[10; 16)
+    WHITESPACE@[16; 17)
+    NAME@[17; 18)
+      IDENT@[17; 18) "B"
+    WHITESPACE@[18; 19)
+    L_CURLY@[19; 20)
+    R_CURLY@[20; 21)
+  WHITESPACE@[21; 22)
+  STRUCT_ITEM@[22; 33)
+    STRUCT_KW@[22; 28)
+    WHITESPACE@[28; 29)
+    NAME@[29; 30)
+      IDENT@[29; 30) "C"
+    L_PAREN@[30; 31)
+    R_PAREN@[31; 32)
+    SEMI@[32; 33)
+  WHITESPACE@[33; 35)
+  STRUCT_ITEM@[35; 74)
+    STRUCT_KW@[35; 41)
+    WHITESPACE@[41; 42)
+    NAME@[42; 43)
+      IDENT@[42; 43) "D"
+    WHITESPACE@[43; 44)
+    L_CURLY@[44; 45)
+    WHITESPACE@[45; 50)
+    NAMED_FIELD@[50; 56)
+      NAME@[50; 51)
+        IDENT@[50; 51) "a"
+      COLON@[51; 52)
+      WHITESPACE@[52; 53)
+      PATH_TYPE@[53; 56)
+        PATH@[53; 56)
+          PATH_SEGMENT@[53; 56)
+            NAME_REF@[53; 56)
+              IDENT@[53; 56) "u32"
+    COMMA@[56; 57)
+    WHITESPACE@[57; 62)
+    NAMED_FIELD@[62; 72)
+      VISIBILITY@[62; 65)
+        PUB_KW@[62; 65)
+      WHITESPACE@[65; 66)
+      NAME@[66; 67)
+        IDENT@[66; 67) "b"
+      COLON@[67; 68)
+      WHITESPACE@[68; 69)
+      PATH_TYPE@[69; 72)
+        PATH@[69; 72)
+          PATH_SEGMENT@[69; 72)
+            NAME_REF@[69; 72)
+              IDENT@[69; 72) "u32"
+    WHITESPACE@[72; 73)
+    R_CURLY@[73; 74)
+  WHITESPACE@[74; 76)
+  STRUCT_ITEM@[76; 96)
+    STRUCT_KW@[76; 82)
+    WHITESPACE@[82; 83)
+    NAME@[83; 84)
+      IDENT@[83; 84) "E"
+    L_PAREN@[84; 85)
+    POS_FIELD@[85; 90)
+      VISIBILITY@[85; 88)
+        PUB_KW@[85; 88)
+      WHITESPACE@[88; 89)
+      PATH_TYPE@[89; 90)
+        PATH@[89; 90)
+          PATH_SEGMENT@[89; 90)
+            NAME_REF@[89; 90)
+              IDENT@[89; 90) "x"
+    COMMA@[90; 91)
+    WHITESPACE@[91; 92)
+    POS_FIELD@[92; 93)
+      PATH_TYPE@[92; 93)
+        PATH@[92; 93)
+          PATH_SEGMENT@[92; 93)
+            NAME_REF@[92; 93)
+              IDENT@[92; 93) "y"
+    COMMA@[93; 94)
+    R_PAREN@[94; 95)
+    SEMI@[95; 96)
+  WHITESPACE@[96; 97)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0017_attr_trailing_comma.rs b/crates/libsyntax2/tests/data/parser/ok/0017_attr_trailing_comma.rs
new file mode 100644
index 000000000..fe0a7bb97
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0017_attr_trailing_comma.rs
@@ -0,0 +1,2 @@
+#[foo(a,)]
+fn foo() {}
diff --git a/crates/libsyntax2/tests/data/parser/ok/0017_attr_trailing_comma.txt b/crates/libsyntax2/tests/data/parser/ok/0017_attr_trailing_comma.txt
new file mode 100644
index 000000000..69724cdc8
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0017_attr_trailing_comma.txt
@@ -0,0 +1,26 @@
+FILE@[0; 23)
+  FUNCTION@[0; 22)
+    ATTR@[0; 10)
+      POUND@[0; 1)
+      L_BRACK@[1; 2)
+      META_ITEM@[2; 9)
+        IDENT@[2; 5) "foo"
+        L_PAREN@[5; 6)
+        META_ITEM@[6; 7)
+          IDENT@[6; 7) "a"
+        COMMA@[7; 8)
+        R_PAREN@[8; 9)
+      R_BRACK@[9; 10)
+    WHITESPACE@[10; 11)
+    FN_KW@[11; 13)
+    WHITESPACE@[13; 14)
+    NAME@[14; 17)
+      IDENT@[14; 17) "foo"
+    PARAM_LIST@[17; 19)
+      L_PAREN@[17; 18)
+      R_PAREN@[18; 19)
+    WHITESPACE@[19; 20)
+    BLOCK_EXPR@[20; 22)
+      L_CURLY@[20; 21)
+      R_CURLY@[21; 22)
+  WHITESPACE@[22; 23)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0018_struct_type_params.rs b/crates/libsyntax2/tests/data/parser/ok/0018_struct_type_params.rs
new file mode 100644
index 000000000..88c544923
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0018_struct_type_params.rs
@@ -0,0 +1,17 @@
+struct S1<T>;
+struct S2<T>(u32);
+struct S3<T> { u: u32 }
+
+struct S4<>;
+struct S5<'a>;
+struct S6<'a:>;
+struct S7<'a: 'b>;
+struct S8<'a: 'b + >;
+struct S9<'a: 'b + 'c>;
+struct S10<'a,>;
+struct S11<'a, 'b>;
+struct S12<'a: 'b+, 'b: 'c,>;
+
+struct S13<T>;
+struct S14<T, U>;
+struct S15<'a, T, U>;
diff --git a/crates/libsyntax2/tests/data/parser/ok/0018_struct_type_params.txt b/crates/libsyntax2/tests/data/parser/ok/0018_struct_type_params.txt
new file mode 100644
index 000000000..6457c2639
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0018_struct_type_params.txt
@@ -0,0 +1,255 @@
+FILE@[0; 290)
+  STRUCT_ITEM@[0; 13)
+    STRUCT_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    NAME@[7; 9)
+      IDENT@[7; 9) "S1"
+    TYPE_PARAM_LIST@[9; 12)
+      L_ANGLE@[9; 10)
+      TYPE_PARAM@[10; 11)
+        NAME@[10; 11)
+          IDENT@[10; 11) "T"
+      R_ANGLE@[11; 12)
+    SEMI@[12; 13)
+  WHITESPACE@[13; 14)
+  STRUCT_ITEM@[14; 32)
+    STRUCT_KW@[14; 20)
+    WHITESPACE@[20; 21)
+    NAME@[21; 23)
+      IDENT@[21; 23) "S2"
+    TYPE_PARAM_LIST@[23; 26)
+      L_ANGLE@[23; 24)
+      TYPE_PARAM@[24; 25)
+        NAME@[24; 25)
+          IDENT@[24; 25) "T"
+      R_ANGLE@[25; 26)
+    L_PAREN@[26; 27)
+    POS_FIELD@[27; 30)
+      PATH_TYPE@[27; 30)
+        PATH@[27; 30)
+          PATH_SEGMENT@[27; 30)
+            NAME_REF@[27; 30)
+              IDENT@[27; 30) "u32"
+    R_PAREN@[30; 31)
+    SEMI@[31; 32)
+  WHITESPACE@[32; 33)
+  STRUCT_ITEM@[33; 56)
+    STRUCT_KW@[33; 39)
+    WHITESPACE@[39; 40)
+    NAME@[40; 42)
+      IDENT@[40; 42) "S3"
+    TYPE_PARAM_LIST@[42; 45)
+      L_ANGLE@[42; 43)
+      TYPE_PARAM@[43; 44)
+        NAME@[43; 44)
+          IDENT@[43; 44) "T"
+      R_ANGLE@[44; 45)
+    WHITESPACE@[45; 46)
+    L_CURLY@[46; 47)
+    WHITESPACE@[47; 48)
+    NAMED_FIELD@[48; 54)
+      NAME@[48; 49)
+        IDENT@[48; 49) "u"
+      COLON@[49; 50)
+      WHITESPACE@[50; 51)
+      PATH_TYPE@[51; 54)
+        PATH@[51; 54)
+          PATH_SEGMENT@[51; 54)
+            NAME_REF@[51; 54)
+              IDENT@[51; 54) "u32"
+    WHITESPACE@[54; 55)
+    R_CURLY@[55; 56)
+  WHITESPACE@[56; 58)
+  STRUCT_ITEM@[58; 70)
+    STRUCT_KW@[58; 64)
+    WHITESPACE@[64; 65)
+    NAME@[65; 67)
+      IDENT@[65; 67) "S4"
+    TYPE_PARAM_LIST@[67; 69)
+      L_ANGLE@[67; 68)
+      R_ANGLE@[68; 69)
+    SEMI@[69; 70)
+  WHITESPACE@[70; 71)
+  STRUCT_ITEM@[71; 85)
+    STRUCT_KW@[71; 77)
+    WHITESPACE@[77; 78)
+    NAME@[78; 80)
+      IDENT@[78; 80) "S5"
+    TYPE_PARAM_LIST@[80; 84)
+      L_ANGLE@[80; 81)
+      LIFETIME_PARAM@[81; 83)
+        LIFETIME@[81; 83) "'a"
+      R_ANGLE@[83; 84)
+    SEMI@[84; 85)
+  WHITESPACE@[85; 86)
+  STRUCT_ITEM@[86; 101)
+    STRUCT_KW@[86; 92)
+    WHITESPACE@[92; 93)
+    NAME@[93; 95)
+      IDENT@[93; 95) "S6"
+    TYPE_PARAM_LIST@[95; 100)
+      L_ANGLE@[95; 96)
+      LIFETIME_PARAM@[96; 99)
+        LIFETIME@[96; 98) "'a"
+        COLON@[98; 99)
+      R_ANGLE@[99; 100)
+    SEMI@[100; 101)
+  WHITESPACE@[101; 102)
+  STRUCT_ITEM@[102; 120)
+    STRUCT_KW@[102; 108)
+    WHITESPACE@[108; 109)
+    NAME@[109; 111)
+      IDENT@[109; 111) "S7"
+    TYPE_PARAM_LIST@[111; 119)
+      L_ANGLE@[111; 112)
+      LIFETIME_PARAM@[112; 118)
+        LIFETIME@[112; 114) "'a"
+        COLON@[114; 115)
+        WHITESPACE@[115; 116)
+        LIFETIME@[116; 118) "'b"
+      R_ANGLE@[118; 119)
+    SEMI@[119; 120)
+  WHITESPACE@[120; 121)
+  STRUCT_ITEM@[121; 142)
+    STRUCT_KW@[121; 127)
+    WHITESPACE@[127; 128)
+    NAME@[128; 130)
+      IDENT@[128; 130) "S8"
+    TYPE_PARAM_LIST@[130; 141)
+      L_ANGLE@[130; 131)
+      LIFETIME_PARAM@[131; 139)
+        LIFETIME@[131; 133) "'a"
+        COLON@[133; 134)
+        WHITESPACE@[134; 135)
+        LIFETIME@[135; 137) "'b"
+        WHITESPACE@[137; 138)
+        PLUS@[138; 139)
+      WHITESPACE@[139; 140)
+      R_ANGLE@[140; 141)
+    SEMI@[141; 142)
+  WHITESPACE@[142; 143)
+  STRUCT_ITEM@[143; 166)
+    STRUCT_KW@[143; 149)
+    WHITESPACE@[149; 150)
+    NAME@[150; 152)
+      IDENT@[150; 152) "S9"
+    TYPE_PARAM_LIST@[152; 165)
+      L_ANGLE@[152; 153)
+      LIFETIME_PARAM@[153; 164)
+        LIFETIME@[153; 155) "'a"
+        COLON@[155; 156)
+        WHITESPACE@[156; 157)
+        LIFETIME@[157; 159) "'b"
+        WHITESPACE@[159; 160)
+        PLUS@[160; 161)
+        WHITESPACE@[161; 162)
+        LIFETIME@[162; 164) "'c"
+      R_ANGLE@[164; 165)
+    SEMI@[165; 166)
+  WHITESPACE@[166; 167)
+  STRUCT_ITEM@[167; 183)
+    STRUCT_KW@[167; 173)
+    WHITESPACE@[173; 174)
+    NAME@[174; 177)
+      IDENT@[174; 177) "S10"
+    TYPE_PARAM_LIST@[177; 182)
+      L_ANGLE@[177; 178)
+      LIFETIME_PARAM@[178; 180)
+        LIFETIME@[178; 180) "'a"
+      COMMA@[180; 181)
+      R_ANGLE@[181; 182)
+    SEMI@[182; 183)
+  WHITESPACE@[183; 184)
+  STRUCT_ITEM@[184; 203)
+    STRUCT_KW@[184; 190)
+    WHITESPACE@[190; 191)
+    NAME@[191; 194)
+      IDENT@[191; 194) "S11"
+    TYPE_PARAM_LIST@[194; 202)
+      L_ANGLE@[194; 195)
+      LIFETIME_PARAM@[195; 197)
+        LIFETIME@[195; 197) "'a"
+      COMMA@[197; 198)
+      WHITESPACE@[198; 199)
+      LIFETIME_PARAM@[199; 201)
+        LIFETIME@[199; 201) "'b"
+      R_ANGLE@[201; 202)
+    SEMI@[202; 203)
+  WHITESPACE@[203; 204)
+  STRUCT_ITEM@[204; 233)
+    STRUCT_KW@[204; 210)
+    WHITESPACE@[210; 211)
+    NAME@[211; 214)
+      IDENT@[211; 214) "S12"
+    TYPE_PARAM_LIST@[214; 232)
+      L_ANGLE@[214; 215)
+      LIFETIME_PARAM@[215; 222)
+        LIFETIME@[215; 217) "'a"
+        COLON@[217; 218)
+        WHITESPACE@[218; 219)
+        LIFETIME@[219; 221) "'b"
+        PLUS@[221; 222)
+      COMMA@[222; 223)
+      WHITESPACE@[223; 224)
+      LIFETIME_PARAM@[224; 230)
+        LIFETIME@[224; 226) "'b"
+        COLON@[226; 227)
+        WHITESPACE@[227; 228)
+        LIFETIME@[228; 230) "'c"
+      COMMA@[230; 231)
+      R_ANGLE@[231; 232)
+    SEMI@[232; 233)
+  WHITESPACE@[233; 235)
+  STRUCT_ITEM@[235; 249)
+    STRUCT_KW@[235; 241)
+    WHITESPACE@[241; 242)
+    NAME@[242; 245)
+      IDENT@[242; 245) "S13"
+    TYPE_PARAM_LIST@[245; 248)
+      L_ANGLE@[245; 246)
+      TYPE_PARAM@[246; 247)
+        NAME@[246; 247)
+          IDENT@[246; 247) "T"
+      R_ANGLE@[247; 248)
+    SEMI@[248; 249)
+  WHITESPACE@[249; 250)
+  STRUCT_ITEM@[250; 267)
+    STRUCT_KW@[250; 256)
+    WHITESPACE@[256; 257)
+    NAME@[257; 260)
+      IDENT@[257; 260) "S14"
+    TYPE_PARAM_LIST@[260; 266)
+      L_ANGLE@[260; 261)
+      TYPE_PARAM@[261; 262)
+        NAME@[261; 262)
+          IDENT@[261; 262) "T"
+      COMMA@[262; 263)
+      WHITESPACE@[263; 264)
+      TYPE_PARAM@[264; 265)
+        NAME@[264; 265)
+          IDENT@[264; 265) "U"
+      R_ANGLE@[265; 266)
+    SEMI@[266; 267)
+  WHITESPACE@[267; 268)
+  STRUCT_ITEM@[268; 289)
+    STRUCT_KW@[268; 274)
+    WHITESPACE@[274; 275)
+    NAME@[275; 278)
+      IDENT@[275; 278) "S15"
+    TYPE_PARAM_LIST@[278; 288)
+      L_ANGLE@[278; 279)
+      LIFETIME_PARAM@[279; 281)
+        LIFETIME@[279; 281) "'a"
+      COMMA@[281; 282)
+      WHITESPACE@[282; 283)
+      TYPE_PARAM@[283; 284)
+        NAME@[283; 284)
+          IDENT@[283; 284) "T"
+      COMMA@[284; 285)
+      WHITESPACE@[285; 286)
+      TYPE_PARAM@[286; 287)
+        NAME@[286; 287)
+          IDENT@[286; 287) "U"
+      R_ANGLE@[287; 288)
+    SEMI@[288; 289)
+  WHITESPACE@[289; 290)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0019_enums.rs b/crates/libsyntax2/tests/data/parser/ok/0019_enums.rs
new file mode 100644
index 000000000..7a1afa0e6
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0019_enums.rs
@@ -0,0 +1,25 @@
+enum E1 {
+}
+
+enum E2<T> {
+}
+
+enum E3 {
+    X
+}
+
+enum E4 {
+    X,
+}
+
+enum E5 {
+    A,
+    B = 92,
+    C {
+        a: u32,
+        pub b: f64,
+    },
+    F {},
+    D(u32,),
+    E(),
+}
diff --git a/crates/libsyntax2/tests/data/parser/ok/0019_enums.txt b/crates/libsyntax2/tests/data/parser/ok/0019_enums.txt
new file mode 100644
index 000000000..8650381cd
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0019_enums.txt
@@ -0,0 +1,146 @@
+FILE@[0; 182)
+  ENUM_ITEM@[0; 11)
+    ENUM_KW@[0; 4)
+    WHITESPACE@[4; 5)
+    NAME@[5; 7)
+      IDENT@[5; 7) "E1"
+    WHITESPACE@[7; 8)
+    L_CURLY@[8; 9)
+    WHITESPACE@[9; 10)
+    R_CURLY@[10; 11)
+  WHITESPACE@[11; 13)
+  ENUM_ITEM@[13; 27)
+    ENUM_KW@[13; 17)
+    WHITESPACE@[17; 18)
+    NAME@[18; 20)
+      IDENT@[18; 20) "E2"
+    TYPE_PARAM_LIST@[20; 23)
+      L_ANGLE@[20; 21)
+      TYPE_PARAM@[21; 22)
+        NAME@[21; 22)
+          IDENT@[21; 22) "T"
+      R_ANGLE@[22; 23)
+    WHITESPACE@[23; 24)
+    L_CURLY@[24; 25)
+    WHITESPACE@[25; 26)
+    R_CURLY@[26; 27)
+  WHITESPACE@[27; 29)
+  ENUM_ITEM@[29; 46)
+    ENUM_KW@[29; 33)
+    WHITESPACE@[33; 34)
+    NAME@[34; 36)
+      IDENT@[34; 36) "E3"
+    WHITESPACE@[36; 37)
+    L_CURLY@[37; 38)
+    WHITESPACE@[38; 43)
+    ENUM_VARIANT@[43; 44)
+      NAME@[43; 44)
+        IDENT@[43; 44) "X"
+    WHITESPACE@[44; 45)
+    R_CURLY@[45; 46)
+  WHITESPACE@[46; 48)
+  ENUM_ITEM@[48; 66)
+    ENUM_KW@[48; 52)
+    WHITESPACE@[52; 53)
+    NAME@[53; 55)
+      IDENT@[53; 55) "E4"
+    WHITESPACE@[55; 56)
+    L_CURLY@[56; 57)
+    WHITESPACE@[57; 62)
+    ENUM_VARIANT@[62; 63)
+      NAME@[62; 63)
+        IDENT@[62; 63) "X"
+    COMMA@[63; 64)
+    WHITESPACE@[64; 65)
+    R_CURLY@[65; 66)
+  WHITESPACE@[66; 68)
+  ENUM_ITEM@[68; 181)
+    ENUM_KW@[68; 72)
+    WHITESPACE@[72; 73)
+    NAME@[73; 75)
+      IDENT@[73; 75) "E5"
+    WHITESPACE@[75; 76)
+    L_CURLY@[76; 77)
+    WHITESPACE@[77; 82)
+    ENUM_VARIANT@[82; 83)
+      NAME@[82; 83)
+        IDENT@[82; 83) "A"
+    COMMA@[83; 84)
+    WHITESPACE@[84; 89)
+    ENUM_VARIANT@[89; 95)
+      NAME@[89; 90)
+        IDENT@[89; 90) "B"
+      WHITESPACE@[90; 91)
+      EQ@[91; 92)
+      WHITESPACE@[92; 93)
+      LITERAL@[93; 95)
+        INT_NUMBER@[93; 95) "92"
+    COMMA@[95; 96)
+    WHITESPACE@[96; 101)
+    ENUM_VARIANT@[101; 146)
+      NAME@[101; 102)
+        IDENT@[101; 102) "C"
+      WHITESPACE@[102; 103)
+      L_CURLY@[103; 104)
+      WHITESPACE@[104; 113)
+      NAMED_FIELD@[113; 119)
+        NAME@[113; 114)
+          IDENT@[113; 114) "a"
+        COLON@[114; 115)
+        WHITESPACE@[115; 116)
+        PATH_TYPE@[116; 119)
+          PATH@[116; 119)
+            PATH_SEGMENT@[116; 119)
+              NAME_REF@[116; 119)
+                IDENT@[116; 119) "u32"
+      COMMA@[119; 120)
+      WHITESPACE@[120; 129)
+      NAMED_FIELD@[129; 139)
+        VISIBILITY@[129; 132)
+          PUB_KW@[129; 132)
+        WHITESPACE@[132; 133)
+        NAME@[133; 134)
+          IDENT@[133; 134) "b"
+        COLON@[134; 135)
+        WHITESPACE@[135; 136)
+        PATH_TYPE@[136; 139)
+          PATH@[136; 139)
+            PATH_SEGMENT@[136; 139)
+              NAME_REF@[136; 139)
+                IDENT@[136; 139) "f64"
+      COMMA@[139; 140)
+      WHITESPACE@[140; 145)
+      R_CURLY@[145; 146)
+    COMMA@[146; 147)
+    WHITESPACE@[147; 152)
+    ENUM_VARIANT@[152; 156)
+      NAME@[152; 153)
+        IDENT@[152; 153) "F"
+      WHITESPACE@[153; 154)
+      L_CURLY@[154; 155)
+      R_CURLY@[155; 156)
+    COMMA@[156; 157)
+    WHITESPACE@[157; 162)
+    ENUM_VARIANT@[162; 169)
+      NAME@[162; 163)
+        IDENT@[162; 163) "D"
+      L_PAREN@[163; 164)
+      POS_FIELD@[164; 167)
+        PATH_TYPE@[164; 167)
+          PATH@[164; 167)
+            PATH_SEGMENT@[164; 167)
+              NAME_REF@[164; 167)
+                IDENT@[164; 167) "u32"
+      COMMA@[167; 168)
+      R_PAREN@[168; 169)
+    COMMA@[169; 170)
+    WHITESPACE@[170; 175)
+    ENUM_VARIANT@[175; 178)
+      NAME@[175; 176)
+        IDENT@[175; 176) "E"
+      L_PAREN@[176; 177)
+      R_PAREN@[177; 178)
+    COMMA@[178; 179)
+    WHITESPACE@[179; 180)
+    R_CURLY@[180; 181)
+  WHITESPACE@[181; 182)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0020_type_param_bounds.rs b/crates/libsyntax2/tests/data/parser/ok/0020_type_param_bounds.rs
new file mode 100644
index 000000000..a1b9f00a4
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0020_type_param_bounds.rs
@@ -0,0 +1,9 @@
+struct A<T>;
+struct B<T:>;
+struct C<T: 'a>;
+struct D<T: 'a + >;
+struct E<T: 'a + 'd >;
+struct F<T: 'a + 'd + Clone>;
+struct G<T: Clone + Copy>;
+struct H<T: ::Foo + self::Bar + 'a>;
+struct I<T:, U:,>;
diff --git a/crates/libsyntax2/tests/data/parser/ok/0020_type_param_bounds.txt b/crates/libsyntax2/tests/data/parser/ok/0020_type_param_bounds.txt
new file mode 100644
index 000000000..fe12cbb94
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0020_type_param_bounds.txt
@@ -0,0 +1,193 @@
+FILE@[0; 200)
+  STRUCT_ITEM@[0; 12)
+    STRUCT_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    NAME@[7; 8)
+      IDENT@[7; 8) "A"
+    TYPE_PARAM_LIST@[8; 11)
+      L_ANGLE@[8; 9)
+      TYPE_PARAM@[9; 10)
+        NAME@[9; 10)
+          IDENT@[9; 10) "T"
+      R_ANGLE@[10; 11)
+    SEMI@[11; 12)
+  WHITESPACE@[12; 13)
+  STRUCT_ITEM@[13; 26)
+    STRUCT_KW@[13; 19)
+    WHITESPACE@[19; 20)
+    NAME@[20; 21)
+      IDENT@[20; 21) "B"
+    TYPE_PARAM_LIST@[21; 25)
+      L_ANGLE@[21; 22)
+      TYPE_PARAM@[22; 24)
+        NAME@[22; 23)
+          IDENT@[22; 23) "T"
+        COLON@[23; 24)
+      R_ANGLE@[24; 25)
+    SEMI@[25; 26)
+  WHITESPACE@[26; 27)
+  STRUCT_ITEM@[27; 43)
+    STRUCT_KW@[27; 33)
+    WHITESPACE@[33; 34)
+    NAME@[34; 35)
+      IDENT@[34; 35) "C"
+    TYPE_PARAM_LIST@[35; 42)
+      L_ANGLE@[35; 36)
+      TYPE_PARAM@[36; 41)
+        NAME@[36; 37)
+          IDENT@[36; 37) "T"
+        COLON@[37; 38)
+        WHITESPACE@[38; 39)
+        LIFETIME@[39; 41) "'a"
+      R_ANGLE@[41; 42)
+    SEMI@[42; 43)
+  WHITESPACE@[43; 44)
+  STRUCT_ITEM@[44; 63)
+    STRUCT_KW@[44; 50)
+    WHITESPACE@[50; 51)
+    NAME@[51; 52)
+      IDENT@[51; 52) "D"
+    TYPE_PARAM_LIST@[52; 62)
+      L_ANGLE@[52; 53)
+      TYPE_PARAM@[53; 60)
+        NAME@[53; 54)
+          IDENT@[53; 54) "T"
+        COLON@[54; 55)
+        WHITESPACE@[55; 56)
+        LIFETIME@[56; 58) "'a"
+        WHITESPACE@[58; 59)
+        PLUS@[59; 60)
+      WHITESPACE@[60; 61)
+      R_ANGLE@[61; 62)
+    SEMI@[62; 63)
+  WHITESPACE@[63; 64)
+  STRUCT_ITEM@[64; 86)
+    STRUCT_KW@[64; 70)
+    WHITESPACE@[70; 71)
+    NAME@[71; 72)
+      IDENT@[71; 72) "E"
+    TYPE_PARAM_LIST@[72; 85)
+      L_ANGLE@[72; 73)
+      TYPE_PARAM@[73; 83)
+        NAME@[73; 74)
+          IDENT@[73; 74) "T"
+        COLON@[74; 75)
+        WHITESPACE@[75; 76)
+        LIFETIME@[76; 78) "'a"
+        WHITESPACE@[78; 79)
+        PLUS@[79; 80)
+        WHITESPACE@[80; 81)
+        LIFETIME@[81; 83) "'d"
+      WHITESPACE@[83; 84)
+      R_ANGLE@[84; 85)
+    SEMI@[85; 86)
+  WHITESPACE@[86; 87)
+  STRUCT_ITEM@[87; 116)
+    STRUCT_KW@[87; 93)
+    WHITESPACE@[93; 94)
+    NAME@[94; 95)
+      IDENT@[94; 95) "F"
+    TYPE_PARAM_LIST@[95; 115)
+      L_ANGLE@[95; 96)
+      TYPE_PARAM@[96; 114)
+        NAME@[96; 97)
+          IDENT@[96; 97) "T"
+        COLON@[97; 98)
+        WHITESPACE@[98; 99)
+        LIFETIME@[99; 101) "'a"
+        WHITESPACE@[101; 102)
+        PLUS@[102; 103)
+        WHITESPACE@[103; 104)
+        LIFETIME@[104; 106) "'d"
+        WHITESPACE@[106; 107)
+        PLUS@[107; 108)
+        WHITESPACE@[108; 109)
+        PATH@[109; 114)
+          PATH_SEGMENT@[109; 114)
+            NAME_REF@[109; 114)
+              IDENT@[109; 114) "Clone"
+      R_ANGLE@[114; 115)
+    SEMI@[115; 116)
+  WHITESPACE@[116; 117)
+  STRUCT_ITEM@[117; 143)
+    STRUCT_KW@[117; 123)
+    WHITESPACE@[123; 124)
+    NAME@[124; 125)
+      IDENT@[124; 125) "G"
+    TYPE_PARAM_LIST@[125; 142)
+      L_ANGLE@[125; 126)
+      TYPE_PARAM@[126; 141)
+        NAME@[126; 127)
+          IDENT@[126; 127) "T"
+        COLON@[127; 128)
+        WHITESPACE@[128; 129)
+        PATH@[129; 134)
+          PATH_SEGMENT@[129; 134)
+            NAME_REF@[129; 134)
+              IDENT@[129; 134) "Clone"
+        WHITESPACE@[134; 135)
+        PLUS@[135; 136)
+        WHITESPACE@[136; 137)
+        PATH@[137; 141)
+          PATH_SEGMENT@[137; 141)
+            NAME_REF@[137; 141)
+              IDENT@[137; 141) "Copy"
+      R_ANGLE@[141; 142)
+    SEMI@[142; 143)
+  WHITESPACE@[143; 144)
+  STRUCT_ITEM@[144; 180)
+    STRUCT_KW@[144; 150)
+    WHITESPACE@[150; 151)
+    NAME@[151; 152)
+      IDENT@[151; 152) "H"
+    TYPE_PARAM_LIST@[152; 179)
+      L_ANGLE@[152; 153)
+      TYPE_PARAM@[153; 178)
+        NAME@[153; 154)
+          IDENT@[153; 154) "T"
+        COLON@[154; 155)
+        WHITESPACE@[155; 156)
+        PATH@[156; 161)
+          PATH_SEGMENT@[156; 161)
+            COLONCOLON@[156; 158)
+            NAME_REF@[158; 161)
+              IDENT@[158; 161) "Foo"
+        WHITESPACE@[161; 162)
+        PLUS@[162; 163)
+        WHITESPACE@[163; 164)
+        PATH@[164; 173)
+          PATH@[164; 168)
+            PATH_SEGMENT@[164; 168)
+              SELF_KW@[164; 168)
+          COLONCOLON@[168; 170)
+          PATH_SEGMENT@[170; 173)
+            NAME_REF@[170; 173)
+              IDENT@[170; 173) "Bar"
+        WHITESPACE@[173; 174)
+        PLUS@[174; 175)
+        WHITESPACE@[175; 176)
+        LIFETIME@[176; 178) "'a"
+      R_ANGLE@[178; 179)
+    SEMI@[179; 180)
+  WHITESPACE@[180; 181)
+  STRUCT_ITEM@[181; 199)
+    STRUCT_KW@[181; 187)
+    WHITESPACE@[187; 188)
+    NAME@[188; 189)
+      IDENT@[188; 189) "I"
+    TYPE_PARAM_LIST@[189; 198)
+      L_ANGLE@[189; 190)
+      TYPE_PARAM@[190; 192)
+        NAME@[190; 191)
+          IDENT@[190; 191) "T"
+        COLON@[191; 192)
+      COMMA@[192; 193)
+      WHITESPACE@[193; 194)
+      TYPE_PARAM@[194; 196)
+        NAME@[194; 195)
+          IDENT@[194; 195) "U"
+        COLON@[195; 196)
+      COMMA@[196; 197)
+      R_ANGLE@[197; 198)
+    SEMI@[198; 199)
+  WHITESPACE@[199; 200)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0021_extern_fn.rs b/crates/libsyntax2/tests/data/parser/ok/0021_extern_fn.rs
new file mode 100644
index 000000000..e929eef74
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0021_extern_fn.rs
@@ -0,0 +1,8 @@
+extern fn foo() {
+}
+
+extern "C" fn bar() {
+}
+
+extern r"D" fn baz() {
+}
diff --git a/crates/libsyntax2/tests/data/parser/ok/0021_extern_fn.txt b/crates/libsyntax2/tests/data/parser/ok/0021_extern_fn.txt
new file mode 100644
index 000000000..07d5cc157
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0021_extern_fn.txt
@@ -0,0 +1,56 @@
+FILE@[0; 71)
+  FUNCTION@[0; 19)
+    ABI@[0; 6)
+      EXTERN_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    FN_KW@[7; 9)
+    WHITESPACE@[9; 10)
+    NAME@[10; 13)
+      IDENT@[10; 13) "foo"
+    PARAM_LIST@[13; 15)
+      L_PAREN@[13; 14)
+      R_PAREN@[14; 15)
+    WHITESPACE@[15; 16)
+    BLOCK_EXPR@[16; 19)
+      L_CURLY@[16; 17)
+      WHITESPACE@[17; 18)
+      R_CURLY@[18; 19)
+  WHITESPACE@[19; 21)
+  FUNCTION@[21; 44)
+    ABI@[21; 31)
+      EXTERN_KW@[21; 27)
+      WHITESPACE@[27; 28)
+      STRING@[28; 31)
+    WHITESPACE@[31; 32)
+    FN_KW@[32; 34)
+    WHITESPACE@[34; 35)
+    NAME@[35; 38)
+      IDENT@[35; 38) "bar"
+    PARAM_LIST@[38; 40)
+      L_PAREN@[38; 39)
+      R_PAREN@[39; 40)
+    WHITESPACE@[40; 41)
+    BLOCK_EXPR@[41; 44)
+      L_CURLY@[41; 42)
+      WHITESPACE@[42; 43)
+      R_CURLY@[43; 44)
+  WHITESPACE@[44; 46)
+  FUNCTION@[46; 70)
+    ABI@[46; 57)
+      EXTERN_KW@[46; 52)
+      WHITESPACE@[52; 53)
+      RAW_STRING@[53; 57)
+    WHITESPACE@[57; 58)
+    FN_KW@[58; 60)
+    WHITESPACE@[60; 61)
+    NAME@[61; 64)
+      IDENT@[61; 64) "baz"
+    PARAM_LIST@[64; 66)
+      L_PAREN@[64; 65)
+      R_PAREN@[65; 66)
+    WHITESPACE@[66; 67)
+    BLOCK_EXPR@[67; 70)
+      L_CURLY@[67; 68)
+      WHITESPACE@[68; 69)
+      R_CURLY@[69; 70)
+  WHITESPACE@[70; 71)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0022_empty_extern_block.rs b/crates/libsyntax2/tests/data/parser/ok/0022_empty_extern_block.rs
new file mode 100644
index 000000000..f5fe0e6ef
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0022_empty_extern_block.rs
@@ -0,0 +1,5 @@
+extern {
+}
+
+extern "C" {
+}
diff --git a/crates/libsyntax2/tests/data/parser/ok/0022_empty_extern_block.txt b/crates/libsyntax2/tests/data/parser/ok/0022_empty_extern_block.txt
new file mode 100644
index 000000000..81b92d394
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0022_empty_extern_block.txt
@@ -0,0 +1,19 @@
+FILE@[0; 27)
+  EXTERN_BLOCK_EXPR@[0; 10)
+    ABI@[0; 6)
+      EXTERN_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    L_CURLY@[7; 8)
+    WHITESPACE@[8; 9)
+    R_CURLY@[9; 10)
+  WHITESPACE@[10; 12)
+  EXTERN_BLOCK_EXPR@[12; 26)
+    ABI@[12; 22)
+      EXTERN_KW@[12; 18)
+      WHITESPACE@[18; 19)
+      STRING@[19; 22)
+    WHITESPACE@[22; 23)
+    L_CURLY@[23; 24)
+    WHITESPACE@[24; 25)
+    R_CURLY@[25; 26)
+  WHITESPACE@[26; 27)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0023_static_items.rs b/crates/libsyntax2/tests/data/parser/ok/0023_static_items.rs
new file mode 100644
index 000000000..5fb92ce33
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0023_static_items.rs
@@ -0,0 +1,2 @@
+static FOO: u32 = 1;
+static mut BAR: i32 = 92;
diff --git a/crates/libsyntax2/tests/data/parser/ok/0023_static_items.txt b/crates/libsyntax2/tests/data/parser/ok/0023_static_items.txt
new file mode 100644
index 000000000..b8dfdd251
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0023_static_items.txt
@@ -0,0 +1,41 @@
+FILE@[0; 47)
+  STATIC_ITEM@[0; 20)
+    STATIC_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    NAME@[7; 10)
+      IDENT@[7; 10) "FOO"
+    COLON@[10; 11)
+    WHITESPACE@[11; 12)
+    PATH_TYPE@[12; 15)
+      PATH@[12; 15)
+        PATH_SEGMENT@[12; 15)
+          NAME_REF@[12; 15)
+            IDENT@[12; 15) "u32"
+    WHITESPACE@[15; 16)
+    EQ@[16; 17)
+    WHITESPACE@[17; 18)
+    LITERAL@[18; 19)
+      INT_NUMBER@[18; 19) "1"
+    SEMI@[19; 20)
+  WHITESPACE@[20; 21)
+  STATIC_ITEM@[21; 46)
+    STATIC_KW@[21; 27)
+    WHITESPACE@[27; 28)
+    MUT_KW@[28; 31)
+    WHITESPACE@[31; 32)
+    NAME@[32; 35)
+      IDENT@[32; 35) "BAR"
+    COLON@[35; 36)
+    WHITESPACE@[36; 37)
+    PATH_TYPE@[37; 40)
+      PATH@[37; 40)
+        PATH_SEGMENT@[37; 40)
+          NAME_REF@[37; 40)
+            IDENT@[37; 40) "i32"
+    WHITESPACE@[40; 41)
+    EQ@[41; 42)
+    WHITESPACE@[42; 43)
+    LITERAL@[43; 45)
+      INT_NUMBER@[43; 45) "92"
+    SEMI@[45; 46)
+  WHITESPACE@[46; 47)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0024_const_item.rs b/crates/libsyntax2/tests/data/parser/ok/0024_const_item.rs
new file mode 100644
index 000000000..7446859b5
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0024_const_item.rs
@@ -0,0 +1,2 @@
+const FOO: u32 = 92;
+const mut BAR: u32 = 62;
diff --git a/crates/libsyntax2/tests/data/parser/ok/0024_const_item.txt b/crates/libsyntax2/tests/data/parser/ok/0024_const_item.txt
new file mode 100644
index 000000000..85083e9c1
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0024_const_item.txt
@@ -0,0 +1,41 @@
+FILE@[0; 46)
+  CONST_ITEM@[0; 20)
+    CONST_KW@[0; 5)
+    WHITESPACE@[5; 6)
+    NAME@[6; 9)
+      IDENT@[6; 9) "FOO"
+    COLON@[9; 10)
+    WHITESPACE@[10; 11)
+    PATH_TYPE@[11; 14)
+      PATH@[11; 14)
+        PATH_SEGMENT@[11; 14)
+          NAME_REF@[11; 14)
+            IDENT@[11; 14) "u32"
+    WHITESPACE@[14; 15)
+    EQ@[15; 16)
+    WHITESPACE@[16; 17)
+    LITERAL@[17; 19)
+      INT_NUMBER@[17; 19) "92"
+    SEMI@[19; 20)
+  WHITESPACE@[20; 21)
+  CONST_ITEM@[21; 45)
+    CONST_KW@[21; 26)
+    WHITESPACE@[26; 27)
+    MUT_KW@[27; 30)
+    WHITESPACE@[30; 31)
+    NAME@[31; 34)
+      IDENT@[31; 34) "BAR"
+    COLON@[34; 35)
+    WHITESPACE@[35; 36)
+    PATH_TYPE@[36; 39)
+      PATH@[36; 39)
+        PATH_SEGMENT@[36; 39)
+          NAME_REF@[36; 39)
+            IDENT@[36; 39) "u32"
+    WHITESPACE@[39; 40)
+    EQ@[40; 41)
+    WHITESPACE@[41; 42)
+    LITERAL@[42; 44)
+      INT_NUMBER@[42; 44) "62"
+    SEMI@[44; 45)
+  WHITESPACE@[45; 46)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0025_extern_fn_in_block.rs b/crates/libsyntax2/tests/data/parser/ok/0025_extern_fn_in_block.rs
new file mode 100644
index 000000000..289809809
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0025_extern_fn_in_block.rs
@@ -0,0 +1,3 @@
+fn main() {
+    extern fn f() {}
+}
diff --git a/crates/libsyntax2/tests/data/parser/ok/0025_extern_fn_in_block.txt b/crates/libsyntax2/tests/data/parser/ok/0025_extern_fn_in_block.txt
new file mode 100644
index 000000000..46fb177b2
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0025_extern_fn_in_block.txt
@@ -0,0 +1,31 @@
+FILE@[0; 35)
+  FUNCTION@[0; 34)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8)
+      R_PAREN@[8; 9)
+    WHITESPACE@[9; 10)
+    BLOCK_EXPR@[10; 34)
+      L_CURLY@[10; 11)
+      WHITESPACE@[11; 16)
+      FUNCTION@[16; 32)
+        ABI@[16; 22)
+          EXTERN_KW@[16; 22)
+        WHITESPACE@[22; 23)
+        FN_KW@[23; 25)
+        WHITESPACE@[25; 26)
+        NAME@[26; 27)
+          IDENT@[26; 27) "f"
+        PARAM_LIST@[27; 29)
+          L_PAREN@[27; 28)
+          R_PAREN@[28; 29)
+        WHITESPACE@[29; 30)
+        BLOCK_EXPR@[30; 32)
+          L_CURLY@[30; 31)
+          R_CURLY@[31; 32)
+      WHITESPACE@[32; 33)
+      R_CURLY@[33; 34)
+  WHITESPACE@[34; 35)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0026_const_fn_in_block.rs b/crates/libsyntax2/tests/data/parser/ok/0026_const_fn_in_block.rs
new file mode 100644
index 000000000..7641a3d28
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0026_const_fn_in_block.rs
@@ -0,0 +1,3 @@
+fn main() {
+    const fn f() {}
+}
diff --git a/crates/libsyntax2/tests/data/parser/ok/0026_const_fn_in_block.txt b/crates/libsyntax2/tests/data/parser/ok/0026_const_fn_in_block.txt
new file mode 100644
index 000000000..a450762a8
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0026_const_fn_in_block.txt
@@ -0,0 +1,30 @@
+FILE@[0; 34)
+  FUNCTION@[0; 33)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8)
+      R_PAREN@[8; 9)
+    WHITESPACE@[9; 10)
+    BLOCK_EXPR@[10; 33)
+      L_CURLY@[10; 11)
+      WHITESPACE@[11; 16)
+      FUNCTION@[16; 31)
+        CONST_KW@[16; 21)
+        WHITESPACE@[21; 22)
+        FN_KW@[22; 24)
+        WHITESPACE@[24; 25)
+        NAME@[25; 26)
+          IDENT@[25; 26) "f"
+        PARAM_LIST@[26; 28)
+          L_PAREN@[26; 27)
+          R_PAREN@[27; 28)
+        WHITESPACE@[28; 29)
+        BLOCK_EXPR@[29; 31)
+          L_CURLY@[29; 30)
+          R_CURLY@[30; 31)
+      WHITESPACE@[31; 32)
+      R_CURLY@[32; 33)
+  WHITESPACE@[33; 34)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0027_unsafe_fn_in_block.rs b/crates/libsyntax2/tests/data/parser/ok/0027_unsafe_fn_in_block.rs
new file mode 100644
index 000000000..f3c5ff938
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0027_unsafe_fn_in_block.rs
@@ -0,0 +1,4 @@
+fn main() {
+    unsafe fn f() {}
+    unsafe { 92 }
+}
diff --git a/crates/libsyntax2/tests/data/parser/ok/0027_unsafe_fn_in_block.txt b/crates/libsyntax2/tests/data/parser/ok/0027_unsafe_fn_in_block.txt
new file mode 100644
index 000000000..28cd7ad3d
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0027_unsafe_fn_in_block.txt
@@ -0,0 +1,40 @@
+FILE@[0; 53)
+  FUNCTION@[0; 52)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8)
+      R_PAREN@[8; 9)
+    WHITESPACE@[9; 10)
+    BLOCK_EXPR@[10; 52)
+      L_CURLY@[10; 11)
+      WHITESPACE@[11; 16)
+      FUNCTION@[16; 32)
+        UNSAFE_KW@[16; 22)
+        WHITESPACE@[22; 23)
+        FN_KW@[23; 25)
+        WHITESPACE@[25; 26)
+        NAME@[26; 27)
+          IDENT@[26; 27) "f"
+        PARAM_LIST@[27; 29)
+          L_PAREN@[27; 28)
+          R_PAREN@[28; 29)
+        WHITESPACE@[29; 30)
+        BLOCK_EXPR@[30; 32)
+          L_CURLY@[30; 31)
+          R_CURLY@[31; 32)
+      WHITESPACE@[32; 37)
+      BLOCK_EXPR@[37; 50)
+        UNSAFE_KW@[37; 43)
+        WHITESPACE@[43; 44)
+        L_CURLY@[44; 45)
+        WHITESPACE@[45; 46)
+        LITERAL@[46; 48)
+          INT_NUMBER@[46; 48) "92"
+        WHITESPACE@[48; 49)
+        R_CURLY@[49; 50)
+      WHITESPACE@[50; 51)
+      R_CURLY@[51; 52)
+  WHITESPACE@[52; 53)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0028_operator_binding_power.rs b/crates/libsyntax2/tests/data/parser/ok/0028_operator_binding_power.rs
new file mode 100644
index 000000000..cc9598470
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0028_operator_binding_power.rs
@@ -0,0 +1,14 @@
+fn binding_power() {
+    let x = 1 + 2 * 3 % 4 - 5 / 6;
+    1 + 2 * 3;
+    1 << 2 + 3;
+    1 & 2 >> 3;
+    1 ^ 2 & 3;
+    1 | 2 ^ 3;
+    1 == 2 | 3;
+    1 && 2 == 3;
+    //1 || 2 && 2;
+    //1 .. 2 || 3;
+    //1 = 2 .. 3;
+    //---&*1 - --2 * 9;
+}
diff --git a/crates/libsyntax2/tests/data/parser/ok/0028_operator_binding_power.txt b/crates/libsyntax2/tests/data/parser/ok/0028_operator_binding_power.txt
new file mode 100644
index 000000000..3fb1ae811
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0028_operator_binding_power.txt
@@ -0,0 +1,185 @@
+FILE@[0; 248)
+  FUNCTION@[0; 247)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 16)
+      IDENT@[3; 16) "binding_power"
+    PARAM_LIST@[16; 18)
+      L_PAREN@[16; 17)
+      R_PAREN@[17; 18)
+    WHITESPACE@[18; 19)
+    BLOCK_EXPR@[19; 247)
+      L_CURLY@[19; 20)
+      WHITESPACE@[20; 25)
+      LET_STMT@[25; 55)
+        LET_KW@[25; 28)
+        WHITESPACE@[28; 29)
+        BIND_PAT@[29; 30)
+          NAME@[29; 30)
+            IDENT@[29; 30) "x"
+        WHITESPACE@[30; 31)
+        EQ@[31; 32)
+        WHITESPACE@[32; 33)
+        BIN_EXPR@[33; 54)
+          BIN_EXPR@[33; 46)
+            LITERAL@[33; 34)
+              INT_NUMBER@[33; 34) "1"
+            WHITESPACE@[34; 35)
+            PLUS@[35; 36)
+            WHITESPACE@[36; 37)
+            BIN_EXPR@[37; 46)
+              BIN_EXPR@[37; 42)
+                LITERAL@[37; 38)
+                  INT_NUMBER@[37; 38) "2"
+                WHITESPACE@[38; 39)
+                STAR@[39; 40)
+                WHITESPACE@[40; 41)
+                LITERAL@[41; 42)
+                  INT_NUMBER@[41; 42) "3"
+              WHITESPACE@[42; 43)
+              PERCENT@[43; 44)
+              WHITESPACE@[44; 45)
+              LITERAL@[45; 46)
+                INT_NUMBER@[45; 46) "4"
+          WHITESPACE@[46; 47)
+          MINUS@[47; 48)
+          WHITESPACE@[48; 49)
+          BIN_EXPR@[49; 54)
+            LITERAL@[49; 50)
+              INT_NUMBER@[49; 50) "5"
+            WHITESPACE@[50; 51)
+            SLASH@[51; 52)
+            WHITESPACE@[52; 53)
+            LITERAL@[53; 54)
+              INT_NUMBER@[53; 54) "6"
+        SEMI@[54; 55)
+      WHITESPACE@[55; 60)
+      EXPR_STMT@[60; 70)
+        BIN_EXPR@[60; 69)
+          LITERAL@[60; 61)
+            INT_NUMBER@[60; 61) "1"
+          WHITESPACE@[61; 62)
+          PLUS@[62; 63)
+          WHITESPACE@[63; 64)
+          BIN_EXPR@[64; 69)
+            LITERAL@[64; 65)
+              INT_NUMBER@[64; 65) "2"
+            WHITESPACE@[65; 66)
+            STAR@[66; 67)
+            WHITESPACE@[67; 68)
+            LITERAL@[68; 69)
+              INT_NUMBER@[68; 69) "3"
+        SEMI@[69; 70)
+      WHITESPACE@[70; 75)
+      EXPR_STMT@[75; 86)
+        BIN_EXPR@[75; 85)
+          LITERAL@[75; 76)
+            INT_NUMBER@[75; 76) "1"
+          WHITESPACE@[76; 77)
+          SHL@[77; 79)
+          WHITESPACE@[79; 80)
+          BIN_EXPR@[80; 85)
+            LITERAL@[80; 81)
+              INT_NUMBER@[80; 81) "2"
+            WHITESPACE@[81; 82)
+            PLUS@[82; 83)
+            WHITESPACE@[83; 84)
+            LITERAL@[84; 85)
+              INT_NUMBER@[84; 85) "3"
+        SEMI@[85; 86)
+      WHITESPACE@[86; 91)
+      EXPR_STMT@[91; 102)
+        BIN_EXPR@[91; 101)
+          LITERAL@[91; 92)
+            INT_NUMBER@[91; 92) "1"
+          WHITESPACE@[92; 93)
+          AMP@[93; 94)
+          WHITESPACE@[94; 95)
+          BIN_EXPR@[95; 101)
+            LITERAL@[95; 96)
+              INT_NUMBER@[95; 96) "2"
+            WHITESPACE@[96; 97)
+            SHR@[97; 99)
+            WHITESPACE@[99; 100)
+            LITERAL@[100; 101)
+              INT_NUMBER@[100; 101) "3"
+        SEMI@[101; 102)
+      WHITESPACE@[102; 107)
+      EXPR_STMT@[107; 117)
+        BIN_EXPR@[107; 116)
+          LITERAL@[107; 108)
+            INT_NUMBER@[107; 108) "1"
+          WHITESPACE@[108; 109)
+          CARET@[109; 110)
+          WHITESPACE@[110; 111)
+          BIN_EXPR@[111; 116)
+            LITERAL@[111; 112)
+              INT_NUMBER@[111; 112) "2"
+            WHITESPACE@[112; 113)
+            AMP@[113; 114)
+            WHITESPACE@[114; 115)
+            LITERAL@[115; 116)
+              INT_NUMBER@[115; 116) "3"
+        SEMI@[116; 117)
+      WHITESPACE@[117; 122)
+      EXPR_STMT@[122; 132)
+        BIN_EXPR@[122; 131)
+          LITERAL@[122; 123)
+            INT_NUMBER@[122; 123) "1"
+          WHITESPACE@[123; 124)
+          PIPE@[124; 125)
+          WHITESPACE@[125; 126)
+          BIN_EXPR@[126; 131)
+            LITERAL@[126; 127)
+              INT_NUMBER@[126; 127) "2"
+            WHITESPACE@[127; 128)
+            CARET@[128; 129)
+            WHITESPACE@[129; 130)
+            LITERAL@[130; 131)
+              INT_NUMBER@[130; 131) "3"
+        SEMI@[131; 132)
+      WHITESPACE@[132; 137)
+      EXPR_STMT@[137; 148)
+        BIN_EXPR@[137; 147)
+          LITERAL@[137; 138)
+            INT_NUMBER@[137; 138) "1"
+          WHITESPACE@[138; 139)
+          EQEQ@[139; 141)
+          WHITESPACE@[141; 142)
+          BIN_EXPR@[142; 147)
+            LITERAL@[142; 143)
+              INT_NUMBER@[142; 143) "2"
+            WHITESPACE@[143; 144)
+            PIPE@[144; 145)
+            WHITESPACE@[145; 146)
+            LITERAL@[146; 147)
+              INT_NUMBER@[146; 147) "3"
+        SEMI@[147; 148)
+      WHITESPACE@[148; 153)
+      EXPR_STMT@[153; 165)
+        BIN_EXPR@[153; 164)
+          LITERAL@[153; 154)
+            INT_NUMBER@[153; 154) "1"
+          WHITESPACE@[154; 155)
+          AMPAMP@[155; 157)
+          WHITESPACE@[157; 158)
+          BIN_EXPR@[158; 164)
+            LITERAL@[158; 159)
+              INT_NUMBER@[158; 159) "2"
+            WHITESPACE@[159; 160)
+            EQEQ@[160; 162)
+            WHITESPACE@[162; 163)
+            LITERAL@[163; 164)
+              INT_NUMBER@[163; 164) "3"
+        SEMI@[164; 165)
+      WHITESPACE@[165; 170)
+      COMMENT@[170; 184)
+      WHITESPACE@[184; 189)
+      COMMENT@[189; 203)
+      WHITESPACE@[203; 208)
+      COMMENT@[208; 221)
+      WHITESPACE@[221; 226)
+      COMMENT@[226; 245)
+      WHITESPACE@[245; 246)
+      R_CURLY@[246; 247)
+  WHITESPACE@[247; 248)
diff --git a/crates/libsyntax2/tests/data/parser/ok/0029_range_forms.rs b/crates/libsyntax2/tests/data/parser/ok/0029_range_forms.rs
new file mode 100644
index 000000000..03f4ae7b2
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0029_range_forms.rs
@@ -0,0 +1,6 @@
+fn foo() {
+    ..1 + 1;
+    ..z = 2;
+    x = false..1 == 1;
+    let x = 1..;
+}
diff --git a/crates/libsyntax2/tests/data/parser/ok/0029_range_forms.txt b/crates/libsyntax2/tests/data/parser/ok/0029_range_forms.txt
new file mode 100644
index 000000000..91d5e5bba
--- /dev/null
+++ b/crates/libsyntax2/tests/data/parser/ok/0029_range_forms.txt
@@ -0,0 +1,83 @@
+FILE@[0; 79)
+  FUNCTION@[0; 78)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK_EXPR@[9; 78)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      EXPR_STMT@[15; 23)
+        RANGE_EXPR@[15; 22)
+          DOTDOT@[15; 17)
+          BIN_EXPR@[17; 22)
+            LITERAL@[17; 18)
+              INT_NUMBER@[17; 18) "1"
+            WHITESPACE@[18; 19)
+            PLUS@[19; 20)
+            WHITESPACE@[20; 21)
+            LITERAL@[21; 22)
+              INT_NUMBER@[21; 22) "1"
+        SEMI@[22; 23)
+      WHITESPACE@[23; 28)
+      EXPR_STMT@[28; 36)
+        BIN_EXPR@[28; 35)
+          RANGE_EXPR@[28; 31)
+            DOTDOT@[28; 30)
+            PATH_EXPR@[30; 31)
+              PATH@[30; 31)
+                PATH_SEGMENT@[30; 31)
+                  NAME_REF@[30; 31)
+                    IDENT@[30; 31) "z"
+          WHITESPACE@[31; 32)
+          EQ@[32; 33)
+          WHITESPACE@[33; 34)
+          LITERAL@[34; 35)
+            INT_NUMBER@[34; 35) "2"
+        SEMI@[35; 36)
+      WHITESPACE@[36; 41)
+      EXPR_STMT@[41; 59)
+        BIN_EXPR@[41; 58)
+          PATH_EXPR@[41; 42)
+            PATH@[41; 42)
+              PATH_SEGMENT@[41; 42)
+                NAME_REF@[41; 42)
+                  IDENT@[41; 42) "x"
+          WHITESPACE@[42; 43)
+          EQ@[43; 44)
+          WHITESPACE@[44; 45)
+          RANGE_EXPR@[45; 58)
+            LITERAL@[45; 50)
+              FALSE_KW@[45; 50)
+            DOTDOT@[50; 52)
+            BIN_EXPR@[52; 58)
+              LITERAL@[52; 53)
+                INT_NUMBER@[52; 53) "1"
+              WHITESPACE@[53; 54)
+              EQEQ@[54; 56)
+              WHITESPACE@[56; 57)
+              LITERAL@[57; 58)
+                INT_NUMBER@[57; 58) "1"
+        SEMI@[58; 59)
+      WHITESPACE@[59; 64)
+      LET_STMT@[64; 76)
+        LET_KW@[64; 67)
+        WHITESPACE@[67; 68)
+        BIND_PAT@[68; 69)
+          NAME@[68; 69)
+            IDENT@[68; 69) "x"
+        WHITESPACE@[69; 70)
+        EQ@[70; 71)
+        WHITESPACE@[71; 72)
+        RANGE_EXPR@[72; 75)
+          LITERAL@[72; 73)
+            INT_NUMBER@[72; 73) "1"
+          DOTDOT@[73; 75)
+        SEMI@[75; 76)
+      WHITESPACE@[76; 77)
+      R_CURLY@[77; 78)
+  WHITESPACE@[78; 79)
diff --git a/crates/libsyntax2/tests/lexer.rs b/crates/libsyntax2/tests/lexer.rs
new file mode 100644
index 000000000..46ac9fedd
--- /dev/null
+++ b/crates/libsyntax2/tests/lexer.rs
@@ -0,0 +1,28 @@
+extern crate libsyntax2;
+extern crate testutils;
+
+use std::fmt::Write;
+
+use libsyntax2::{tokenize, Token};
+use testutils::dir_tests;
+
+#[test]
+fn lexer_tests() {
+    dir_tests(&["lexer"], |text| {
+        let tokens = tokenize(text);
+        dump_tokens(&tokens, text)
+    })
+}
+
+fn dump_tokens(tokens: &[Token], text: &str) -> String {
+    let mut acc = String::new();
+    let mut offset = 0;
+    for token in tokens {
+        let len: u32 = token.len.into();
+        let len = len as usize;
+        let token_text = &text[offset..offset + len];
+        offset += len;
+        write!(acc, "{:?} {} {:?}\n", token.kind, token.len, token_text).unwrap()
+    }
+    acc
+}
diff --git a/crates/libsyntax2/tests/parser.rs b/crates/libsyntax2/tests/parser.rs
new file mode 100644
index 000000000..af2ae11bb
--- /dev/null
+++ b/crates/libsyntax2/tests/parser.rs
@@ -0,0 +1,14 @@
+extern crate libsyntax2;
+extern crate testutils;
+
+use libsyntax2::parse;
+use libsyntax2::utils::dump_tree;
+use testutils::dir_tests;
+
+#[test]
+fn parser_tests() {
+    dir_tests(&["parser/inline", "parser/ok", "parser/err"], |text| {
+        let file = parse(text);
+        dump_tree(&file)
+    })
+}
diff --git a/crates/libsyntax2/tests/testutils/Cargo.toml b/crates/libsyntax2/tests/testutils/Cargo.toml
new file mode 100644
index 000000000..53b20f17b
--- /dev/null
+++ b/crates/libsyntax2/tests/testutils/Cargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "testutils"
+version = "0.1.0"
+authors = ["Aleksey Kladov <[email protected]>"]
+
+[dependencies]
+difference = "2.0.0"
diff --git a/crates/libsyntax2/tests/testutils/src/lib.rs b/crates/libsyntax2/tests/testutils/src/lib.rs
new file mode 100644
index 000000000..39c821661
--- /dev/null
+++ b/crates/libsyntax2/tests/testutils/src/lib.rs
@@ -0,0 +1,111 @@
+extern crate difference;
+
+use std::{
+    fs,
+    path::{Path, PathBuf},
+};
+
+use difference::Changeset;
+
+/// Read file and normalize newlines.
+///
+/// `rustc` seems to always normalize `\r\n` newlines to `\n`:
+///
+/// ```
+/// let s = "
+/// ";
+/// assert_eq!(s.as_bytes(), &[10]);
+/// ```
+///
+/// so this should always be correct.
+fn read_text(path: &Path) -> String {
+    fs::read_to_string(path).unwrap().replace("\r\n", "\n")
+}
+
+pub fn dir_tests<F>(paths: &[&str], f: F)
+where
+    F: Fn(&str) -> String,
+{
+    for path in collect_tests(paths) {
+        let input_code = read_text(&path);
+        let parse_tree = f(&input_code);
+        let path = path.with_extension("txt");
+        if !path.exists() {
+            println!("\nfile: {}", path.display());
+            println!("No .txt file with expected result, creating...\n");
+            println!("{}\n{}", input_code, parse_tree);
+            fs::write(&path, parse_tree).unwrap();
+            panic!("No expected result")
+        }
+        let expected = read_text(&path);
+        let expected = expected.as_str();
+        let parse_tree = parse_tree.as_str();
+        assert_equal_text(expected, parse_tree, &path);
+    }
+}
+
+fn assert_equal_text(expected: &str, actual: &str, path: &Path) {
+    if expected != actual {
+        print_difference(expected, actual, path)
+    }
+}
+
+fn collect_tests(paths: &[&str]) -> Vec<PathBuf> {
+    paths
+        .iter()
+        .flat_map(|path| {
+            let path = test_data_dir().join(path);
+            test_from_dir(&path).into_iter()
+        })
+        .collect()
+}
+
+fn test_from_dir(dir: &Path) -> Vec<PathBuf> {
+    let mut acc = Vec::new();
+    for file in fs::read_dir(&dir).unwrap() {
+        let file = file.unwrap();
+        let path = file.path();
+        if path.extension().unwrap_or_default() == "rs" {
+            acc.push(path);
+        }
+    }
+    acc.sort();
+    acc
+}
+
+const REWRITE: bool = false;
+
+fn print_difference(expected: &str, actual: &str, path: &Path) {
+    let dir = project_dir();
+    let path = path.strip_prefix(&dir).unwrap_or_else(|_| path);
+    if expected.trim() == actual.trim() {
+        println!("whitespace difference, rewriting");
+        println!("file: {}\n", path.display());
+        fs::write(path, actual).unwrap();
+        return;
+    }
+    if REWRITE {
+        println!("rewriting {}", path.display());
+        fs::write(path, actual).unwrap();
+        return;
+    }
+    let changeset = Changeset::new(actual, expected, "\n");
+    println!("Expected:\n{}\n\nActual:\n{}\n", expected, actual);
+    print!("{}", changeset);
+    println!("file: {}\n", path.display());
+    panic!("Comparison failed")
+}
+
+fn project_dir() -> PathBuf {
+    let dir = env!("CARGO_MANIFEST_DIR");
+    PathBuf::from(dir)
+        .parent()
+        .unwrap()
+        .parent()
+        .unwrap()
+        .to_owned()
+}
+
+fn test_data_dir() -> PathBuf {
+    project_dir().join("tests/data")
+}
diff --git a/crates/server/Cargo.toml b/crates/server/Cargo.toml
new file mode 100644
index 000000000..e6d1b18c3
--- /dev/null
+++ b/crates/server/Cargo.toml
@@ -0,0 +1,18 @@
+[package]
+name = "m"
+version = "0.1.0"
+authors = ["Aleksey Kladov <[email protected]>"]
+
+[dependencies]
+failure = "0.1.2"
+languageserver-types = "0.48.0"
+serde_json = "1.0.24"
+serde = "1.0.71"
+serde_derive = "1.0.71"
+drop_bomb = "0.1.0"
+crossbeam-channel = "0.2.4"
+threadpool = "1.7.1"
+flexi_logger = "0.9.0"
+log = "0.4.3"
+libeditor = { path = "../libeditor" }
+libanalysis = { path = "../libanalysis" }
diff --git a/crates/server/src/caps.rs b/crates/server/src/caps.rs
new file mode 100644
index 000000000..3d89c64a9
--- /dev/null
+++ b/crates/server/src/caps.rs
@@ -0,0 +1,36 @@
+use languageserver_types::{
+    ServerCapabilities,
+    TextDocumentSyncCapability,
+    TextDocumentSyncOptions,
+    TextDocumentSyncKind,
+};
+
+pub const SERVER_CAPABILITIES: ServerCapabilities = ServerCapabilities {
+    text_document_sync: Some(TextDocumentSyncCapability::Options(
+        TextDocumentSyncOptions {
+            open_close: Some(true),
+            change: Some(TextDocumentSyncKind::Full),
+            will_save: None,
+            will_save_wait_until: None,
+            save: None,
+        }
+    )),
+    hover_provider: None,
+    completion_provider: None,
+    signature_help_provider: None,
+    definition_provider: None,
+    type_definition_provider: None,
+    implementation_provider: None,
+    references_provider: None,
+    document_highlight_provider: None,
+    document_symbol_provider: None,
+    workspace_symbol_provider: None,
+    code_action_provider: None,
+    code_lens_provider: None,
+    document_formatting_provider: None,
+    document_range_formatting_provider: None,
+    document_on_type_formatting_provider: None,
+    rename_provider: None,
+    color_provider: None,
+    execute_command_provider: None,
+};
diff --git a/crates/server/src/dispatch.rs b/crates/server/src/dispatch.rs
new file mode 100644
index 000000000..2da0996e3
--- /dev/null
+++ b/crates/server/src/dispatch.rs
@@ -0,0 +1,174 @@
+use std::marker::PhantomData;
+
+use serde::{
+    ser::Serialize,
+    de::DeserializeOwned,
+};
+use serde_json;
+use drop_bomb::DropBomb;
+
+use ::{
+    Result,
+    req::{Request, Notification},
+    io::{Io, RawMsg, RawResponse, RawRequest, RawNotification},
+};
+
+pub struct Responder<R: Request> {
+    id: u64,
+    bomb: DropBomb,
+    ph: PhantomData<R>,
+}
+
+impl<R: Request> Responder<R>
+    where
+        R::Params: DeserializeOwned,
+        R::Result: Serialize,
+{
+    pub fn response(self, io: &mut Io, resp: Result<R::Result>) -> Result<()> {
+        match resp {
+            Ok(res) => self.result(io, res)?,
+            Err(e) => {
+                self.error(io)?;
+                return Err(e);
+            }
+        }
+        Ok(())
+    }
+
+    pub fn result(mut self, io: &mut Io, result: R::Result) -> Result<()> {
+        self.bomb.defuse();
+        io.send(RawMsg::Response(RawResponse {
+            id: Some(self.id),
+            result: serde_json::to_value(result)?,
+            error: serde_json::Value::Null,
+        }));
+        Ok(())
+    }
+
+    pub fn error(mut self, io: &mut Io) -> Result<()> {
+        self.bomb.defuse();
+        error(io, self.id, ErrorCode::InternalError, "internal error")
+    }
+}
+
+
+fn parse_request_as<R>(raw: RawRequest) -> Result<::std::result::Result<(R::Params, Responder<R>), RawRequest>>
+    where
+        R: Request,
+        R::Params: DeserializeOwned,
+        R::Result: Serialize,
+{
+    if raw.method != R::METHOD {
+        return Ok(Err(raw));
+    }
+
+    let params: R::Params = serde_json::from_value(raw.params)?;
+    let responder = Responder {
+        id: raw.id,
+        bomb: DropBomb::new("dropped request"),
+        ph: PhantomData,
+    };
+    Ok(Ok((params, responder)))
+}
+
+pub fn handle_request<R, F>(req: &mut Option<RawRequest>, f: F) -> Result<()>
+    where
+        R: Request,
+        R::Params: DeserializeOwned,
+        R::Result: Serialize,
+        F: FnOnce(R::Params, Responder<R>) -> Result<()>
+{
+    match req.take() {
+        None => Ok(()),
+        Some(r) => match parse_request_as::<R>(r)? {
+            Ok((params, responder)) => f(params, responder),
+            Err(r) => {
+                *req = Some(r);
+                Ok(())
+            },
+        }
+    }
+}
+
+pub fn expect_request<R>(io: &mut Io, raw: RawRequest) -> Result<Option<(R::Params, Responder<R>)>>
+    where
+        R: Request,
+        R::Params: DeserializeOwned,
+        R::Result: Serialize,
+{
+    let ret = match parse_request_as::<R>(raw)? {
+        Ok(x) => Some(x),
+        Err(raw) => {
+            unknown_method(io, raw)?;
+            None
+        }
+    };
+    Ok(ret)
+}
+
+fn parse_notification_as<N>(raw: RawNotification) -> Result<::std::result::Result<N::Params, RawNotification>>
+    where
+        N: Notification,
+        N::Params: DeserializeOwned,
+{
+    if raw.method != N::METHOD {
+        return Ok(Err(raw));
+    }
+    let params: N::Params = serde_json::from_value(raw.params)?;
+    Ok(Ok(params))
+}
+
+pub fn handle_notification<N, F>(not: &mut Option<RawNotification>, f: F) -> Result<()>
+    where
+        N: Notification,
+        N::Params: DeserializeOwned,
+        F: FnOnce(N::Params) -> Result<()>
+{
+    match not.take() {
+        None => Ok(()),
+        Some(n) => match parse_notification_as::<N>(n)? {
+            Ok(params) => f(params),
+            Err(n) => {
+                *not = Some(n);
+                Ok(())
+            },
+        }
+    }
+}
+
+
+pub fn unknown_method(io: &mut Io, raw: RawRequest) -> Result<()> {
+    error(io, raw.id, ErrorCode::MethodNotFound, "unknown method")
+}
+
+fn error(io: &mut Io, id: u64, code: ErrorCode, message: &'static str) -> Result<()> {
+    #[derive(Serialize)]
+    struct Error {
+        code: i32,
+        message: &'static str,
+    }
+    io.send(RawMsg::Response(RawResponse {
+        id: Some(id),
+        result: serde_json::Value::Null,
+        error: serde_json::to_value(Error {
+            code: code as i32,
+            message,
+        })?,
+    }));
+    Ok(())
+}
+
+
+#[allow(unused)]
+enum ErrorCode {
+    ParseError = -32700,
+    InvalidRequest = -32600,
+    MethodNotFound = -32601,
+    InvalidParams = -32602,
+    InternalError = -32603,
+    ServerErrorStart = -32099,
+    ServerErrorEnd = -32000,
+    ServerNotInitialized = -32002,
+    UnknownErrorCode = -32001,
+    RequestCancelled = -32800,
+}
diff --git a/crates/server/src/handlers.rs b/crates/server/src/handlers.rs
new file mode 100644
index 000000000..5ee87a4dd
--- /dev/null
+++ b/crates/server/src/handlers.rs
@@ -0,0 +1,61 @@
+use languageserver_types::{Range, Position};
+use libanalysis::World;
+use libeditor::{self, LineIndex, LineCol, TextRange, TextUnit};
+use {req, Result, FilePath};
+
+pub fn handle_syntax_tree(
+    world: World,
+    params: req::SyntaxTreeParams,
+) -> Result<String> {
+    let path = params.text_document.file_path()?;
+    let file = world.file_syntax(&path)?;
+    Ok(libeditor::syntax_tree(&file))
+}
+
+pub fn handle_extend_selection(
+    world: World,
+    params: req::ExtendSelectionParams,
+) -> Result<req::ExtendSelectionResult> {
+    let path = params.text_document.file_path()?;
+    let file = world.file_syntax(&path)?;
+    let line_index = world.file_line_index(&path)?;
+    let selections = params.selections.into_iter()
+        .map(|r| {
+            let r = to_text_range(&line_index, r);
+            let r = libeditor::extend_selection(&file, r).unwrap_or(r);
+            to_vs_range(&line_index, r)
+        })
+        .collect();
+    Ok(req::ExtendSelectionResult { selections })
+}
+
+
+fn to_text_range(line_index: &LineIndex, range: Range) -> TextRange {
+    TextRange::from_to(
+        to_text_unit(line_index, range.start),
+        to_text_unit(line_index, range.end),
+    )
+}
+
+fn to_text_unit(line_index: &LineIndex, position: Position) -> TextUnit {
+    // TODO: UTF-16
+    let line_col = LineCol {
+        line: position.line as u32,
+        col: (position.character as u32).into(),
+    };
+    line_index.offset(line_col)
+}
+
+
+fn to_vs_range(line_index: &LineIndex, range: TextRange) -> Range {
+    Range::new(
+        to_vs_position(line_index, range.start()),
+        to_vs_position(line_index, range.end()),
+    )
+}
+
+fn to_vs_position(line_index: &LineIndex, offset: TextUnit) -> Position {
+    let line_col = line_index.line_col(offset);
+    // TODO: UTF-16
+    Position::new(line_col.line as u64, u32::from(line_col.col) as u64)
+}
diff --git a/crates/server/src/io.rs b/crates/server/src/io.rs
new file mode 100644
index 000000000..5eafc6942
--- /dev/null
+++ b/crates/server/src/io.rs
@@ -0,0 +1,202 @@
+use std::{
+    thread,
+    io::{
+        stdout, stdin,
+        BufRead, Write,
+    },
+};
+use serde_json::{Value, from_str, to_string};
+use crossbeam_channel::{Receiver, Sender, bounded};
+
+use Result;
+
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum RawMsg {
+    Request(RawRequest),
+    Notification(RawNotification),
+    Response(RawResponse),
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RawRequest {
+    pub id: u64,
+    pub method: String,
+    pub params: Value,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RawNotification {
+    pub method: String,
+    pub params: Value,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RawResponse {
+    pub id: Option<u64>,
+    pub result: Value,
+    pub error: Value,
+}
+
+struct MsgReceiver {
+    chan: Receiver<RawMsg>,
+    thread: Option<thread::JoinHandle<Result<()>>>,
+}
+
+impl MsgReceiver {
+    fn recv(&mut self) -> Result<RawMsg> {
+        match self.chan.recv() {
+            Some(msg) => Ok(msg),
+            None => {
+                self.cleanup()?;
+                unreachable!()
+            }
+        }
+    }
+
+    fn cleanup(&mut self) -> Result<()> {
+        self.thread
+            .take()
+            .ok_or_else(|| format_err!("MsgReceiver thread panicked"))?
+            .join()
+            .map_err(|_| format_err!("MsgReceiver thread panicked"))??;
+        bail!("client disconnected")
+    }
+
+    fn stop(self) -> Result<()> {
+        // Can't really self.thread.join() here, b/c it might be
+        // blocking on read
+        Ok(())
+    }
+}
+
+struct MsgSender {
+    chan: Sender<RawMsg>,
+    thread: thread::JoinHandle<Result<()>>,
+}
+
+impl MsgSender {
+    fn send(&mut self, msg: RawMsg) {
+        self.chan.send(msg)
+    }
+
+    fn stop(self) -> Result<()> {
+        drop(self.chan);
+        self.thread.join()
+            .map_err(|_| format_err!("MsgSender thread panicked"))??;
+        Ok(())
+    }
+}
+
+pub struct Io {
+    receiver: MsgReceiver,
+    sender: MsgSender,
+}
+
+impl Io {
+    pub fn from_stdio() -> Io {
+        let sender = {
+            let (tx, rx) = bounded(16);
+            MsgSender {
+                chan: tx,
+                thread: thread::spawn(move || {
+                    let stdout = stdout();
+                    let mut stdout = stdout.lock();
+                    for msg in rx {
+                        #[derive(Serialize)]
+                        struct JsonRpc {
+                            jsonrpc: &'static str,
+                            #[serde(flatten)]
+                            msg: RawMsg,
+                        }
+                        let text = to_string(&JsonRpc {
+                            jsonrpc: "2.0",
+                            msg,
+                        })?;
+                        write_msg_text(&mut stdout, &text)?;
+                    }
+                    Ok(())
+                }),
+            }
+        };
+        let receiver = {
+            let (tx, rx) = bounded(16);
+            MsgReceiver {
+                chan: rx,
+                thread: Some(thread::spawn(move || {
+                    let stdin = stdin();
+                    let mut stdin = stdin.lock();
+                    while let Some(text) = read_msg_text(&mut stdin)? {
+                        let msg: RawMsg = from_str(&text)?;
+                        tx.send(msg);
+                    }
+                    Ok(())
+                })),
+            }
+        };
+        Io { receiver, sender }
+    }
+
+    pub fn send(&mut self, msg: RawMsg) {
+        self.sender.send(msg)
+    }
+
+    pub fn recv(&mut self) -> Result<RawMsg> {
+        self.receiver.recv()
+    }
+
+    pub fn receiver(&mut self) -> &mut Receiver<RawMsg> {
+        &mut self.receiver.chan
+    }
+
+    pub fn cleanup_receiver(&mut self) -> Result<()> {
+        self.receiver.cleanup()
+    }
+
+    pub fn stop(self) -> Result<()> {
+        self.receiver.stop()?;
+        self.sender.stop()?;
+        Ok(())
+    }
+}
+
+
+fn read_msg_text(inp: &mut impl BufRead) -> Result<Option<String>> {
+    let mut size = None;
+    let mut buf = String::new();
+    loop {
+        buf.clear();
+        if inp.read_line(&mut buf)? == 0 {
+            return Ok(None);
+        }
+        if !buf.ends_with("\r\n") {
+            bail!("malformed header: {:?}", buf);
+        }
+        let buf = &buf[..buf.len() - 2];
+        if buf.is_empty() {
+            break;
+        }
+        let mut parts = buf.splitn(2, ": ");
+        let header_name = parts.next().unwrap();
+        let header_value = parts.next().ok_or_else(|| format_err!("malformed header: {:?}", buf))?;
+        if header_name == "Content-Length" {
+            size = Some(header_value.parse::<usize>()?);
+        }
+    }
+    let size = size.ok_or_else(|| format_err!("no Content-Length"))?;
+    let mut buf = buf.into_bytes();
+    buf.resize(size, 0);
+    inp.read_exact(&mut buf)?;
+    let buf = String::from_utf8(buf)?;
+    debug!("< {}", buf);
+    Ok(Some(buf))
+}
+
+fn write_msg_text(out: &mut impl Write, msg: &str) -> Result<()> {
+    debug!("> {}", msg);
+    write!(out, "Content-Length: {}\r\n\r\n", msg.len())?;
+    out.write_all(msg.as_bytes())?;
+    out.flush()?;
+    Ok(())
+}
diff --git a/crates/server/src/main.rs b/crates/server/src/main.rs
new file mode 100644
index 000000000..116abce1c
--- /dev/null
+++ b/crates/server/src/main.rs
@@ -0,0 +1,249 @@
+#[macro_use]
+extern crate failure;
+#[macro_use]
+extern crate serde_derive;
+extern crate serde;
+extern crate serde_json;
+extern crate languageserver_types;
+extern crate drop_bomb;
+#[macro_use]
+extern crate crossbeam_channel;
+extern crate threadpool;
+#[macro_use]
+extern crate log;
+extern crate flexi_logger;
+extern crate libeditor;
+extern crate libanalysis;
+
+mod io;
+mod caps;
+mod req;
+mod dispatch;
+mod handlers;
+
+use std::path::PathBuf;
+
+use threadpool::ThreadPool;
+use crossbeam_channel::{bounded, Sender, Receiver};
+use flexi_logger::Logger;
+use libanalysis::WorldState;
+use languageserver_types::{TextDocumentItem, VersionedTextDocumentIdentifier, TextDocumentIdentifier};
+
+use ::{
+    io::{Io, RawMsg},
+    handlers::{handle_syntax_tree, handle_extend_selection},
+};
+
+pub type Result<T> = ::std::result::Result<T, ::failure::Error>;
+
+fn main() -> Result<()> {
+    Logger::with_env_or_str("m=trace, libanalysis=trace")
+        .log_to_file()
+        .directory("log")
+        .start()?;
+    info!("starting server");
+    match ::std::panic::catch_unwind(|| main_inner()) {
+        Ok(res) => {
+            info!("shutting down: {:?}", res);
+            res
+        }
+        Err(_) => {
+            error!("server panicked");
+            bail!("server panicked")
+        }
+    }
+}
+
+fn main_inner() -> Result<()> {
+    let mut io = Io::from_stdio();
+    let res = initialize(&mut io);
+    info!("shutting down IO...");
+    let io_res = io.stop();
+    info!("... IO is down");
+    match (res, io_res) {
+        (Ok(()), Ok(())) => Ok(()),
+        (res, Ok(())) => res,
+        (Ok(()), io_res) => io_res,
+        (res, Err(io_err)) => {
+            error!("shutdown error: {:?}", io_err);
+            res
+        }
+    }
+}
+
+fn initialize(io: &mut Io) -> Result<()> {
+    loop {
+        match io.recv()? {
+            RawMsg::Request(req) => {
+                if let Some((_params, resp)) = dispatch::expect_request::<req::Initialize>(io, req)? {
+                    resp.result(io, req::InitializeResult {
+                        capabilities: caps::SERVER_CAPABILITIES
+                    })?;
+                    match io.recv()? {
+                        RawMsg::Notification(n) => {
+                            if n.method != "initialized" {
+                                bail!("expected initialized notification");
+                            }
+                        }
+                        _ => {
+                            bail!("expected initialized notification");
+                        }
+                    }
+                    return initialized(io);
+                }
+            }
+            RawMsg::Notification(n) => {
+                bail!("expected initialize request, got {:?}", n)
+            }
+            RawMsg::Response(res) => {
+                bail!("expected initialize request, got {:?}", res)
+            }
+        }
+    }
+}
+
+type Thunk = Box<for<'a> FnBox<&'a mut Io, Result<()>>>;
+
+fn initialized(io: &mut Io) -> Result<()> {
+    let mut world = WorldState::new();
+    let mut pool = ThreadPool::new(4);
+    let (sender, receiver) = bounded::<Thunk>(16);
+    let res = main_loop(io, &mut world, &mut pool, sender, receiver.clone());
+    info!("waiting for background jobs to finish...");
+    receiver.for_each(drop);
+    pool.join();
+    info!("...background jobs have finished");
+    res
+}
+
+fn main_loop(
+    io: &mut Io,
+    world: &mut WorldState,
+    pool: &mut ThreadPool,
+    sender: Sender<Thunk>,
+    receiver: Receiver<Thunk>,
+) -> Result<()> {
+    info!("server initialized, serving requests");
+    loop {
+        enum Event {
+            Msg(RawMsg),
+            Thunk(Thunk),
+            ReceiverDead,
+        }
+
+        let event = select! {
+            recv(io.receiver(), msg) => match msg {
+                Some(msg) => Event::Msg(msg),
+                None => Event::ReceiverDead,
+            },
+            recv(receiver, thunk) => Event::Thunk(thunk.unwrap()),
+        };
+
+        let msg = match event {
+            Event::ReceiverDead => {
+                io.cleanup_receiver()?;
+                unreachable!();
+            }
+            Event::Thunk(thunk) => {
+                thunk.call_box(io)?;
+                continue;
+            }
+            Event::Msg(msg) => msg,
+        };
+
+        match msg {
+            RawMsg::Request(req) => {
+                let mut req = Some(req);
+                dispatch::handle_request::<req::SyntaxTree, _>(&mut req, |params, resp| {
+                    let world = world.snapshot();
+                    let sender = sender.clone();
+                    pool.execute(move || {
+                        let res = handle_syntax_tree(world, params);
+                        sender.send(Box::new(|io: &mut Io| resp.response(io, res)))
+                    });
+                    Ok(())
+                })?;
+                dispatch::handle_request::<req::ExtendSelection, _>(&mut req, |params, resp| {
+                    let world = world.snapshot();
+                    let sender = sender.clone();
+                    pool.execute(move || {
+                        let res = handle_extend_selection(world, params);
+                        sender.send(Box::new(|io: &mut Io| resp.response(io, res)))
+                    });
+                    Ok(())
+                })?;
+                dispatch::handle_request::<req::Shutdown, _>(&mut req, |(), resp| {
+                    resp.result(io, ())?;
+                    Ok(())
+                })?;
+                if let Some(req) = req {
+                    error!("unknown method: {:?}", req);
+                    dispatch::unknown_method(io, req)?;
+                }
+            }
+            RawMsg::Notification(not) => {
+                let mut not = Some(not);
+                dispatch::handle_notification::<req::DidOpenTextDocument, _>(&mut not, |params| {
+                    let path = params.text_document.file_path()?;
+                    world.change_overlay(path, Some(params.text_document.text));
+                    Ok(())
+                })?;
+                dispatch::handle_notification::<req::DidChangeTextDocument, _>(&mut not, |mut params| {
+                    let path = params.text_document.file_path()?;
+                    let text = params.content_changes.pop()
+                        .ok_or_else(|| format_err!("empty changes"))?
+                        .text;
+                    world.change_overlay(path, Some(text));
+                    Ok(())
+                })?;
+                dispatch::handle_notification::<req::DidCloseTextDocument, _>(&mut not, |params| {
+                    let path = params.text_document.file_path()?;
+                    world.change_overlay(path, None);
+                    Ok(())
+                })?;
+
+                if let Some(not) = not {
+                    error!("unhandled notification: {:?}", not)
+                }
+            }
+            msg => {
+                eprintln!("msg = {:?}", msg);
+            }
+        }
+    }
+}
+
+trait FnBox<A, R>: Send {
+    fn call_box(self: Box<Self>, a: A) -> R;
+}
+
+impl<A, R, F: FnOnce(A) -> R + Send> FnBox<A, R> for F {
+    fn call_box(self: Box<F>, a: A) -> R {
+        (*self)(a)
+    }
+}
+
+trait FilePath {
+    fn file_path(&self) -> Result<PathBuf>;
+}
+
+impl FilePath for TextDocumentItem {
+    fn file_path(&self) -> Result<PathBuf> {
+        self.uri.to_file_path()
+            .map_err(|()| format_err!("invalid uri: {}", self.uri))
+    }
+}
+
+impl FilePath for VersionedTextDocumentIdentifier {
+    fn file_path(&self) -> Result<PathBuf> {
+        self.uri.to_file_path()
+            .map_err(|()| format_err!("invalid uri: {}", self.uri))
+    }
+}
+
+impl FilePath for TextDocumentIdentifier {
+    fn file_path(&self) -> Result<PathBuf> {
+        self.uri.to_file_path()
+            .map_err(|()| format_err!("invalid uri: {}", self.uri))
+    }
+}
diff --git a/crates/server/src/req.rs b/crates/server/src/req.rs
new file mode 100644
index 000000000..4e588159b
--- /dev/null
+++ b/crates/server/src/req.rs
@@ -0,0 +1,41 @@
+use languageserver_types::{TextDocumentIdentifier, Range};
+
+pub use languageserver_types::{
+    request::*, notification::*,
+    InitializeResult,
+};
+
+pub enum SyntaxTree {}
+
+impl Request for SyntaxTree {
+    type Params = SyntaxTreeParams;
+    type Result = String;
+    const METHOD: &'static str = "m/syntaxTree";
+}
+
+#[derive(Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct SyntaxTreeParams {
+    pub text_document: TextDocumentIdentifier
+}
+
+pub enum ExtendSelection {}
+
+impl Request for ExtendSelection {
+    type Params = ExtendSelectionParams;
+    type Result = ExtendSelectionResult;
+    const METHOD: &'static str = "m/extendSelection";
+}
+
+#[derive(Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct ExtendSelectionParams {
+    pub text_document: TextDocumentIdentifier,
+    pub selections: Vec<Range>,
+}
+
+#[derive(Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct ExtendSelectionResult {
+    pub selections: Vec<Range>,
+}
diff --git a/crates/tools/Cargo.toml b/crates/tools/Cargo.toml
new file mode 100644
index 000000000..f9fee16f9
--- /dev/null
+++ b/crates/tools/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "tools"
+version = "0.1.0"
+authors = ["Aleksey Kladov <[email protected]>"]
+publish = false
+
+[dependencies]
+ron = "0.1.7"
+walkdir = "2.1.3"
+itertools = "0.7.8"
+tera = "0.11"
+clap = "2.32.0"
+failure = "0.1.1"
+commandspec = "0.10"
diff --git a/crates/tools/src/lib.rs b/crates/tools/src/lib.rs
new file mode 100644
index 000000000..97a56a31f
--- /dev/null
+++ b/crates/tools/src/lib.rs
@@ -0,0 +1,43 @@
+extern crate itertools;
+
+use itertools::Itertools;
+
+#[derive(Debug)]
+pub struct Test {
+    pub name: String,
+    pub text: String,
+}
+
+pub fn collect_tests(s: &str) -> Vec<(usize, Test)> {
+    let mut res = vec![];
+    let prefix = "// ";
+    let comment_blocks = s
+        .lines()
+        .map(str::trim_left)
+        .enumerate()
+        .group_by(|(_idx, line)| line.starts_with(prefix));
+
+    'outer: for (is_comment, block) in comment_blocks.into_iter() {
+        if !is_comment {
+            continue;
+        }
+        let mut block = block.map(|(idx, line)| (idx, &line[prefix.len()..]));
+
+        let (start_line, name) = loop {
+            match block.next() {
+                Some((idx, line)) if line.starts_with("test ") => {
+                    break (idx, line["test ".len()..].to_string())
+                }
+                Some(_) => (),
+                None => continue 'outer,
+            }
+        };
+        let text: String = itertools::join(
+            block.map(|(_, line)| line).chain(::std::iter::once("")),
+            "\n",
+        );
+        assert!(!text.trim().is_empty() && text.ends_with("\n"));
+        res.push((start_line, Test { name, text }))
+    }
+    res
+}
diff --git a/crates/tools/src/main.rs b/crates/tools/src/main.rs
new file mode 100644
index 000000000..d42d3ecb7
--- /dev/null
+++ b/crates/tools/src/main.rs
@@ -0,0 +1,216 @@
+extern crate clap;
+#[macro_use]
+extern crate failure;
+extern crate ron;
+extern crate tera;
+extern crate tools;
+extern crate walkdir;
+#[macro_use]
+extern crate commandspec;
+
+use clap::{App, Arg, SubCommand};
+use std::{
+    collections::HashMap,
+    fs,
+    path::{Path, PathBuf},
+};
+use tools::{collect_tests, Test};
+
+type Result<T> = ::std::result::Result<T, failure::Error>;
+
+const GRAMMAR_DIR: &str = "./crates/libsyntax2/src/grammar";
+const INLINE_TESTS_DIR: &str = "./crates/libsyntax2/tests/data/parser/inline";
+const GRAMMAR: &str = "./crates/libsyntax2/src/grammar.ron";
+const SYNTAX_KINDS: &str = "./crates/libsyntax2/src/syntax_kinds/generated.rs";
+const SYNTAX_KINDS_TEMPLATE: &str = "./crates/libsyntax2/src/syntax_kinds/generated.rs.tera";
+const AST: &str = "./crates/libsyntax2/src/ast/generated.rs";
+const AST_TEMPLATE: &str = "./crates/libsyntax2/src/ast/generated.rs.tera";
+
+fn main() -> Result<()> {
+    let matches = App::new("tasks")
+        .setting(clap::AppSettings::SubcommandRequiredElseHelp)
+        .arg(
+            Arg::with_name("verify")
+                .long("--verify")
+                .help("Verify that generated code is up-to-date")
+                .global(true),
+        )
+        .subcommand(SubCommand::with_name("gen-kinds"))
+        .subcommand(SubCommand::with_name("gen-tests"))
+        .subcommand(SubCommand::with_name("install-code"))
+        .get_matches();
+    match matches.subcommand() {
+        ("install-code", _) => install_code_extension()?,
+        (name, Some(matches)) => run_gen_command(name, matches.is_present("verify"))?,
+        _ => unreachable!(),
+    }
+    Ok(())
+}
+
+fn run_gen_command(name: &str, verify: bool) -> Result<()> {
+    match name {
+        "gen-kinds" => {
+            update(Path::new(SYNTAX_KINDS), &render_template(SYNTAX_KINDS_TEMPLATE)?, verify)?;
+            update(Path::new(AST), &render_template(AST_TEMPLATE)?, verify)?;
+        },
+        "gen-tests" => {
+            gen_tests(verify)?
+        },
+        _ => unreachable!(),
+    }
+    Ok(())
+}
+
+fn update(path: &Path, contents: &str, verify: bool) -> Result<()> {
+    match fs::read_to_string(path) {
+        Ok(ref old_contents) if old_contents == contents => {
+            return Ok(());
+        }
+        _ => (),
+    }
+    if verify {
+        bail!("`{}` is not up-to-date", path.display());
+    }
+    eprintln!("updating {}", path.display());
+    fs::write(path, contents)?;
+    Ok(())
+}
+
+fn render_template(template: &str) -> Result<String> {
+    let grammar: ron::value::Value = {
+        let text = fs::read_to_string(GRAMMAR)?;
+        ron::de::from_str(&text)?
+    };
+    let template = fs::read_to_string(template)?;
+    let mut tera = tera::Tera::default();
+    tera.add_raw_template("grammar", &template)
+        .map_err(|e| format_err!("template error: {:?}", e))?;
+    tera.register_global_function("concat", Box::new(concat));
+    tera.register_filter("camel", |arg, _| {
+        Ok(arg.as_str().unwrap()
+            .split("_")
+            .flat_map(|word| {
+                word.chars()
+                    .next().unwrap()
+                    .to_uppercase()
+                    .chain(
+                        word.chars().skip(1).flat_map(|c| c.to_lowercase())
+                    )
+            })
+            .collect::<String>()
+            .into())
+    });
+    let ret = tera
+        .render("grammar", &grammar)
+        .map_err(|e| format_err!("template error: {:?}", e))?;
+    return Ok(ret);
+
+    fn concat(args: HashMap<String, tera::Value>) -> tera::Result<tera::Value> {
+        let mut elements = Vec::new();
+        for &key in ["a", "b", "c"].iter() {
+            let val = match args.get(key) {
+                Some(val) => val,
+                None => continue,
+            };
+            let val = val.as_array().unwrap();
+            elements.extend(val.iter().cloned());
+        }
+        Ok(tera::Value::Array(elements))
+    }
+}
+
+fn gen_tests(verify: bool) -> Result<()> {
+    let tests = tests_from_dir(Path::new(GRAMMAR_DIR))?;
+
+    let inline_tests_dir = Path::new(INLINE_TESTS_DIR);
+    if !inline_tests_dir.is_dir() {
+        fs::create_dir_all(inline_tests_dir)?;
+    }
+    let existing = existing_tests(inline_tests_dir)?;
+
+    for t in existing.keys().filter(|&t| !tests.contains_key(t)) {
+        panic!("Test is deleted: {}", t);
+    }
+
+    let mut new_idx = existing.len() + 2;
+    for (name, test) in tests {
+        let path = match existing.get(&name) {
+            Some((path, _test)) => path.clone(),
+            None => {
+                let file_name = format!("{:04}_{}.rs", new_idx, name);
+                new_idx += 1;
+                inline_tests_dir.join(file_name)
+            }
+        };
+        update(&path, &test.text, verify)?;
+    }
+    Ok(())
+}
+
+fn tests_from_dir(dir: &Path) -> Result<HashMap<String, Test>> {
+    let mut res = HashMap::new();
+    for entry in ::walkdir::WalkDir::new(dir) {
+        let entry = entry.unwrap();
+        if !entry.file_type().is_file() {
+            continue;
+        }
+        if entry.path().extension().unwrap_or_default() != "rs" {
+            continue;
+        }
+        let text = fs::read_to_string(entry.path())?;
+
+        for (_, test) in collect_tests(&text) {
+            if let Some(old_test) = res.insert(test.name.clone(), test) {
+                bail!("Duplicate test: {}", old_test.name)
+            }
+        }
+    }
+    Ok(res)
+}
+
+fn existing_tests(dir: &Path) -> Result<HashMap<String, (PathBuf, Test)>> {
+    let mut res = HashMap::new();
+    for file in fs::read_dir(dir)? {
+        let file = file?;
+        let path = file.path();
+        if path.extension().unwrap_or_default() != "rs" {
+            continue;
+        }
+        let name = {
+            let file_name = path.file_name().unwrap().to_str().unwrap();
+            file_name[5..file_name.len() - 3].to_string()
+        };
+        let text = fs::read_to_string(&path)?;
+        let test = Test {
+            name: name.clone(),
+            text,
+        };
+        match res.insert(name, (path, test)) {
+            Some(old) => println!("Duplicate test: {:?}", old),
+            None => (),
+        }
+    }
+    Ok(res)
+}
+
+fn install_code_extension() -> Result<()> {
+    execute!(
+        r"
+cd code
+npm install
+    "
+    )?;
+    execute!(
+        r"
+cd code
+./node_modules/vsce/out/vsce package
+    "
+    )?;
+    execute!(
+        r"
+cd code
+code --install-extension ./libsyntax-rust-0.0.1.vsix
+    "
+    )?;
+    Ok(())
+}