65 files changed, 1114 insertions, 988 deletions
diff --git a/crates/gen_lsp_server/Cargo.toml b/crates/gen_lsp_server/Cargo.toml
index 34343e2f2..ba8bfdbd3 100644
--- a/crates/gen_lsp_server/Cargo.toml
+++ b/crates/gen_lsp_server/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 edition = "2018"
 name = "gen_lsp_server"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["rust-analyzer developers"]
 repository = "https://github.com/rust-analyzer/rust-analyzer"
 license = "MIT OR Apache-2.0"
diff --git a/crates/ra_assists/src/add_explicit_type.rs b/crates/ra_assists/src/add_explicit_type.rs
index cb0ac9885..f3ed74b7f 100644
--- a/crates/ra_assists/src/add_explicit_type.rs
+++ b/crates/ra_assists/src/add_explicit_type.rs
@@ -3,7 +3,7 @@ use hir::{
    db::HirDatabase,
 };
 use ra_syntax::{
-    SyntaxKind,
+    T,
    ast::{LetStmt, PatKind, NameOwner, AstNode}
 };
@@ -24,7 +24,7 @@ pub(crate) fn add_explicit_type(mut ctx: AssistCtx<impl HirDatabase>) -> Option<
    let name = pat.name()?;
    let name_range = name.syntax().range();
    // Assist not applicable if the type has already been specified
-    if stmt.syntax().children_with_tokens().any(|child| child.kind() == SyntaxKind::COLON) {
+    if stmt.syntax().children_with_tokens().any(|child| child.kind() == T![:]) {
        return None;
    }
    // Infer type
diff --git a/crates/ra_assists/src/ast_editor.rs b/crates/ra_assists/src/ast_editor.rs
index aa7aeaabb..9afcac01a 100644
--- a/crates/ra_assists/src/ast_editor.rs
+++ b/crates/ra_assists/src/ast_editor.rs
@@ -2,7 +2,7 @@ use std::{iter, ops::RangeInclusive};
 use arrayvec::ArrayVec;
 use ra_text_edit::TextEditBuilder;
-use ra_syntax::{AstNode, TreeArc, ast, SyntaxKind::*, SyntaxElement, SourceFile, InsertPosition, Direction};
+use ra_syntax::{AstNode, TreeArc, ast, SyntaxKind::*, SyntaxElement, SourceFile, InsertPosition, Direction, T};
 use ra_fmt::leading_indent;
 use hir::Name;
@@ -49,7 +49,7 @@ impl<N: AstNode> AstEditor<N> {
    fn do_make_multiline(&mut self) {
        let l_curly =
-            match self.ast().syntax().children_with_tokens().find(|it| it.kind() == L_CURLY) {
+            match self.ast().syntax().children_with_tokens().find(|it| it.kind() == T!['{']) {
                Some(it) => it,
                None => return,
            };
@@ -124,7 +124,7 @@ impl AstEditor<ast::NamedFieldList> {
                if let Some(comma) = $anchor
                    .syntax()
                    .siblings_with_tokens(Direction::Next)
-                    .find(|it| it.kind() == COMMA)
+                    .find(|it| it.kind() == T![,])
                {
                    InsertPosition::After(comma)
                } else {
@@ -154,7 +154,7 @@ impl AstEditor<ast::NamedFieldList> {
    }
    fn l_curly(&self) -> Option<SyntaxElement> {
-        self.ast().syntax().children_with_tokens().find(|it| it.kind() == L_CURLY)
+        self.ast().syntax().children_with_tokens().find(|it| it.kind() == T!['{'])
    }
 }
@@ -188,7 +188,7 @@ impl AstEditor<ast::ItemList> {
    }
    fn l_curly(&self) -> Option<SyntaxElement> {
-        self.ast().syntax().children_with_tokens().find(|it| it.kind() == L_CURLY)
+        self.ast().syntax().children_with_tokens().find(|it| it.kind() == T!['{'])
    }
 }
@@ -290,7 +290,7 @@ fn ast_node_from_file_text<N: AstNode>(text: &str) -> TreeArc<N> {
 mod tokens {
    use once_cell::sync::Lazy;
-    use ra_syntax::{AstNode, SourceFile, TreeArc, SyntaxToken, SyntaxKind::*};
+    use ra_syntax::{AstNode, SourceFile, TreeArc, SyntaxToken, SyntaxKind::*, T};
    static SOURCE_FILE: Lazy<TreeArc<SourceFile>> = Lazy::new(|| SourceFile::parse(",\n; ;"));
@@ -299,7 +299,7 @@ mod tokens {
            .syntax()
            .descendants_with_tokens()
            .filter_map(|it| it.as_token())
-            .find(|it| it.kind() == COMMA)
+            .find(|it| it.kind() == T![,])
            .unwrap()
    }
diff --git a/crates/ra_assists/src/auto_import.rs b/crates/ra_assists/src/auto_import.rs
index 7c856c19b..1566cf179 100644
--- a/crates/ra_assists/src/auto_import.rs
+++ b/crates/ra_assists/src/auto_import.rs
@@ -2,8 +2,9 @@ use ra_text_edit::TextEditBuilder;
 use hir::{ self, db::HirDatabase};
 use ra_syntax::{
+    T,
    ast::{ self, NameOwner }, AstNode, SyntaxNode, Direction, TextRange, SmolStr,
-    SyntaxKind::{ PATH, PATH_SEGMENT, COLONCOLON, COMMA }
+    SyntaxKind::{ PATH, PATH_SEGMENT }
 };
 use crate::{
    AssistId,
@@ -23,7 +24,7 @@ fn collect_path_segments_raw<'a>(
            children.next().map(|n| (n, n.kind())),
        );
        match (first, second, third) {
-            (Some((subpath, PATH)), Some((_, COLONCOLON)), Some((segment, PATH_SEGMENT))) => {
+            (Some((subpath, PATH)), Some((_, T![::])), Some((segment, PATH_SEGMENT))) => {
                path = ast::Path::cast(subpath.as_node()?)?;
                segments.push(ast::PathSegment::cast(segment.as_node()?)?);
            }
@@ -421,7 +422,7 @@ fn make_assist_add_in_tree_list(
    let last = tree_list.use_trees().last();
    if let Some(last) = last {
        let mut buf = String::new();
-        let comma = last.syntax().siblings(Direction::Next).find(|n| n.kind() == COMMA);
+        let comma = last.syntax().siblings(Direction::Next).find(|n| n.kind() == T![,]);
        let offset = if let Some(comma) = comma {
            comma.range().end()
        } else {
diff --git a/crates/ra_assists/src/change_visibility.rs b/crates/ra_assists/src/change_visibility.rs
index c63470726..620f534b5 100644
--- a/crates/ra_assists/src/change_visibility.rs
+++ b/crates/ra_assists/src/change_visibility.rs
@@ -1,8 +1,9 @@
 use hir::db::HirDatabase;
 use ra_syntax::{
+    T,
    AstNode, SyntaxNode, TextUnit,
    ast::{self, VisibilityOwner, NameOwner},
-    SyntaxKind::{VISIBILITY, FN_KW, MOD_KW, STRUCT_KW, ENUM_KW, TRAIT_KW, FN_DEF, MODULE, STRUCT_DEF, ENUM_DEF, TRAIT_DEF, IDENT, WHITESPACE, COMMENT, ATTR},
+    SyntaxKind::{VISIBILITY, FN_DEF, MODULE, STRUCT_DEF, ENUM_DEF, TRAIT_DEF, IDENT, WHITESPACE, COMMENT, ATTR},
 };
 use crate::{AssistCtx, Assist, AssistId};
@@ -16,7 +17,7 @@ pub(crate) fn change_visibility(ctx: AssistCtx<impl HirDatabase>) -> Option<Assi
 fn add_vis(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
    let item_keyword = ctx.token_at_offset().find(|leaf| match leaf.kind() {
-        FN_KW | MOD_KW | STRUCT_KW | ENUM_KW | TRAIT_KW => true,
+        T![fn] | T![mod] | T![struct] | T![enum] | T![trait] => true,
        _ => false,
    });
diff --git a/crates/ra_assists/src/flip_comma.rs b/crates/ra_assists/src/flip_comma.rs
index a9b108111..7626ffad3 100644
--- a/crates/ra_assists/src/flip_comma.rs
+++ b/crates/ra_assists/src/flip_comma.rs
@@ -1,14 +1,14 @@
 use hir::db::HirDatabase;
 use ra_syntax::{
+    T,
    Direction,
-    SyntaxKind::COMMA,
    algo::non_trivia_sibling,
 };
 use crate::{AssistCtx, Assist, AssistId};
 pub(crate) fn flip_comma(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
-    let comma = ctx.token_at_offset().find(|leaf| leaf.kind() == COMMA)?;
+    let comma = ctx.token_at_offset().find(|leaf| leaf.kind() == T![,])?;
    let prev = non_trivia_sibling(comma.into(), Direction::Prev)?;
    let next = non_trivia_sibling(comma.into(), Direction::Next)?;
    ctx.add_action(AssistId("flip_comma"), "flip comma", |edit| {
diff --git a/crates/ra_assists/src/remove_dbg.rs b/crates/ra_assists/src/remove_dbg.rs
index ae9958f11..6e900f8ef 100644
--- a/crates/ra_assists/src/remove_dbg.rs
+++ b/crates/ra_assists/src/remove_dbg.rs
@@ -2,9 +2,7 @@ use hir::db::HirDatabase;
 use ra_syntax::{
    ast::{self, AstNode},
    TextUnit,
-    SyntaxKind::{
+    T
-        L_PAREN, R_PAREN, L_CURLY, R_CURLY, L_BRACK, R_BRACK, EXCL
-    },
 };
 use crate::{AssistCtx, Assist, AssistId};
@@ -64,7 +62,7 @@ fn is_valid_macrocall(macro_call: &ast::MacroCall, macro_name: &str) -> Option<b
    // Make sure it is actually a dbg-macro call, dbg followed by !
    let excl = path.syntax().next_sibling_or_token()?;
-    if name_ref.text() != macro_name || excl.kind() != EXCL {
+    if name_ref.text() != macro_name || excl.kind() != T![!] {
        return None;
    }
@@ -73,7 +71,7 @@ fn is_valid_macrocall(macro_call: &ast::MacroCall, macro_name: &str) -> Option<b
    let last_child = node.last_child_or_token()?;
    match (first_child.kind(), last_child.kind()) {
-        (L_PAREN, R_PAREN) | (L_BRACK, R_BRACK) | (L_CURLY, R_CURLY) => Some(true),
+        (T!['('], T![')']) | (T!['['], T![']']) | (T!['{'], T!['}']) => Some(true),
        _ => Some(false),
    }
 }
diff --git a/crates/ra_assists/src/split_import.rs b/crates/ra_assists/src/split_import.rs
index 57e0efaf2..881c5ecdc 100644
--- a/crates/ra_assists/src/split_import.rs
+++ b/crates/ra_assists/src/split_import.rs
@@ -2,14 +2,15 @@ use std::iter::successors;
 use hir::db::HirDatabase;
 use ra_syntax::{
-    TextUnit, AstNode, SyntaxKind::COLONCOLON,
+    T,
+    TextUnit, AstNode,
    ast,
 };
 use crate::{AssistCtx, Assist, AssistId};
 pub(crate) fn split_import(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
-    let colon_colon = ctx.token_at_offset().find(|leaf| leaf.kind() == COLONCOLON)?;
+    let colon_colon = ctx.token_at_offset().find(|leaf| leaf.kind() == T![::])?;
    let path = ast::Path::cast(colon_colon.parent())?;
    let top_path = successors(Some(path), |it| it.parent_path()).last()?;
diff --git a/crates/ra_cli/src/analysis_stats.rs b/crates/ra_cli/src/analysis_stats.rs
index c95d452b3..b481ace9e 100644
--- a/crates/ra_cli/src/analysis_stats.rs
+++ b/crates/ra_cli/src/analysis_stats.rs
@@ -51,7 +51,10 @@ pub fn run(verbose: bool, path: &str, only: Option<&str>) -> Result<()> {
    println!("Total modules found: {}", visited_modules.len());
    println!("Total declarations: {}", num_decls);
    println!("Total functions: {}", funcs.len());
-    let bar = indicatif::ProgressBar::new(funcs.len() as u64);
+    let bar = indicatif::ProgressBar::with_draw_target(
+        funcs.len() as u64,
+        indicatif::ProgressDrawTarget::stderr_nohz(),
+    );
    bar.set_style(
        indicatif::ProgressStyle::default_bar().template("{wide_bar} {pos}/{len}\n{msg}"),
    );
diff --git a/crates/ra_db/src/lib.rs b/crates/ra_db/src/lib.rs
index 1cd400752..bf567721a 100644
--- a/crates/ra_db/src/lib.rs
+++ b/crates/ra_db/src/lib.rs
@@ -15,7 +15,7 @@ pub use crate::{
    },
 };
-pub trait CheckCanceled: panic::RefUnwindSafe {
+pub trait CheckCanceled {
    /// Aborts current query if there are pending changes.
    ///
    /// rust-analyzer needs to be able to answer semantic questions about the
@@ -36,14 +36,15 @@ pub trait CheckCanceled: panic::RefUnwindSafe {
        Self: Sized,
        F: FnOnce(&Self) -> T + panic::UnwindSafe,
    {
-        panic::catch_unwind(|| f(self)).map_err(|err| match err.downcast::<Canceled>() {
+        let this = panic::AssertUnwindSafe(self);
+        panic::catch_unwind(|| f(*this)).map_err(|err| match err.downcast::<Canceled>() {
            Ok(canceled) => *canceled,
            Err(payload) => panic::resume_unwind(payload),
        })
    }
 }
-impl<T: salsa::Database + panic::RefUnwindSafe> CheckCanceled for T {
+impl<T: salsa::Database> CheckCanceled for T {
    fn check_canceled(&self) {
        if self.salsa_runtime().is_current_revision_canceled() {
            Canceled::throw()
diff --git a/crates/ra_fmt/src/lib.rs b/crates/ra_fmt/src/lib.rs
index 603be1854..aac5a1d23 100644
--- a/crates/ra_fmt/src/lib.rs
+++ b/crates/ra_fmt/src/lib.rs
@@ -3,7 +3,7 @@
 use std::iter::successors;
 use itertools::Itertools;
 use ra_syntax::{
-    SyntaxNode, SyntaxKind::*, SyntaxToken, SyntaxKind,
+    SyntaxNode, SyntaxKind::*, SyntaxToken, SyntaxKind, T,
    ast::{self, AstNode, AstToken},
 };
@@ -38,7 +38,7 @@ pub fn extract_trivial_expression(block: &ast::Block) -> Option<&ast::Expr> {
        return None;
    }
    let non_trivial_children = block.syntax().children().filter(|it| match it.kind() {
-        WHITESPACE | L_CURLY | R_CURLY => false,
+        WHITESPACE | T!['{'] | T!['}'] => false,
        _ => it != &expr.syntax(),
    });
    if non_trivial_children.count() > 0 {
@@ -49,8 +49,8 @@ pub fn extract_trivial_expression(block: &ast::Block) -> Option<&ast::Expr> {
 pub fn compute_ws(left: SyntaxKind, right: SyntaxKind) -> &'static str {
    match left {
-        L_PAREN | L_BRACK => return "",
+        T!['('] | T!['['] => return "",
-        L_CURLY => {
+        T!['{'] => {
            if let USE_TREE = right {
                return "";
            }
@@ -58,13 +58,13 @@ pub fn compute_ws(left: SyntaxKind, right: SyntaxKind) -> &'static str {
        _ => (),
    }
    match right {
-        R_PAREN | R_BRACK => return "",
+        T![')'] | T![']'] => return "",
-        R_CURLY => {
+        T!['}'] => {
            if let USE_TREE = left {
                return "";
            }
        }
-        DOT => return "",
+        T![.] => return "",
        _ => (),
    }
    " "
diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml
index 68ffcb2e9..294d047d8 100644
--- a/crates/ra_hir/Cargo.toml
+++ b/crates/ra_hir/Cargo.toml
@@ -21,10 +21,10 @@ tt = { path = "../ra_tt", package = "ra_tt" }
 test_utils = { path = "../test_utils" }
 ra_prof = { path = "../ra_prof" }
-chalk-solve = { git = "https://github.com/rust-lang/chalk.git" }
+chalk-solve = { git = "https://github.com/flodiebold/chalk.git", branch = "fuel" }
-chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git" }
+chalk-rust-ir = { git = "https://github.com/flodiebold/chalk.git", branch = "fuel" }
-chalk-ir = { git = "https://github.com/rust-lang/chalk.git" }
+chalk-ir = { git = "https://github.com/flodiebold/chalk.git", branch = "fuel" }
 [dev-dependencies]
 flexi_logger = "0.11.0"
-insta = "0.7.0"
+insta = "0.8.1"
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index 8e827d4f5..11cdf9c34 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -11,7 +11,7 @@ use crate::{
    DefWithBody, Trait,
    ids,
    nameres::{Namespace, ImportSourceMap, RawItems, CrateDefMap},
-    ty::{InferenceResult, Ty, method_resolution::CrateImplBlocks, TypableDef, CallableDef, FnSig, TypeCtor, GenericPredicate},
+    ty::{InferenceResult, Ty, method_resolution::CrateImplBlocks, TypableDef, CallableDef, FnSig, TypeCtor, GenericPredicate, Substs},
    adt::{StructData, EnumData},
    impl_block::{ModuleImplBlocks, ImplSourceMap, ImplBlock},
    generics::{GenericParams, GenericDef},
@@ -126,7 +126,7 @@ pub trait HirDatabase: DefDatabase {
    #[salsa::invoke(ExprScopes::expr_scopes_query)]
    fn expr_scopes(&self, def: DefWithBody) -> Arc<ExprScopes>;
-    #[salsa::invoke(crate::ty::infer)]
+    #[salsa::invoke(crate::ty::infer_query)]
    fn infer(&self, def: DefWithBody) -> Arc<InferenceResult>;
    #[salsa::invoke(crate::ty::type_for_def)]
@@ -141,6 +141,9 @@ pub trait HirDatabase: DefDatabase {
    #[salsa::invoke(crate::ty::generic_predicates)]
    fn generic_predicates(&self, def: GenericDef) -> Arc<[GenericPredicate]>;
+    #[salsa::invoke(crate::ty::generic_defaults)]
+    fn generic_defaults(&self, def: GenericDef) -> Substs;
    #[salsa::invoke(crate::expr::body_with_source_map_query)]
    fn body_with_source_map(
        &self,
@@ -153,7 +156,7 @@ pub trait HirDatabase: DefDatabase {
    #[salsa::invoke(crate::ty::method_resolution::CrateImplBlocks::impls_in_crate_query)]
    fn impls_in_crate(&self, krate: Crate) -> Arc<CrateImplBlocks>;
-    #[salsa::invoke(crate::ty::traits::impls_for_trait)]
+    #[salsa::invoke(crate::ty::traits::impls_for_trait_query)]
    fn impls_for_trait(&self, krate: Crate, trait_: Trait) -> Arc<[ImplBlock]>;
    /// This provides the Chalk trait solver instance. Because Chalk always
@@ -161,11 +164,11 @@ pub trait HirDatabase: DefDatabase {
    /// because Chalk does its own internal caching, the solver is wrapped in a
    /// Mutex and the query is marked volatile, to make sure the cached state is
    /// thrown away when input facts change.
-    #[salsa::invoke(crate::ty::traits::solver)]
+    #[salsa::invoke(crate::ty::traits::solver_query)]
    #[salsa::volatile]
    fn solver(&self, krate: Crate) -> Arc<Mutex<crate::ty::traits::Solver>>;
-    #[salsa::invoke(crate::ty::traits::implements)]
+    #[salsa::invoke(crate::ty::traits::implements_query)]
    fn implements(
        &self,
        krate: Crate,
diff --git a/crates/ra_hir/src/expr/validation.rs b/crates/ra_hir/src/expr/validation.rs
index aebed6788..3f758f283 100644
--- a/crates/ra_hir/src/expr/validation.rs
+++ b/crates/ra_hir/src/expr/validation.rs
@@ -5,13 +5,11 @@ use ra_syntax::ast::{AstNode, StructLit};
 use crate::{
    expr::AstPtr,
-    HirDatabase,
+    HirDatabase, Function, Name,
-    Function,
-    Name,
    diagnostics::{DiagnosticSink, MissingFields},
    adt::AdtDef,
    Path,
-    ty::InferenceResult
+    ty::InferenceResult,
 };
 use super::{Expr, StructLitField, ExprId};
@@ -50,43 +48,46 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        spread: &Option<ExprId>,
        db: &impl HirDatabase,
    ) {
-        if let Some(_) = spread {
+        if spread.is_some() {
            return;
        }
+        let struct_def = match self.infer[id].as_adt() {
+            Some((AdtDef::Struct(s), _)) => s,
+            _ => return,
+        };
        let lit_fields: FxHashSet<_> = fields.into_iter().map(|f| &f.name).collect();
-        let struct_ty = &self.infer[id];
+        let missed_fields: Vec<Name> = struct_def
-        if let Some((AdtDef::Struct(s), _)) = struct_ty.as_adt() {
+            .fields(db)
-            let missed_fields: Vec<Name> = s
+            .iter()
-                .fields(db)
+            .filter_map(|f| {
-                .iter()
+                let name = f.name(db);
-                .filter_map(|f| {
+                if lit_fields.contains(&name) {
-                    let name = f.name(db);
+                    None
-                    if lit_fields.contains(&name) {
+                } else {
-                        None
+                    Some(name)
-                    } else {
+                }
-                        Some(name)
+            })
-                    }
+            .collect();
-                })
+        if missed_fields.is_empty() {
-                .collect();
+            return;
-            if missed_fields.is_empty() {
+        }
-                return;
+        let source_map = self.func.body_source_map(db);
-            }
+        let file_id = self.func.source(db).0;
-            let source_map = self.func.body_source_map(db);
+        let source_file = db.parse(file_id.original_file(db));
-            let file_id = self.func.source(db).0;
+        if let Some(field_list_node) = source_map
-            let source_file = db.parse(file_id.original_file(db));
+            .expr_syntax(id)
-            if let Some(field_list_node) = source_map
+            .map(|ptr| ptr.to_node(source_file.syntax()))
-                .expr_syntax(id)
+            .and_then(StructLit::cast)
-                .map(|ptr| ptr.to_node(source_file.syntax()))
+            .and_then(|lit| lit.named_field_list())
-                .and_then(StructLit::cast)
+        {
-                .and_then(|lit| lit.named_field_list())
+            let field_list_ptr = AstPtr::new(field_list_node);
-            {
+            self.sink.push(MissingFields {
-                let field_list_ptr = AstPtr::new(field_list_node);
+                file: file_id,
-                self.sink.push(MissingFields {
+                field_list: field_list_ptr,
-                    file: file_id,
+                missed_fields,
-                    field_list: field_list_ptr,
+            })
-                    missed_fields,
-                })
-            }
        }
    }
 }
diff --git a/crates/ra_hir/src/generics.rs b/crates/ra_hir/src/generics.rs
index c29b96f50..79a7fa23a 100644
--- a/crates/ra_hir/src/generics.rs
+++ b/crates/ra_hir/src/generics.rs
@@ -5,7 +5,7 @@
 use std::sync::Arc;
-use ra_syntax::ast::{self, NameOwner, TypeParamsOwner, TypeBoundsOwner};
+use ra_syntax::ast::{self, NameOwner, TypeParamsOwner, TypeBoundsOwner, DefaultTypeParamOwner};
 use crate::{
    db::{ HirDatabase, DefDatabase},
@@ -18,6 +18,7 @@ pub struct GenericParam {
    // FIXME: give generic params proper IDs
    pub(crate) idx: u32,
    pub(crate) name: Name,
+    pub(crate) default: Option<Path>,
 }
 /// Data about the generic parameters of a function, struct, impl, etc.
@@ -68,7 +69,11 @@ impl GenericParams {
            GenericDef::Enum(it) => generics.fill(&*it.source(db).1, start),
            GenericDef::Trait(it) => {
                // traits get the Self type as an implicit first type parameter
-                generics.params.push(GenericParam { idx: start, name: Name::self_type() });
+                generics.params.push(GenericParam {
+                    idx: start,
+                    name: Name::self_type(),
+                    default: None,
+                });
                generics.fill(&*it.source(db).1, start + 1);
            }
            GenericDef::TypeAlias(it) => generics.fill(&*it.source(db).1, start),
@@ -90,7 +95,9 @@ impl GenericParams {
    fn fill_params(&mut self, params: &ast::TypeParamList, start: u32) {
        for (idx, type_param) in params.type_params().enumerate() {
            let name = type_param.name().map(AsName::as_name).unwrap_or_else(Name::missing);
-            let param = GenericParam { idx: idx as u32 + start, name: name.clone() };
+            let default = type_param.default_type().and_then(|t| t.path()).and_then(Path::from_ast);
+            let param = GenericParam { idx: idx as u32 + start, name: name.clone(), default };
            self.params.push(param);
            let type_ref = TypeRef::Path(name.into());
@@ -190,13 +197,13 @@ impl From<crate::adt::AdtDef> for GenericDef {
    }
 }
-pub trait HasGenericParams {
+pub trait HasGenericParams: Copy {
    fn generic_params(self, db: &impl DefDatabase) -> Arc<GenericParams>;
 }
 impl<T> HasGenericParams for T
 where
-    T: Into<GenericDef>,
+    T: Into<GenericDef> + Copy,
 {
    fn generic_params(self, db: &impl DefDatabase) -> Arc<GenericParams> {
        db.generic_params(self.into())
diff --git a/crates/ra_hir/src/mock.rs b/crates/ra_hir/src/mock.rs
index fa5882dea..b84cb7503 100644
--- a/crates/ra_hir/src/mock.rs
+++ b/crates/ra_hir/src/mock.rs
@@ -236,7 +236,7 @@ impl MockDatabase {
 }
 #[derive(Default)]
-pub struct CrateGraphFixture(pub FxHashMap<String, (String, Edition, Vec<String>)>);
+pub struct CrateGraphFixture(pub Vec<(String, (String, Edition, Vec<String>))>);
 #[macro_export]
 macro_rules! crate_graph {
@@ -246,10 +246,10 @@ macro_rules! crate_graph {
            #[allow(unused_mut, unused_assignments)]
            let mut edition = ra_db::Edition::Edition2018;
            $(edition = ra_db::Edition::from_string($edition);)?
-            res.0.insert(
+            res.0.push((
                $crate_name.to_string(),
                ($crate_path.to_string(), edition, vec![$($dep.to_string()),*])
-            );
+            ));
        )*
        res
    }}
diff --git a/crates/ra_hir/src/name.rs b/crates/ra_hir/src/name.rs
index 9a999e66c..e3a82cf03 100644
--- a/crates/ra_hir/src/name.rs
+++ b/crates/ra_hir/src/name.rs
@@ -5,7 +5,7 @@ use ra_syntax::{ast, SmolStr};
 /// `Name` is a wrapper around string, which is used in hir for both references
 /// and declarations. In theory, names should also carry hygiene info, but we are
 /// not there yet!
-#[derive(Clone, PartialEq, Eq, Hash)]
+#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct Name {
    text: SmolStr,
 }
diff --git a/crates/ra_hir/src/nameres/tests.rs b/crates/ra_hir/src/nameres/tests.rs
index 572bd1bf7..14c8ee50b 100644
--- a/crates/ra_hir/src/nameres/tests.rs
+++ b/crates/ra_hir/src/nameres/tests.rs
@@ -8,7 +8,11 @@ use ra_db::SourceDatabase;
 use test_utils::covers;
 use insta::assert_snapshot_matches;
-use crate::{Crate, mock::{MockDatabase, CrateGraphFixture}, nameres::Resolution};
+use crate::{
+    Crate,
+    mock::{MockDatabase, CrateGraphFixture},
+    nameres::Resolution,
+};
 use super::*;
@@ -25,12 +29,15 @@ fn compute_crate_def_map(fixture: &str, graph: Option<CrateGraphFixture>) -> Arc
 fn render_crate_def_map(map: &CrateDefMap) -> String {
    let mut buf = String::new();
    go(&mut buf, map, "\ncrate", map.root);
-    return buf;
+    return buf.trim().to_string();
    fn go(buf: &mut String, map: &CrateDefMap, path: &str, module: CrateModuleId) {
        *buf += path;
        *buf += "\n";
-        for (name, res) in map.modules[module].scope.items.iter() {
+        let mut entries = map.modules[module].scope.items.iter().collect::<Vec<_>>();
+        entries.sort_by_key(|(name, _)| *name);
+        for (name, res) in entries {
            *buf += &format!("{}: {}\n", name, dump_resolution(res))
        }
        for (name, child) in map.modules[module].children.iter() {
@@ -54,8 +61,8 @@ fn def_map(fixtute: &str) -> String {
    render_crate_def_map(&dm)
 }
-fn def_map_with_crate_graph(fixtute: &str, graph: CrateGraphFixture) -> String {
+fn def_map_with_crate_graph(fixture: &str, graph: CrateGraphFixture) -> String {
-    let dm = compute_crate_def_map(fixtute, Some(graph));
+    let dm = compute_crate_def_map(fixture, Some(graph));
    render_crate_def_map(&dm)
 }
@@ -79,21 +86,20 @@ fn crate_def_map_smoke_test() {
        ",
    );
    assert_snapshot_matches!(map, @r###"
-crate
+        ⋮crate
-V: t v
+        ⋮E: t
-E: t
+        ⋮S: t v
-foo: t
+        ⋮V: t v
-S: t v
+        ⋮foo: t
+        ⋮
-crate::foo
+        ⋮crate::foo
-bar: t
+        ⋮bar: t
-f: v
+        ⋮f: v
+        ⋮
-crate::foo::bar
+        ⋮crate::foo::bar
-Baz: t v
+        ⋮Baz: t v
-E: t
+        ⋮E: t
-"###
+    "###)
-    )
 }
 #[test]
@@ -113,12 +119,12 @@ fn bogus_paths() {
        ",
    );
    assert_snapshot_matches!(map, @r###"
-crate
+   ⋮crate
-foo: t
+   ⋮S: t v
-S: t v
+   ⋮foo: t
+   ⋮
-crate::foo
+   ⋮crate::foo
-"###
+    "###
    )
 }
@@ -137,13 +143,13 @@ fn use_as() {
    );
    assert_snapshot_matches!(map,
        @r###"
-crate
+   ⋮crate
-Foo: t v
+   ⋮Foo: t v
-foo: t
+   ⋮foo: t
+   ⋮
-crate::foo
+   ⋮crate::foo
-Baz: t v
+   ⋮Baz: t v
-"###
+    "###
    );
 }
@@ -164,21 +170,19 @@ fn use_trees() {
        pub enum Quux {};
        ",
    );
-    assert_snapshot_matches!(map,
+    assert_snapshot_matches!(map, @r###"
-        @r###"
+        ⋮crate
-crate
+        ⋮Baz: t v
-Quux: t
+        ⋮Quux: t
-Baz: t v
+        ⋮foo: t
-foo: t
+        ⋮
+        ⋮crate::foo
-crate::foo
+        ⋮bar: t
-bar: t
+        ⋮
+        ⋮crate::foo::bar
-crate::foo::bar
+        ⋮Baz: t v
-Quux: t
+        ⋮Quux: t
-Baz: t v
+    "###);
-"###
-    );
 }
 #[test]
@@ -199,20 +203,18 @@ fn re_exports() {
        pub struct Baz;
        ",
    );
-    assert_snapshot_matches!(map,
+    assert_snapshot_matches!(map, @r###"
-        @r###"
+        ⋮crate
-crate
+        ⋮Baz: t v
-Baz: t v
+        ⋮foo: t
-foo: t
+        ⋮
+        ⋮crate::foo
-crate::foo
+        ⋮Baz: t v
-bar: t
+        ⋮bar: t
-Baz: t v
+        ⋮
+        ⋮crate::foo::bar
-crate::foo::bar
+        ⋮Baz: t v
-Baz: t v
+    "###);
-"###
-    );
 }
 #[test]
@@ -237,10 +239,10 @@ fn std_prelude() {
        },
    );
    assert_snapshot_matches!(map, @r###"
-crate
+        ⋮crate
-Bar: t v
+        ⋮Bar: t v
-Baz: t v
+        ⋮Baz: t v
-"###);
+    "###);
 }
 #[test]
@@ -254,10 +256,10 @@ fn can_import_enum_variant() {
        ",
    );
    assert_snapshot_matches!(map, @r###"
-crate
+        ⋮crate
-V: t v
+        ⋮E: t
-E: t
+        ⋮V: t v
-"###
+    "###
    );
 }
@@ -285,20 +287,18 @@ fn edition_2015_imports() {
        },
    );
-    assert_snapshot_matches!(map,
+    assert_snapshot_matches!(map, @r###"
-        @r###"
+        ⋮crate
-crate
+        ⋮bar: t
-bar: t
+        ⋮foo: t
-foo: t
+        ⋮
+        ⋮crate::bar
-crate::bar
+        ⋮Bar: t v
-Bar: t v
+        ⋮
+        ⋮crate::foo
-crate::foo
+        ⋮Bar: t v
-FromLib: t v
+        ⋮FromLib: t v
-Bar: t v
+    "###);
-"###
-    );
 }
 #[test]
@@ -317,16 +317,14 @@ fn module_resolution_works_for_non_standard_filenames() {
        },
    );
-    assert_snapshot_matches!(map,
+    assert_snapshot_matches!(map, @r###"
-        @r###"
+        ⋮crate
-crate
+        ⋮Bar: t v
-Bar: t v
+        ⋮foo: t
-foo: t
+        ⋮
+        ⋮crate::foo
-crate::foo
+        ⋮Bar: t v
-Bar: t v
+    "###);
-"###
-    );
 }
 #[test]
@@ -348,12 +346,10 @@ fn name_res_works_for_broken_modules() {
        pub struct Baz;
        ",
    );
-    assert_snapshot_matches!(map,
+    assert_snapshot_matches!(map, @r###"
-        @r###"
+        ⋮crate
-crate
+        ⋮Baz: _
-Baz: _
+    "###);
-"###
-    );
 }
 #[test]
@@ -369,19 +365,17 @@ fn item_map_using_self() {
        pub struct Baz;
        ",
    );
-    assert_snapshot_matches!(map,
+    assert_snapshot_matches!(map, @r###"
-        @r###"
+        ⋮crate
-crate
+        ⋮Baz: t v
-Baz: t v
+        ⋮foo: t
-foo: t
+        ⋮
+        ⋮crate::foo
-crate::foo
+        ⋮bar: t
-bar: t
+        ⋮
+        ⋮crate::foo::bar
-crate::foo::bar
+        ⋮Baz: t v
-Baz: t v
+    "###);
-"###
-    );
 }
 #[test]
@@ -400,12 +394,10 @@ fn item_map_across_crates() {
        },
    );
-    assert_snapshot_matches!(map,
+    assert_snapshot_matches!(map, @r###"
-        @r###"
+        ⋮crate
-crate
+        ⋮Baz: t v
-Baz: t v
+    "###);
-"###
-    );
 }
 #[test]
@@ -430,12 +422,14 @@ fn extern_crate_rename() {
        },
    );
-    assert_snapshot_matches!(map,
+    assert_snapshot_matches!(map, @r###"
-        @r###"
+   ⋮crate
-crate
+   ⋮alloc_crate: t
-Arc: t v
+   ⋮sync: t
-"###
+   ⋮
-    );
+   ⋮crate::sync
+   ⋮Arc: t v
+    "###);
 }
 #[test]
@@ -462,9 +456,13 @@ fn extern_crate_rename_2015_edition() {
    assert_snapshot_matches!(map,
        @r###"
-crate
+   ⋮crate
-Arc: t v
+   ⋮alloc_crate: t
-"###
+   ⋮sync: t
+   ⋮
+   ⋮crate::sync
+   ⋮Arc: t v
+    "###
    );
 }
@@ -490,12 +488,10 @@ fn import_across_source_roots() {
        },
    );
-    assert_snapshot_matches!(map,
+    assert_snapshot_matches!(map, @r###"
-        @r###"
+        ⋮crate
-crate
+        ⋮C: t v
-C: t v
+    "###);
-"###
-    );
 }
 #[test]
@@ -519,12 +515,10 @@ fn reexport_across_crates() {
        },
    );
-    assert_snapshot_matches!(map,
+    assert_snapshot_matches!(map, @r###"
-        @r###"
+        ⋮crate
-crate
+        ⋮Baz: t v
-Baz: t v
+    "###);
-"###
-    );
 }
 #[test]
@@ -544,13 +538,11 @@ fn values_dont_shadow_extern_crates() {
        },
    );
-    assert_snapshot_matches!(map,
+    assert_snapshot_matches!(map, @r###"
-        @r###"
+        ⋮crate
-crate
+        ⋮Bar: t v
-Bar: t v
+        ⋮foo: v
-foo: v
+    "###);
-"###
-    );
 }
 #[test]
diff --git a/crates/ra_hir/src/nameres/tests/globs.rs b/crates/ra_hir/src/nameres/tests/globs.rs
index 6e50c7ff6..e1519ca6b 100644
--- a/crates/ra_hir/src/nameres/tests/globs.rs
+++ b/crates/ra_hir/src/nameres/tests/globs.rs
@@ -18,20 +18,20 @@ fn glob_1() {
        ",
    );
    assert_snapshot_matches!(map, @r###"
-crate
+   ⋮crate
-bar: t
+   ⋮Baz: t v
-Foo: t v
+   ⋮Foo: t v
-Baz: t v
+   ⋮bar: t
-foo: t
+   ⋮foo: t
+   ⋮
-crate::foo
+   ⋮crate::foo
-bar: t
+   ⋮Baz: t v
-Foo: t v
+   ⋮Foo: t v
-Baz: t v
+   ⋮bar: t
+   ⋮
-crate::foo::bar
+   ⋮crate::foo::bar
-Baz: t v
+   ⋮Baz: t v
-"###
+    "###
    );
 }
@@ -54,22 +54,22 @@ fn glob_2() {
        ",
    );
    assert_snapshot_matches!(map, @r###"
-crate
+   ⋮crate
-bar: t
+   ⋮Baz: t v
-Foo: t v
+   ⋮Foo: t v
-Baz: t v
+   ⋮bar: t
-foo: t
+   ⋮foo: t
+   ⋮
-crate::foo
+   ⋮crate::foo
-bar: t
+   ⋮Baz: t v
-Foo: t v
+   ⋮Foo: t v
-Baz: t v
+   ⋮bar: t
+   ⋮
-crate::foo::bar
+   ⋮crate::foo::bar
-bar: t
+   ⋮Baz: t v
-Foo: t v
+   ⋮Foo: t v
-Baz: t v
+   ⋮bar: t
-"###
+    "###
    );
 }
@@ -90,9 +90,9 @@ fn glob_across_crates() {
        },
    );
    assert_snapshot_matches!(map, @r###"
-crate
+   ⋮crate
-Baz: t v
+   ⋮Baz: t v
-"###
+    "###
    );
 }
@@ -109,10 +109,10 @@ fn glob_enum() {
        ",
    );
    assert_snapshot_matches!(map, @r###"
-crate
+   ⋮crate
-Foo: t
+   ⋮Bar: t v
-Bar: t v
+   ⋮Baz: t v
-Baz: t v
+   ⋮Foo: t
-"###
+    "###
    );
 }
diff --git a/crates/ra_hir/src/nameres/tests/macros.rs b/crates/ra_hir/src/nameres/tests/macros.rs
index 8781b026b..f7ca380ad 100644
--- a/crates/ra_hir/src/nameres/tests/macros.rs
+++ b/crates/ra_hir/src/nameres/tests/macros.rs
@@ -18,14 +18,14 @@ fn macro_rules_are_globally_visible() {
        ",
    );
    assert_snapshot_matches!(map, @r###"
-crate
+   ⋮crate
-nested: t
+   ⋮Foo: t v
-Foo: t v
+   ⋮nested: t
+   ⋮
-crate::nested
+   ⋮crate::nested
-Bar: t v
+   ⋮Bar: t v
-Baz: t v
+   ⋮Baz: t v
-"###);
+    "###);
 }
 #[test]
@@ -45,15 +45,15 @@ fn macro_rules_can_define_modules() {
        ",
    );
    assert_snapshot_matches!(map, @r###"
-crate
+   ⋮crate
-n1: t
+   ⋮n1: t
+   ⋮
-crate::n1
+   ⋮crate::n1
-n2: t
+   ⋮n2: t
+   ⋮
-crate::n1::n2
+   ⋮crate::n1::n2
-X: t v
+   ⋮X: t v
-"###);
+    "###);
 }
 #[test]
@@ -81,14 +81,14 @@ fn macro_rules_from_other_crates_are_visible() {
        },
    );
    assert_snapshot_matches!(map, @r###"
-crate
+   ⋮crate
-bar: t
+   ⋮Bar: t v
-Foo: t v
+   ⋮Foo: t v
-Bar: t v
+   ⋮bar: t
+   ⋮
-crate::bar
+   ⋮crate::bar
-bar: t
+   ⋮Bar: t v
-Foo: t v
+   ⋮Foo: t v
-Bar: t v
+   ⋮bar: t
-"###);
+    "###);
 }
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index cfe07156b..3679a2242 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -19,8 +19,8 @@ use std::{fmt, mem};
 use crate::{Name, AdtDef, type_ref::Mutability, db::HirDatabase, Trait, GenericParams};
 use display::{HirDisplay, HirFormatter};
-pub(crate) use lower::{TypableDef, type_for_def, type_for_field, callable_item_sig, generic_predicates};
+pub(crate) use lower::{TypableDef, type_for_def, type_for_field, callable_item_sig, generic_predicates, generic_defaults};
-pub(crate) use infer::{infer, InferenceResult, InferTy};
+pub(crate) use infer::{infer_query, InferenceResult, InferTy};
 pub use lower::CallableDef;
 /// A type constructor or type name: this might be something like the primitive
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 1e7d97f51..a48272981 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -23,6 +23,7 @@ use ena::unify::{InPlaceUnificationTable, UnifyKey, UnifyValue, NoError};
 use rustc_hash::FxHashMap;
 use ra_arena::map::ArenaMap;
+use ra_prof::profile;
 use test_utils::tested_by;
 use crate::{
@@ -51,7 +52,8 @@ use super::{
 mod unify;
 /// The entry point of type inference.
-pub fn infer(db: &impl HirDatabase, def: DefWithBody) -> Arc<InferenceResult> {
+pub fn infer_query(db: &impl HirDatabase, def: DefWithBody) -> Arc<InferenceResult> {
+    let _p = profile("infer_query");
    db.check_canceled();
    let body = def.body(db);
    let resolver = def.resolver(db);
diff --git a/crates/ra_hir/src/ty/infer/unify.rs b/crates/ra_hir/src/ty/infer/unify.rs
index 8ca7e957d..bc9719725 100644
--- a/crates/ra_hir/src/ty/infer/unify.rs
+++ b/crates/ra_hir/src/ty/infer/unify.rs
@@ -56,7 +56,12 @@ where
                    self.var_stack.pop();
                    result
                } else {
-                    let free_var = InferTy::TypeVar(self.ctx.var_unification_table.find(inner));
+                    let root = self.ctx.var_unification_table.find(inner);
+                    let free_var = match tv {
+                        InferTy::TypeVar(_) => InferTy::TypeVar(root),
+                        InferTy::IntVar(_) => InferTy::IntVar(root),
+                        InferTy::FloatVar(_) => InferTy::FloatVar(root),
+                    };
                    let position = self.add(free_var);
                    Ty::Bound(position as u32)
                }
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index 09d26ce5a..a1a2d0f6b 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -9,17 +9,18 @@ use std::sync::Arc;
 use std::iter;
 use crate::{
-    Function, Struct, StructField, Enum, EnumVariant, Path,
+    Function, Struct, StructField, Enum, EnumVariant, Path, ModuleDef, TypeAlias, Const, Static,
-    ModuleDef, TypeAlias,
-    Const, Static,
    HirDatabase,
    type_ref::TypeRef,
    name::KnownName,
    nameres::Namespace,
    resolve::{Resolver, Resolution},
    path::{PathSegment, GenericArg},
-    generics::{GenericParams, HasGenericParams},
+    generics::{HasGenericParams},
-    adt::VariantDef, Trait, generics::{ WherePredicate, GenericDef}
+    adt::VariantDef,
+    Trait,
+    generics::{WherePredicate, GenericDef},
+    ty::AdtDef,
 };
 use super::{Ty, primitive, FnSig, Substs, TypeCtor, TraitRef, GenericPredicate};
@@ -120,15 +121,15 @@ impl Ty {
        segment: &PathSegment,
        resolved: TypableDef,
    ) -> Substs {
-        let def_generics = match resolved {
+        let def_generic: Option<GenericDef> = match resolved {
-            TypableDef::Function(func) => func.generic_params(db),
+            TypableDef::Function(func) => Some(func.into()),
-            TypableDef::Struct(s) => s.generic_params(db),
+            TypableDef::Struct(s) => Some(s.into()),
-            TypableDef::Enum(e) => e.generic_params(db),
+            TypableDef::Enum(e) => Some(e.into()),
-            TypableDef::EnumVariant(var) => var.parent_enum(db).generic_params(db),
+            TypableDef::EnumVariant(var) => Some(var.parent_enum(db).into()),
-            TypableDef::TypeAlias(t) => t.generic_params(db),
+            TypableDef::TypeAlias(t) => Some(t.into()),
-            TypableDef::Const(_) | TypableDef::Static(_) => GenericParams::default().into(),
+            TypableDef::Const(_) | TypableDef::Static(_) => None,
        };
-        substs_from_path_segment(db, resolver, segment, &def_generics, false)
+        substs_from_path_segment(db, resolver, segment, def_generic, false)
    }
    /// Collect generic arguments from a path into a `Substs`. See also
@@ -172,10 +173,12 @@ pub(super) fn substs_from_path_segment(
    db: &impl HirDatabase,
    resolver: &Resolver,
    segment: &PathSegment,
-    def_generics: &GenericParams,
+    def_generic: Option<GenericDef>,
    add_self_param: bool,
 ) -> Substs {
    let mut substs = Vec::new();
+    let def_generics = def_generic.map(|def| def.generic_params(db)).unwrap_or_default();
    let parent_param_count = def_generics.count_parent_params();
    substs.extend(iter::repeat(Ty::Unknown).take(parent_param_count));
    if add_self_param {
@@ -199,12 +202,24 @@ pub(super) fn substs_from_path_segment(
        }
    }
    // add placeholders for args that were not provided
-    // FIXME: handle defaults
    let supplied_params = substs.len();
    for _ in supplied_params..def_generics.count_params_including_parent() {
        substs.push(Ty::Unknown);
    }
    assert_eq!(substs.len(), def_generics.count_params_including_parent());
+    // handle defaults
+    if let Some(def_generic) = def_generic {
+        let default_substs = db.generic_defaults(def_generic);
+        assert_eq!(substs.len(), default_substs.len());
+        for (i, default_ty) in default_substs.iter().enumerate() {
+            if substs[i] == Ty::Unknown {
+                substs[i] = default_ty.clone();
+            }
+        }
+    }
    Substs(substs.into())
 }
@@ -249,7 +264,7 @@ impl TraitRef {
        resolved: Trait,
    ) -> Substs {
        let segment = path.segments.last().expect("path should have at least one segment");
-        substs_from_path_segment(db, resolver, segment, &resolved.generic_params(db), true)
+        substs_from_path_segment(db, resolver, segment, Some(resolved.into()), true)
    }
    pub(crate) fn for_trait(db: &impl HirDatabase, trait_: Trait) -> TraitRef {
@@ -274,9 +289,9 @@ impl TraitRef {
 pub(crate) fn type_for_def(db: &impl HirDatabase, def: TypableDef, ns: Namespace) -> Ty {
    match (def, ns) {
        (TypableDef::Function(f), Namespace::Values) => type_for_fn(db, f),
-        (TypableDef::Struct(s), Namespace::Types) => type_for_struct(db, s),
+        (TypableDef::Struct(s), Namespace::Types) => type_for_adt(db, s),
        (TypableDef::Struct(s), Namespace::Values) => type_for_struct_constructor(db, s),
-        (TypableDef::Enum(e), Namespace::Types) => type_for_enum(db, e),
+        (TypableDef::Enum(e), Namespace::Types) => type_for_adt(db, e),
        (TypableDef::EnumVariant(v), Namespace::Values) => type_for_enum_variant_constructor(db, v),
        (TypableDef::TypeAlias(t), Namespace::Types) => type_for_type_alias(db, t),
        (TypableDef::Const(c), Namespace::Values) => type_for_const(db, c),
@@ -331,6 +346,22 @@ pub(crate) fn generic_predicates(
    predicates.into()
 }
+/// Resolve the default type params from generics
+pub(crate) fn generic_defaults(db: &impl HirDatabase, def: GenericDef) -> Substs {
+    let resolver = def.resolver(db);
+    let generic_params = def.generic_params(db);
+    let defaults = generic_params
+        .params_including_parent()
+        .into_iter()
+        .map(|p| {
+            p.default.as_ref().map_or(Ty::Unknown, |path| Ty::from_hir_path(db, &resolver, path))
+        })
+        .collect::<Vec<_>>();
+    Substs(defaults.into())
+}
 fn fn_sig_for_fn(db: &impl HirDatabase, def: Function) -> FnSig {
    let signature = def.signature(db);
    let resolver = def.resolver(db);
@@ -375,7 +406,7 @@ fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> FnSig {
        .iter()
        .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref))
        .collect::<Vec<_>>();
-    let ret = type_for_struct(db, def);
+    let ret = type_for_adt(db, def);
    FnSig::from_params_and_return(params, ret)
 }
@@ -383,7 +414,7 @@ fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> FnSig {
 fn type_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> Ty {
    let var_data = def.variant_data(db);
    if var_data.fields().is_none() {
-        return type_for_struct(db, def); // Unit struct
+        return type_for_adt(db, def); // Unit struct
    }
    let generics = def.generic_params(db);
    let substs = Substs::identity(&generics);
@@ -403,7 +434,7 @@ fn fn_sig_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant)
        .collect::<Vec<_>>();
    let generics = def.parent_enum(db).generic_params(db);
    let substs = Substs::identity(&generics);
-    let ret = type_for_enum(db, def.parent_enum(db)).subst(&substs);
+    let ret = type_for_adt(db, def.parent_enum(db)).subst(&substs);
    FnSig::from_params_and_return(params, ret)
 }
@@ -411,21 +442,16 @@ fn fn_sig_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant)
 fn type_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) -> Ty {
    let var_data = def.variant_data(db);
    if var_data.fields().is_none() {
-        return type_for_enum(db, def.parent_enum(db)); // Unit variant
+        return type_for_adt(db, def.parent_enum(db)); // Unit variant
    }
    let generics = def.parent_enum(db).generic_params(db);
    let substs = Substs::identity(&generics);
    Ty::apply(TypeCtor::FnDef(def.into()), substs)
 }
-fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Ty {
+fn type_for_adt(db: &impl HirDatabase, adt: impl Into<AdtDef> + HasGenericParams) -> Ty {
-    let generics = s.generic_params(db);
+    let generics = adt.generic_params(db);
-    Ty::apply(TypeCtor::Adt(s.into()), Substs::identity(&generics))
+    Ty::apply(TypeCtor::Adt(adt.into()), Substs::identity(&generics))
-}
-fn type_for_enum(db: &impl HirDatabase, s: Enum) -> Ty {
-    let generics = s.generic_params(db);
-    Ty::apply(TypeCtor::Adt(s.into()), Substs::identity(&generics))
 }
 fn type_for_type_alias(db: &impl HirDatabase, t: TypeAlias) -> Ty {
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index f8364203d..cd24faba5 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -1449,6 +1449,35 @@ fn test() {
 }
 #[test]
+fn infer_associated_method_generics_with_default_param() {
+    assert_snapshot_matches!(
+        infer(r#"
+struct Gen<T=u32> {
+    val: T
+}
+impl<T> Gen<T> {
+    pub fn make() -> Gen<T> {
+        loop { }
+    }
+}
+fn test() {
+    let a = Gen::make();
+}
+"#),
+        @r###"
+[80; 104) '{     ...     }': !
+[90; 98) 'loop { }': !
+[95; 98) '{ }': ()
+[118; 146) '{     ...e(); }': ()
+[128; 129) 'a': Gen<u32>
+[132; 141) 'Gen::make': fn make<u32>() -> Gen<T>
+[132; 143) 'Gen::make()': Gen<u32>"###
+    );
+}
+#[test]
 fn infer_associated_method_generics_without_args() {
    assert_snapshot_matches!(
        infer(r#"
diff --git a/crates/ra_hir/src/ty/traits.rs b/crates/ra_hir/src/ty/traits.rs
index 7de04c044..e6c78c0d4 100644
--- a/crates/ra_hir/src/ty/traits.rs
+++ b/crates/ra_hir/src/ty/traits.rs
@@ -4,6 +4,7 @@ use std::sync::{Arc, Mutex};
 use rustc_hash::FxHashSet;
 use log::debug;
 use chalk_ir::cast::Cast;
+use ra_prof::profile;
 use crate::{Crate, Trait, db::HirDatabase, ImplBlock};
 use super::{TraitRef, Ty, Canonical};
@@ -25,7 +26,7 @@ struct ChalkContext<'a, DB> {
    krate: Crate,
 }
-pub(crate) fn solver(_db: &impl HirDatabase, _krate: Crate) -> Arc<Mutex<Solver>> {
+pub(crate) fn solver_query(_db: &impl HirDatabase, _krate: Crate) -> Arc<Mutex<Solver>> {
    // krate parameter is just so we cache a unique solver per crate
    let solver_choice = chalk_solve::SolverChoice::SLG { max_size: CHALK_SOLVER_MAX_SIZE };
    debug!("Creating new solver for crate {:?}", _krate);
@@ -33,7 +34,7 @@ pub(crate) fn solver(_db: &impl HirDatabase, _krate: Crate) -> Arc<Mutex<Solver>
 }
 /// Collects impls for the given trait in the whole dependency tree of `krate`.
-pub(crate) fn impls_for_trait(
+pub(crate) fn impls_for_trait_query(
    db: &impl HirDatabase,
    krate: Crate,
    trait_: Trait,
@@ -60,7 +61,7 @@ fn solve(
    let context = ChalkContext { db, krate };
    let solver = db.solver(krate);
    debug!("solve goal: {:?}", goal);
-    let solution = solver.lock().unwrap().solve(&context, goal);
+    let solution = solver.lock().unwrap().solve_with_fuel(&context, goal, Some(1000));
    debug!("solve({:?}) => {:?}", goal, solution);
    solution
 }
@@ -76,11 +77,12 @@ pub enum Obligation {
 }
 /// Check using Chalk whether trait is implemented for given parameters including `Self` type.
-pub(crate) fn implements(
+pub(crate) fn implements_query(
    db: &impl HirDatabase,
    krate: Crate,
    trait_ref: Canonical<TraitRef>,
 ) -> Option<Solution> {
+    let _p = profile("implements_query");
    let goal: chalk_ir::Goal = trait_ref.value.to_chalk(db).cast();
    debug!("goal: {:?}", goal);
    let env = chalk_ir::Environment::new();
diff --git a/crates/ra_ide_api/Cargo.toml b/crates/ra_ide_api/Cargo.toml
index 333706c1a..d399d5e2e 100644
--- a/crates/ra_ide_api/Cargo.toml
+++ b/crates/ra_ide_api/Cargo.toml
@@ -29,7 +29,7 @@ test_utils = { path = "../test_utils" }
 ra_assists = { path = "../ra_assists" }
 [dev-dependencies]
-insta = "0.7.0"
+insta = "0.8.1"
 [dev-dependencies.proptest]
 version = "0.9.0"
diff --git a/crates/ra_ide_api/src/diagnostics.rs b/crates/ra_ide_api/src/diagnostics.rs
index e23d178b0..9a0eb2c14 100644
--- a/crates/ra_ide_api/src/diagnostics.rs
+++ b/crates/ra_ide_api/src/diagnostics.rs
@@ -4,7 +4,7 @@ use itertools::Itertools;
 use hir::{source_binder, diagnostics::{Diagnostic as _, DiagnosticSink}};
 use ra_db::SourceDatabase;
 use ra_syntax::{
-    Location, SourceFile, SyntaxKind, TextRange, SyntaxNode,
+    T, Location, SourceFile, TextRange, SyntaxNode,
    ast::{self, AstNode, NamedFieldList, NamedField},
 };
 use ra_assists::ast_editor::{AstEditor, AstBuilder};
@@ -130,9 +130,7 @@ fn text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(
    single_use_tree: &ast::UseTree,
 ) -> Option<TextEdit> {
    let use_tree_list_node = single_use_tree.syntax().parent()?;
-    if single_use_tree.path()?.segment()?.syntax().first_child_or_token()?.kind()
+    if single_use_tree.path()?.segment()?.syntax().first_child_or_token()?.kind() == T![self] {
-        == SyntaxKind::SELF_KW
-    {
        let start = use_tree_list_node.prev_sibling_or_token()?.range().start();
        let end = use_tree_list_node.range().end();
        let range = TextRange::from_to(start, end);
diff --git a/crates/ra_ide_api/src/extend_selection.rs b/crates/ra_ide_api/src/extend_selection.rs
index 163fa8c3c..4553faad0 100644
--- a/crates/ra_ide_api/src/extend_selection.rs
+++ b/crates/ra_ide_api/src/extend_selection.rs
@@ -157,7 +157,7 @@ fn extend_list_item(node: &SyntaxNode) -> Option<TextRange> {
            })
            .next()
            .and_then(|it| it.as_token())
-            .filter(|node| node.kind() == COMMA)
+            .filter(|node| node.kind() == T![,])
    }
    if let Some(comma_node) = nearby_comma(node, Direction::Prev) {
diff --git a/crates/ra_ide_api/src/join_lines.rs b/crates/ra_ide_api/src/join_lines.rs
index 598717311..4ca005466 100644
--- a/crates/ra_ide_api/src/join_lines.rs
+++ b/crates/ra_ide_api/src/join_lines.rs
@@ -1,7 +1,8 @@
 use itertools::Itertools;
 use ra_syntax::{
+    T,
    SourceFile, TextRange, TextUnit, SyntaxNode, SyntaxElement, SyntaxToken,
-    SyntaxKind::{self, WHITESPACE, COMMA, R_CURLY, R_PAREN, R_BRACK},
+    SyntaxKind::{self, WHITESPACE},
    algo::{find_covering_element, non_trivia_sibling},
    ast::{self, AstNode, AstToken},
    Direction,
@@ -89,7 +90,7 @@ fn remove_newline(edit: &mut TextEditBuilder, token: SyntaxToken, offset: TextUn
    if is_trailing_comma(prev.kind(), next.kind()) {
        // Removes: trailing comma, newline (incl. surrounding whitespace)
        edit.delete(TextRange::from_to(prev.range().start(), token.range().end()));
-    } else if prev.kind() == COMMA && next.kind() == R_CURLY {
+    } else if prev.kind() == T![,] && next.kind() == T!['}'] {
        // Removes: comma, newline (incl. surrounding whitespace)
        let space = if let Some(left) = prev.prev_sibling_or_token() {
            compute_ws(left.kind(), next.kind())
@@ -116,7 +117,7 @@ fn remove_newline(edit: &mut TextEditBuilder, token: SyntaxToken, offset: TextUn
 fn has_comma_after(node: &SyntaxNode) -> bool {
    match non_trivia_sibling(node.into(), Direction::Next) {
-        Some(n) => n.kind() == COMMA,
+        Some(n) => n.kind() == T![,],
        _ => false,
    }
 }
@@ -150,7 +151,7 @@ fn join_single_use_tree(edit: &mut TextEditBuilder, token: SyntaxToken) -> Optio
 fn is_trailing_comma(left: SyntaxKind, right: SyntaxKind) -> bool {
    match (left, right) {
-        (COMMA, R_PAREN) | (COMMA, R_BRACK) => true,
+        (T![,], T![')']) | (T![,], T![']']) => true,
        _ => false,
    }
 }
diff --git a/crates/ra_ide_api/src/matching_brace.rs b/crates/ra_ide_api/src/matching_brace.rs
index bebd16a69..eaa4b620c 100644
--- a/crates/ra_ide_api/src/matching_brace.rs
+++ b/crates/ra_ide_api/src/matching_brace.rs
@@ -1,13 +1,14 @@
 use ra_syntax::{
    SourceFile, TextUnit,
    algo::find_token_at_offset,
-    SyntaxKind::{self, *},
+    SyntaxKind::{self},
    ast::AstNode,
+    T
 };
 pub fn matching_brace(file: &SourceFile, offset: TextUnit) -> Option<TextUnit> {
    const BRACES: &[SyntaxKind] =
-        &[L_CURLY, R_CURLY, L_BRACK, R_BRACK, L_PAREN, R_PAREN, L_ANGLE, R_ANGLE];
+        &[T!['{'], T!['}'], T!['['], T![']'], T!['('], T![')'], T![<], T![>]];
    let (brace_node, brace_idx) = find_token_at_offset(file.syntax(), offset)
        .filter_map(|node| {
            let idx = BRACES.iter().position(|&brace| brace == node.kind())?;
diff --git a/crates/ra_ide_api/src/syntax_highlighting.rs b/crates/ra_ide_api/src/syntax_highlighting.rs
index d9a28d2b5..2158291dc 100644
--- a/crates/ra_ide_api/src/syntax_highlighting.rs
+++ b/crates/ra_ide_api/src/syntax_highlighting.rs
@@ -1,6 +1,6 @@
 use rustc_hash::FxHashSet;
-use ra_syntax::{ast, AstNode, TextRange, Direction, SyntaxKind::*, SyntaxElement};
+use ra_syntax::{ast, AstNode, TextRange, Direction, SyntaxKind, SyntaxKind::*, SyntaxElement, T};
 use ra_db::SourceDatabase;
 use crate::{FileId, db::RootDatabase};
@@ -11,6 +11,21 @@ pub struct HighlightedRange {
    pub tag: &'static str,
 }
+fn is_control_keyword(kind: SyntaxKind) -> bool {
+    match kind {
+        T![for]
+        | T![loop]
+        | T![while]
+        | T![continue]
+        | T![break]
+        | T![if]
+        | T![else]
+        | T![match]
+        | T![return] => true,
+        _ => false,
+    }
+}
 pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRange> {
    let source_file = db.parse(file_id);
@@ -29,6 +44,8 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
            NAME => "function",
            INT_NUMBER | FLOAT_NUMBER | CHAR | BYTE => "literal",
            LIFETIME => "parameter",
+            T![unsafe] => "keyword.unsafe",
+            k if is_control_keyword(k) => "keyword.control",
            k if k.is_keyword() => "keyword",
            _ => {
                if let Some(macro_call) = node.as_node().and_then(ast::MacroCall::cast) {
@@ -40,7 +57,7 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
                                let mut range_end = name_ref.syntax().range().end();
                                for sibling in path.syntax().siblings_with_tokens(Direction::Next) {
                                    match sibling.kind() {
-                                        EXCL | IDENT => range_end = sibling.range().end(),
+                                        T![!] | IDENT => range_end = sibling.range().end(),
                                        _ => (),
                                    }
                                }
diff --git a/crates/ra_mbe/src/mbe_expander.rs b/crates/ra_mbe/src/mbe_expander.rs
index 3a4dbb5f5..7fff8deff 100644
--- a/crates/ra_mbe/src/mbe_expander.rs
+++ b/crates/ra_mbe/src/mbe_expander.rs
@@ -281,7 +281,11 @@ fn match_lhs(pattern: &crate::Subtree, input: &mut TtCursor) -> Result<Bindings,
                        return Err(ExpandError::UnexpectedToken);
                    }
                }
-                _ => return Err(ExpandError::UnexpectedToken),
+                crate::Leaf::Literal(literal) => {
+                    if input.eat_literal().map(|i| &i.text) != Some(&literal.text) {
+                        return Err(ExpandError::UnexpectedToken);
+                    }
+                }
            },
            crate::TokenTree::Repeat(crate::Repeat { subtree, kind, separator }) => {
                // Dirty hack to make macro-expansion terminate.
diff --git a/crates/ra_mbe/src/subtree_source.rs b/crates/ra_mbe/src/subtree_source.rs
index 3554dc110..c938acf64 100644
--- a/crates/ra_mbe/src/subtree_source.rs
+++ b/crates/ra_mbe/src/subtree_source.rs
@@ -1,5 +1,5 @@
 use ra_parser::{TokenSource};
-use ra_syntax::{classify_literal, SmolStr, SyntaxKind, SyntaxKind::*};
+use ra_syntax::{classify_literal, SmolStr, SyntaxKind, SyntaxKind::*, T};
 use std::cell::{RefCell};
 // A Sequece of Token,
@@ -284,9 +284,9 @@ impl<'a> TokenSource for SubtreeTokenSource<'a> {
 fn convert_delim(d: tt::Delimiter, closing: bool) -> TtToken {
    let (kinds, texts) = match d {
-        tt::Delimiter::Parenthesis => ([L_PAREN, R_PAREN], "()"),
+        tt::Delimiter::Parenthesis => ([T!['('], T![')']], "()"),
-        tt::Delimiter::Brace => ([L_CURLY, R_CURLY], "{}"),
+        tt::Delimiter::Brace => ([T!['{'], T!['}']], "{}"),
-        tt::Delimiter::Bracket => ([L_BRACK, R_BRACK], "[]"),
+        tt::Delimiter::Bracket => ([T!['['], T![']']], "[]"),
        tt::Delimiter::None => ([L_DOLLAR, R_DOLLAR], ""),
    };
@@ -299,8 +299,8 @@ fn convert_delim(d: tt::Delimiter, closing: bool) -> TtToken {
 fn convert_literal(l: &tt::Literal) -> TtToken {
    let kind =
        classify_literal(&l.text).map(|tkn| tkn.kind).unwrap_or_else(|| match l.text.as_ref() {
-            "true" => SyntaxKind::TRUE_KW,
+            "true" => T![true],
-            "false" => SyntaxKind::FALSE_KW,
+            "false" => T![false],
            _ => panic!("Fail to convert given literal {:#?}", &l),
        });
@@ -320,11 +320,11 @@ fn convert_ident(ident: &tt::Ident) -> TtToken {
 fn convert_punct(p: &tt::Punct) -> TtToken {
    let kind = match p.char {
        // lexer may produce compound tokens for these ones
-        '.' => DOT,
+        '.' => T![.],
-        ':' => COLON,
+        ':' => T![:],
-        '=' => EQ,
+        '=' => T![=],
-        '!' => EXCL,
+        '!' => T![!],
-        '-' => MINUS,
+        '-' => T![-],
        c => SyntaxKind::from_char(c).unwrap(),
    };
    let text = {
diff --git a/crates/ra_mbe/src/syntax_bridge.rs b/crates/ra_mbe/src/syntax_bridge.rs
index 5e6a6f2a1..d8e344557 100644
--- a/crates/ra_mbe/src/syntax_bridge.rs
+++ b/crates/ra_mbe/src/syntax_bridge.rs
@@ -1,7 +1,7 @@
 use ra_parser::{TreeSink, ParseError};
 use ra_syntax::{
    AstNode, SyntaxNode, TextRange, SyntaxKind, SmolStr, SyntaxTreeBuilder, TreeArc, SyntaxElement,
-    ast, SyntaxKind::*, TextUnit
+    ast, SyntaxKind::*, TextUnit, T
 };
 use crate::subtree_source::{SubtreeTokenSource, Querier};
@@ -211,9 +211,9 @@ fn convert_tt(
    let first_child = tt.first_child_or_token()?;
    let last_child = tt.last_child_or_token()?;
    let (delimiter, skip_first) = match (first_child.kind(), last_child.kind()) {
-        (L_PAREN, R_PAREN) => (tt::Delimiter::Parenthesis, true),
+        (T!['('], T![')']) => (tt::Delimiter::Parenthesis, true),
-        (L_CURLY, R_CURLY) => (tt::Delimiter::Brace, true),
+        (T!['{'], T!['}']) => (tt::Delimiter::Brace, true),
-        (L_BRACK, R_BRACK) => (tt::Delimiter::Bracket, true),
+        (T!['['], T![']']) => (tt::Delimiter::Bracket, true),
        _ => (tt::Delimiter::None, false),
    };
@@ -248,23 +248,22 @@ fn convert_tt(
                    token_trees.push(tt::Leaf::from(tt::Punct { char, spacing }).into());
                } else {
-                    let child: tt::TokenTree = if token.kind() == SyntaxKind::TRUE_KW
+                    let child: tt::TokenTree =
-                        || token.kind() == SyntaxKind::FALSE_KW
+                        if token.kind() == T![true] || token.kind() == T![false] {
-                    {
+                            tt::Leaf::from(tt::Literal { text: token.text().clone() }).into()
-                        tt::Leaf::from(tt::Literal { text: token.text().clone() }).into()
+                        } else if token.kind().is_keyword()
-                    } else if token.kind().is_keyword()
+                            || token.kind() == IDENT
-                        || token.kind() == IDENT
+                            || token.kind() == LIFETIME
-                        || token.kind() == LIFETIME
+                        {
-                    {
+                            let relative_range = token.range() - global_offset;
-                        let relative_range = token.range() - global_offset;
+                            let id = token_map.alloc(relative_range);
-                        let id = token_map.alloc(relative_range);
+                            let text = token.text().clone();
-                        let text = token.text().clone();
+                            tt::Leaf::from(tt::Ident { text, id }).into()
-                        tt::Leaf::from(tt::Ident { text, id }).into()
+                        } else if token.kind().is_literal() {
-                    } else if token.kind().is_literal() {
+                            tt::Leaf::from(tt::Literal { text: token.text().clone() }).into()
-                        tt::Leaf::from(tt::Literal { text: token.text().clone() }).into()
+                        } else {
-                    } else {
+                            return None;
-                        return None;
+                        };
-                    };
                    token_trees.push(child);
                }
            }
@@ -305,10 +304,8 @@ impl<'a, Q: Querier> TtTreeSink<'a, Q> {
 }
 fn is_delimiter(kind: SyntaxKind) -> bool {
-    use SyntaxKind::*;
    match kind {
-        L_PAREN | L_BRACK | L_CURLY | R_PAREN | R_BRACK | R_CURLY => true,
+        T!['('] | T!['['] | T!['{'] | T![')'] | T![']'] | T!['}'] => true,
        _ => false,
    }
 }
diff --git a/crates/ra_mbe/src/tests.rs b/crates/ra_mbe/src/tests.rs
index 004faf77e..e3a5ceecf 100644
--- a/crates/ra_mbe/src/tests.rs
+++ b/crates/ra_mbe/src/tests.rs
@@ -575,6 +575,20 @@ fn test_tt_to_stmts() {
    );
 }
+#[test]
+fn test_match_literal() {
+    let rules = create_rules(
+        r#"
+    macro_rules! foo {
+        ('(') => {
+            fn foo() {}
+        }
+    }
+"#,
+    );
+    assert_expansion(MacroKind::Items, &rules, "foo! ['(']", "fn foo () {}");
+}
 // The following tests are port from intellij-rust directly
 // https://github.com/intellij-rust/intellij-rust/blob/c4e9feee4ad46e7953b1948c112533360b6087bb/src/test/kotlin/org/rust/lang/core/macros/RsMacroExpansionTest.kt
diff --git a/crates/ra_parser/src/event.rs b/crates/ra_parser/src/event.rs
index 87cf4eca0..51beb0866 100644
--- a/crates/ra_parser/src/event.rs
+++ b/crates/ra_parser/src/event.rs
@@ -38,7 +38,7 @@ pub(crate) enum Event {
    /// The events for it would look like this:
    ///
    ///
-    /// START(PATH) IDENT('foo') FINISH START(PATH) COLONCOLON IDENT('bar') FINISH
+    /// START(PATH) IDENT('foo') FINISH START(PATH) T![::] IDENT('bar') FINISH
    ///       |                          /\
    ///       |                          |
    ///       +------forward-parent------+
diff --git a/crates/ra_parser/src/grammar.rs b/crates/ra_parser/src/grammar.rs
index a538ec081..cf603eba1 100644
--- a/crates/ra_parser/src/grammar.rs
+++ b/crates/ra_parser/src/grammar.rs
@@ -59,7 +59,7 @@ pub(crate) fn macro_stmts(p: &mut Parser) {
    let m = p.start();
    while !p.at(EOF) {
-        if p.current() == SEMI {
+        if p.current() == T![;] {
            p.bump();
            continue;
        }
@@ -103,7 +103,7 @@ pub(crate) fn block(p: &mut Parser) {
 pub(crate) fn meta_item(p: &mut Parser) {
    fn is_delimiter(p: &mut Parser) -> bool {
        match p.current() {
-            L_CURLY | L_PAREN | L_BRACK => true,
+            T!['{'] | T!['('] | T!['['] => true,
            _ => false,
        }
    }
@@ -123,12 +123,12 @@ pub(crate) fn meta_item(p: &mut Parser) {
            // https://doc.rust-lang.org/reference/paths.html#simple-paths
            // The start of an meta must be a simple path
            match p.current() {
-                IDENT | COLONCOLON | SUPER_KW | SELF_KW | CRATE_KW => p.bump(),
+                IDENT | T![::] | T![super] | T![self] | T![crate] => p.bump(),
-                EQ => {
+                T![=] => {
                    p.bump();
                    match p.current() {
                        c if c.is_literal() => p.bump(),
-                        TRUE_KW | FALSE_KW => p.bump(),
+                        T![true] | T![false] => p.bump(),
                        _ => {}
                    }
                    break;
@@ -158,7 +158,7 @@ pub(crate) fn reparser(
        MATCH_ARM_LIST => items::match_arm_list,
        USE_TREE_LIST => items::use_tree_list,
        EXTERN_ITEM_LIST => items::extern_item_list,
-        TOKEN_TREE if first_child? == L_CURLY => items::token_tree,
+        TOKEN_TREE if first_child? == T!['{'] => items::token_tree,
        ITEM_LIST => match parent? {
            IMPL_BLOCK => items::impl_item_list,
            TRAIT_DEF => items::trait_item_list,
@@ -184,26 +184,26 @@ impl BlockLike {
 pub(crate) fn opt_visibility(p: &mut Parser) -> bool {
    match p.current() {
-        PUB_KW => {
+        T![pub] => {
            let m = p.start();
            p.bump();
-            if p.at(L_PAREN) {
+            if p.at(T!['(']) {
                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 => {
+                    T![crate] | T![self] | T![super] => {
                        p.bump();
                        p.bump();
-                        p.expect(R_PAREN);
+                        p.expect(T![')']);
                    }
-                    IN_KW => {
+                    T![in] => {
                        p.bump();
                        p.bump();
                        paths::use_path(p);
-                        p.expect(R_PAREN);
+                        p.expect(T![')']);
                    }
                    _ => (),
                }
@@ -217,7 +217,7 @@ pub(crate) fn opt_visibility(p: &mut Parser) -> bool {
        //
        // test crate_keyword_path
        // fn foo() { crate::foo(); }
-        CRATE_KW if p.nth(1) != COLONCOLON => {
+        T![crate] if p.nth(1) != T![::] => {
            let m = p.start();
            p.bump();
            m.complete(p, VISIBILITY);
@@ -228,10 +228,10 @@ pub(crate) fn opt_visibility(p: &mut Parser) -> bool {
 }
 fn opt_alias(p: &mut Parser) {
-    if p.at(AS_KW) {
+    if p.at(T![as]) {
        let m = p.start();
        p.bump();
-        if !p.eat(UNDERSCORE) {
+        if !p.eat(T![_]) {
            name(p);
        }
        m.complete(p, ALIAS);
@@ -239,7 +239,7 @@ fn opt_alias(p: &mut Parser) {
 }
 fn abi(p: &mut Parser) {
-    assert!(p.at(EXTERN_KW));
+    assert!(p.at(T![extern]));
    let abi = p.start();
    p.bump();
    match p.current() {
@@ -250,7 +250,7 @@ fn abi(p: &mut Parser) {
 }
 fn opt_fn_ret_type(p: &mut Parser) -> bool {
-    if p.at(THIN_ARROW) {
+    if p.at(T![->]) {
        let m = p.start();
        p.bump();
        types::type_(p);
@@ -280,21 +280,21 @@ fn name_ref(p: &mut Parser) {
        let m = p.start();
        p.bump();
        m.complete(p, NAME_REF);
-    } else if p.at(SELF_KW) {
+    } else if p.at(T![self]) {
        let m = p.start();
        p.bump();
-        m.complete(p, SELF_KW);
+        m.complete(p, T![self]);
    } else {
        p.err_and_bump("expected identifier");
    }
 }
 fn error_block(p: &mut Parser, message: &str) {
-    assert!(p.at(L_CURLY));
+    assert!(p.at(T!['{']));
    let m = p.start();
    p.error(message);
    p.bump();
    expressions::expr_block_contents(p);
-    p.eat(R_CURLY);
+    p.eat(T!['}']);
    m.complete(p, ERROR);
 }
diff --git a/crates/ra_parser/src/grammar/attributes.rs b/crates/ra_parser/src/grammar/attributes.rs
index cd30e8a45..20d58445f 100644
--- a/crates/ra_parser/src/grammar/attributes.rs
+++ b/crates/ra_parser/src/grammar/attributes.rs
@@ -1,28 +1,28 @@
 use super::*;
 pub(super) fn inner_attributes(p: &mut Parser) {
-    while p.current() == POUND && p.nth(1) == EXCL {
+    while p.current() == T![#] && p.nth(1) == T![!] {
        attribute(p, true)
    }
 }
 pub(super) fn outer_attributes(p: &mut Parser) {
-    while p.at(POUND) {
+    while p.at(T![#]) {
        attribute(p, false)
    }
 }
 fn attribute(p: &mut Parser, inner: bool) {
    let attr = p.start();
-    assert!(p.at(POUND));
+    assert!(p.at(T![#]));
    p.bump();
    if inner {
-        assert!(p.at(EXCL));
+        assert!(p.at(T![!]));
        p.bump();
    }
-    if p.at(L_BRACK) {
+    if p.at(T!['[']) {
        items::token_tree(p);
    } else {
        p.error("expected `[`");
diff --git a/crates/ra_parser/src/grammar/expressions.rs b/crates/ra_parser/src/grammar/expressions.rs
index 9fe529f53..bb6c78b5f 100644
--- a/crates/ra_parser/src/grammar/expressions.rs
+++ b/crates/ra_parser/src/grammar/expressions.rs
@@ -36,14 +36,14 @@ fn expr_no_struct(p: &mut Parser) {
 // fn c() { 1; 2; }
 // fn d() { 1; 2 }
 pub(crate) fn block(p: &mut Parser) {
-    if !p.at(L_CURLY) {
+    if !p.at(T!['{']) {
        p.error("expected a block");
        return;
    }
    let m = p.start();
    p.bump();
    expr_block_contents(p);
-    p.expect(R_CURLY);
+    p.expect(T!['}']);
    m.complete(p, BLOCK);
 }
@@ -65,10 +65,10 @@ pub(super) fn stmt(p: &mut Parser, with_semi: StmtWithSemi) {
    //     #[C] #[D] {}
    //     #[D] return ();
    // }
-    let has_attrs = p.at(POUND);
+    let has_attrs = p.at(T![#]);
    attributes::outer_attributes(p);
-    if p.at(LET_KW) {
+    if p.at(T![let]) {
        let_stmt(p, m, with_semi);
        return;
    }
@@ -90,7 +90,7 @@ pub(super) fn stmt(p: &mut Parser, with_semi: StmtWithSemi) {
        p.error(format!("attributes are not allowed on {:?}", kind));
    }
-    if p.at(R_CURLY) {
+    if p.at(T!['}']) {
        // test attr_on_last_expr_in_block
        // fn foo() {
        //     { #[A] bar!()? }
@@ -121,15 +121,15 @@ pub(super) fn stmt(p: &mut Parser, with_semi: StmtWithSemi) {
        match with_semi {
            StmtWithSemi::Yes => {
                if blocklike.is_block() {
-                    p.eat(SEMI);
+                    p.eat(T![;]);
                } else {
-                    p.expect(SEMI);
+                    p.expect(T![;]);
                }
            }
            StmtWithSemi::No => {}
            StmtWithSemi::Optional => {
-                if p.at(SEMI) {
+                if p.at(T![;]) {
-                    p.eat(SEMI);
+                    p.eat(T![;]);
                }
            }
        }
@@ -145,24 +145,24 @@ pub(super) fn stmt(p: &mut Parser, with_semi: StmtWithSemi) {
    //     let d: i32 = 92;
    // }
    fn let_stmt(p: &mut Parser, m: Marker, with_semi: StmtWithSemi) {
-        assert!(p.at(LET_KW));
+        assert!(p.at(T![let]));
        p.bump();
        patterns::pattern(p);
-        if p.at(COLON) {
+        if p.at(T![:]) {
            types::ascription(p);
        }
-        if p.eat(EQ) {
+        if p.eat(T![=]) {
            expressions::expr(p);
        }
        match with_semi {
            StmtWithSemi::Yes => {
-                p.expect(SEMI);
+                p.expect(T![;]);
            }
            StmtWithSemi::No => {}
            StmtWithSemi::Optional => {
-                if p.at(SEMI) {
+                if p.at(T![;]) {
-                    p.eat(SEMI);
+                    p.eat(T![;]);
                }
            }
        }
@@ -174,12 +174,12 @@ pub(crate) fn expr_block_contents(p: &mut Parser) {
    // This is checked by a validator
    attributes::inner_attributes(p);
-    while !p.at(EOF) && !p.at(R_CURLY) {
+    while !p.at(EOF) && !p.at(T!['}']) {
        // test nocontentexpr
        // fn foo(){
        //     ;;;some_expr();;;;{;;;};;;;Ok(())
        // }
-        if p.current() == SEMI {
+        if p.current() == T![;] {
            p.bump();
            continue;
        }
@@ -202,41 +202,41 @@ enum Op {
 fn current_op(p: &Parser) -> (u8, Op) {
    if let Some(t) = p.current3() {
        match t {
-            (L_ANGLE, L_ANGLE, EQ) => return (1, Op::Composite(SHLEQ, 3)),
+            (T![<], T![<], T![=]) => return (1, Op::Composite(T![<<=], 3)),
-            (R_ANGLE, R_ANGLE, EQ) => return (1, Op::Composite(SHREQ, 3)),
+            (T![>], T![>], T![=]) => return (1, Op::Composite(T![>>=], 3)),
            _ => (),
        }
    }
    if let Some(t) = p.current2() {
        match t {
-            (PLUS, EQ) => return (1, Op::Composite(PLUSEQ, 2)),
+            (T![+], T![=]) => return (1, Op::Composite(T![+=], 2)),
-            (MINUS, EQ) => return (1, Op::Composite(MINUSEQ, 2)),
+            (T![-], T![=]) => return (1, Op::Composite(T![-=], 2)),
-            (STAR, EQ) => return (1, Op::Composite(STAREQ, 2)),
+            (T![*], T![=]) => return (1, Op::Composite(T![*=], 2)),
-            (PERCENT, EQ) => return (1, Op::Composite(PERCENTEQ, 2)),
+            (T![%], T![=]) => return (1, Op::Composite(T![%=], 2)),
-            (SLASH, EQ) => return (1, Op::Composite(SLASHEQ, 2)),
+            (T![/], T![=]) => return (1, Op::Composite(T![/=], 2)),
-            (PIPE, EQ) => return (1, Op::Composite(PIPEEQ, 2)),
+            (T![|], T![=]) => return (1, Op::Composite(T![|=], 2)),
-            (AMP, EQ) => return (1, Op::Composite(AMPEQ, 2)),
+            (T![&], T![=]) => return (1, Op::Composite(T![&=], 2)),
-            (CARET, EQ) => return (1, Op::Composite(CARETEQ, 2)),
+            (T![^], T![=]) => return (1, Op::Composite(T![^=], 2)),
-            (PIPE, PIPE) => return (3, Op::Composite(PIPEPIPE, 2)),
+            (T![|], T![|]) => return (3, Op::Composite(T![||], 2)),
-            (AMP, AMP) => return (4, Op::Composite(AMPAMP, 2)),
+            (T![&], T![&]) => return (4, Op::Composite(T![&&], 2)),
-            (L_ANGLE, EQ) => return (5, Op::Composite(LTEQ, 2)),
+            (T![<], T![=]) => return (5, Op::Composite(T![<=], 2)),
-            (R_ANGLE, EQ) => return (5, Op::Composite(GTEQ, 2)),
+            (T![>], T![=]) => return (5, Op::Composite(T![>=], 2)),
-            (L_ANGLE, L_ANGLE) => return (9, Op::Composite(SHL, 2)),
+            (T![<], T![<]) => return (9, Op::Composite(T![<<], 2)),
-            (R_ANGLE, R_ANGLE) => return (9, Op::Composite(SHR, 2)),
+            (T![>], T![>]) => return (9, Op::Composite(T![>>], 2)),
            _ => (),
        }
    }
    let bp = match p.current() {
-        EQ => 1,
+        T![=] => 1,
-        DOTDOT | DOTDOTEQ => 2,
+        T![..] | T![..=] => 2,
-        EQEQ | NEQ | L_ANGLE | R_ANGLE => 5,
+        T![==] | T![!=] | T![<] | T![>] => 5,
-        PIPE => 6,
+        T![|] => 6,
-        CARET => 7,
+        T![^] => 7,
-        AMP => 8,
+        T![&] => 8,
-        MINUS | PLUS => 10,
+        T![-] | T![+] => 10,
-        STAR | SLASH | PERCENT => 11,
+        T![*] | T![/] | T![%] => 11,
        _ => 0,
    };
    (bp, Op::Simple)
@@ -284,7 +284,7 @@ fn expr_bp(
            newly_dollar_open = false;
        }
-        let is_range = p.current() == DOTDOT || p.current() == DOTDOTEQ;
+        let is_range = p.current() == T![..] || p.current() == T![..=];
        let (op_bp, op) = current_op(p);
        if op_bp < bp {
            break;
@@ -318,10 +318,10 @@ fn lhs(
        //     let _ = &1;
        //     let _ = &mut &f();
        // }
-        AMP => {
+        T![&] => {
            m = p.start();
            p.bump();
-            p.eat(MUT_KW);
+            p.eat(T![mut]);
            REF_EXPR
        }
        // test unary_expr
@@ -330,14 +330,14 @@ fn lhs(
        //     !!true;
        //     --1;
        // }
-        STAR | EXCL | MINUS => {
+        T![*] | T![!] | T![-] => {
            m = p.start();
            p.bump();
            PREFIX_EXPR
        }
        // test full_range_expr
        // fn foo() { xs[..]; }
-        DOTDOT | DOTDOTEQ => {
+        T![..] | T![..=] => {
            m = p.start();
            p.bump();
            if p.at_ts(EXPR_FIRST) {
@@ -375,21 +375,21 @@ fn postfix_expr(
            //         [] => {}
            //     }
            // }
-            L_PAREN if allow_calls => call_expr(p, lhs),
+            T!['('] if allow_calls => call_expr(p, lhs),
-            L_BRACK if allow_calls => index_expr(p, lhs),
+            T!['['] if allow_calls => index_expr(p, lhs),
-            DOT if p.nth(1) == IDENT && (p.nth(2) == L_PAREN || p.nth(2) == COLONCOLON) => {
+            T![.] if p.nth(1) == IDENT && (p.nth(2) == T!['('] || p.nth(2) == T![::]) => {
                method_call_expr(p, lhs)
            }
-            DOT => field_expr(p, lhs),
+            T![.] => field_expr(p, lhs),
            // test postfix_range
            // fn foo() { let x = 1..; }
-            DOTDOT | DOTDOTEQ if !EXPR_FIRST.contains(p.nth(1)) => {
+            T![..] | T![..=] if !EXPR_FIRST.contains(p.nth(1)) => {
                let m = lhs.precede(p);
                p.bump();
                m.complete(p, RANGE_EXPR)
            }
-            QUESTION => try_expr(p, lhs),
+            T![?] => try_expr(p, lhs),
-            AS_KW => cast_expr(p, lhs),
+            T![as] => cast_expr(p, lhs),
            _ => break,
        };
        allow_calls = true
@@ -405,7 +405,7 @@ fn postfix_expr(
 //     f(<Foo as Trait>::func());
 // }
 fn call_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
-    assert!(p.at(L_PAREN));
+    assert!(p.at(T!['(']));
    let m = lhs.precede(p);
    arg_list(p);
    m.complete(p, CALL_EXPR)
@@ -416,11 +416,11 @@ fn call_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
 //     x[1][2];
 // }
 fn index_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
-    assert!(p.at(L_BRACK));
+    assert!(p.at(T!['[']));
    let m = lhs.precede(p);
    p.bump();
    expr(p);
-    p.expect(R_BRACK);
+    p.expect(T![']']);
    m.complete(p, INDEX_EXPR)
 }
@@ -430,12 +430,12 @@ fn index_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
 //     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));
+    assert!(p.at(T![.]) && p.nth(1) == IDENT && (p.nth(2) == T!['('] || p.nth(2) == T![::]));
    let m = lhs.precede(p);
    p.bump();
    name_ref(p);
    type_args::opt_type_arg_list(p, true);
-    if p.at(L_PAREN) {
+    if p.at(T!['(']) {
        arg_list(p);
    }
    m.complete(p, METHOD_CALL_EXPR)
@@ -455,7 +455,7 @@ fn method_call_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
 //     x.0x01;
 // }
 fn field_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
-    assert!(p.at(DOT));
+    assert!(p.at(T![.]));
    let m = lhs.precede(p);
    p.bump();
    if p.at(IDENT) {
@@ -463,7 +463,7 @@ fn field_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
    } else if p.at(INT_NUMBER) {
        p.bump();
    } else if p.at(FLOAT_NUMBER) {
-        // FIXME: How to recover and instead parse INT + DOT?
+        // FIXME: How to recover and instead parse INT + T![.]?
        p.bump();
    } else {
        p.error("expected field name or number")
@@ -476,7 +476,7 @@ fn field_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
 //     x?;
 // }
 fn try_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
-    assert!(p.at(QUESTION));
+    assert!(p.at(T![?]));
    let m = lhs.precede(p);
    p.bump();
    m.complete(p, TRY_EXPR)
@@ -490,7 +490,7 @@ fn try_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
 //     0x36 as u8 <= 0x37;
 // }
 fn cast_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
-    assert!(p.at(AS_KW));
+    assert!(p.at(T![as]));
    let m = lhs.precede(p);
    p.bump();
    // Use type_no_bounds(), because cast expressions are not
@@ -500,20 +500,20 @@ fn cast_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
 }
 fn arg_list(p: &mut Parser) {
-    assert!(p.at(L_PAREN));
+    assert!(p.at(T!['(']));
    let m = p.start();
    p.bump();
-    while !p.at(R_PAREN) && !p.at(EOF) {
+    while !p.at(T![')']) && !p.at(EOF) {
        if !p.at_ts(EXPR_FIRST) {
            p.error("expected expression");
            break;
        }
        expr(p);
-        if !p.at(R_PAREN) && !p.expect(COMMA) {
+        if !p.at(T![')']) && !p.expect(T![,]) {
            break;
        }
    }
-    p.eat(R_PAREN);
+    p.eat(T![')']);
    m.complete(p, ARG_LIST);
 }
@@ -525,15 +525,15 @@ fn arg_list(p: &mut Parser) {
 //     let _ = format!();
 // }
 fn path_expr(p: &mut Parser, r: Restrictions) -> (CompletedMarker, BlockLike) {
-    assert!(paths::is_path_start(p) || p.at(L_ANGLE));
+    assert!(paths::is_path_start(p) || p.at(T![<]));
    let m = p.start();
    paths::expr_path(p);
    match p.current() {
-        L_CURLY if !r.forbid_structs => {
+        T!['{'] if !r.forbid_structs => {
            named_field_list(p);
            (m.complete(p, STRUCT_LIT), BlockLike::NotBlock)
        }
-        EXCL => {
+        T![!] => {
            let block_like = items::macro_call_after_excl(p);
            (m.complete(p, MACRO_CALL), block_like)
        }
@@ -548,35 +548,35 @@ fn path_expr(p: &mut Parser, r: Restrictions) -> (CompletedMarker, BlockLike) {
 //     S { x, y: 32, ..Default::default() };
 // }
 pub(crate) fn named_field_list(p: &mut Parser) {
-    assert!(p.at(L_CURLY));
+    assert!(p.at(T!['{']));
    let m = p.start();
    p.bump();
-    while !p.at(EOF) && !p.at(R_CURLY) {
+    while !p.at(EOF) && !p.at(T!['}']) {
        match p.current() {
            // test struct_literal_field_with_attr
            // fn main() {
            //     S { #[cfg(test)] field: 1 }
            // }
-            IDENT | POUND => {
+            IDENT | T![#] => {
                let m = p.start();
                attributes::outer_attributes(p);
                name_ref(p);
-                if p.eat(COLON) {
+                if p.eat(T![:]) {
                    expr(p);
                }
                m.complete(p, NAMED_FIELD);
            }
-            DOTDOT => {
+            T![..] => {
                p.bump();
                expr(p);
            }
-            L_CURLY => error_block(p, "expected a field"),
+            T!['{'] => error_block(p, "expected a field"),
            _ => p.err_and_bump("expected identifier"),
        }
-        if !p.at(R_CURLY) {
+        if !p.at(T!['}']) {
-            p.expect(COMMA);
+            p.expect(T![,]);
        }
    }
-    p.expect(R_CURLY);
+    p.expect(T!['}']);
    m.complete(p, NAMED_FIELD_LIST);
 }
diff --git a/crates/ra_parser/src/grammar/expressions/atom.rs b/crates/ra_parser/src/grammar/expressions/atom.rs
index 8dc7e44a9..8b1a1de49 100644
--- a/crates/ra_parser/src/grammar/expressions/atom.rs
+++ b/crates/ra_parser/src/grammar/expressions/atom.rs
@@ -60,29 +60,29 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMar
    if let Some(m) = literal(p) {
        return Some((m, BlockLike::NotBlock));
    }
-    if paths::is_path_start(p) || p.at(L_ANGLE) {
+    if paths::is_path_start(p) || p.at(T![<]) {
        return Some(path_expr(p, r));
    }
    let la = p.nth(1);
    let done = match p.current() {
-        L_PAREN => tuple_expr(p),
+        T!['('] => tuple_expr(p),
-        L_BRACK => array_expr(p),
+        T!['['] => array_expr(p),
-        PIPE => lambda_expr(p),
+        T![|] => lambda_expr(p),
-        MOVE_KW if la == PIPE => lambda_expr(p),
+        T![move] if la == T![|] => lambda_expr(p),
-        ASYNC_KW if la == PIPE || (la == MOVE_KW && p.nth(2) == PIPE) => lambda_expr(p),
+        T![async] if la == T![|] || (la == T![move] && p.nth(2) == T![|]) => lambda_expr(p),
-        IF_KW => if_expr(p),
+        T![if] => if_expr(p),
-        LOOP_KW => loop_expr(p, None),
+        T![loop] => loop_expr(p, None),
-        FOR_KW => for_expr(p, None),
+        T![for] => for_expr(p, None),
-        WHILE_KW => while_expr(p, None),
+        T![while] => while_expr(p, None),
-        LIFETIME if la == COLON => {
+        LIFETIME if la == T![:] => {
            let m = p.start();
            label(p);
            match p.current() {
-                LOOP_KW => loop_expr(p, Some(m)),
+                T![loop] => loop_expr(p, Some(m)),
-                FOR_KW => for_expr(p, Some(m)),
+                T![for] => for_expr(p, Some(m)),
-                WHILE_KW => while_expr(p, Some(m)),
+                T![while] => while_expr(p, Some(m)),
-                L_CURLY => block_expr(p, Some(m)),
+                T!['{'] => block_expr(p, Some(m)),
                _ => {
                    // test_err misplaced_label_err
                    // fn main() {
@@ -94,22 +94,22 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMar
                }
            }
        }
-        ASYNC_KW if la == L_CURLY || (la == MOVE_KW && p.nth(2) == L_CURLY) => {
+        T![async] if la == T!['{'] || (la == T![move] && p.nth(2) == T!['{']) => {
            let m = p.start();
            p.bump();
-            p.eat(MOVE_KW);
+            p.eat(T![move]);
            block_expr(p, Some(m))
        }
-        MATCH_KW => match_expr(p),
+        T![match] => match_expr(p),
-        UNSAFE_KW if la == L_CURLY => {
+        T![unsafe] if la == T!['{'] => {
            let m = p.start();
            p.bump();
            block_expr(p, Some(m))
        }
-        L_CURLY => block_expr(p, None),
+        T!['{'] => block_expr(p, None),
-        RETURN_KW => return_expr(p),
+        T![return] => return_expr(p),
-        CONTINUE_KW => continue_expr(p),
+        T![continue] => continue_expr(p),
-        BREAK_KW => break_expr(p, r),
+        T![break] => break_expr(p, r),
        _ => {
            p.err_recover("expected expression", EXPR_RECOVERY_SET);
            return None;
@@ -129,25 +129,25 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMar
 //     (1,);
 // }
 fn tuple_expr(p: &mut Parser) -> CompletedMarker {
-    assert!(p.at(L_PAREN));
+    assert!(p.at(T!['(']));
    let m = p.start();
-    p.expect(L_PAREN);
+    p.expect(T!['(']);
    let mut saw_comma = false;
    let mut saw_expr = false;
-    while !p.at(EOF) && !p.at(R_PAREN) {
+    while !p.at(EOF) && !p.at(T![')']) {
        saw_expr = true;
        if !p.at_ts(EXPR_FIRST) {
            p.error("expected expression");
            break;
        }
        expr(p);
-        if !p.at(R_PAREN) {
+        if !p.at(T![')']) {
            saw_comma = true;
-            p.expect(COMMA);
+            p.expect(T![,]);
        }
    }
-    p.expect(R_PAREN);
+    p.expect(T![')']);
    m.complete(p, if saw_expr && !saw_comma { PAREN_EXPR } else { TUPLE_EXPR })
 }
@@ -159,21 +159,21 @@ fn tuple_expr(p: &mut Parser) -> CompletedMarker {
 //     [1; 2];
 // }
 fn array_expr(p: &mut Parser) -> CompletedMarker {
-    assert!(p.at(L_BRACK));
+    assert!(p.at(T!['[']));
    let m = p.start();
    p.bump();
-    if p.eat(R_BRACK) {
+    if p.eat(T![']']) {
        return m.complete(p, ARRAY_EXPR);
    }
    expr(p);
-    if p.eat(SEMI) {
+    if p.eat(T![;]) {
        expr(p);
-        p.expect(R_BRACK);
+        p.expect(T![']']);
        return m.complete(p, ARRAY_EXPR);
    }
-    while !p.at(EOF) && !p.at(R_BRACK) {
+    while !p.at(EOF) && !p.at(T![']']) {
-        p.expect(COMMA);
+        p.expect(T![,]);
-        if p.at(R_BRACK) {
+        if p.at(T![']']) {
            break;
        }
        if !p.at_ts(EXPR_FIRST) {
@@ -182,7 +182,7 @@ fn array_expr(p: &mut Parser) -> CompletedMarker {
        }
        expr(p);
    }
-    p.expect(R_BRACK);
+    p.expect(T![']']);
    m.complete(p, ARRAY_EXPR)
 }
@@ -198,17 +198,17 @@ fn array_expr(p: &mut Parser) -> CompletedMarker {
 // }
 fn lambda_expr(p: &mut Parser) -> CompletedMarker {
    assert!(
-        p.at(PIPE)
+        p.at(T![|])
-            || (p.at(MOVE_KW) && p.nth(1) == PIPE)
+            || (p.at(T![move]) && p.nth(1) == T![|])
-            || (p.at(ASYNC_KW) && p.nth(1) == PIPE)
+            || (p.at(T![async]) && p.nth(1) == T![|])
-            || (p.at(ASYNC_KW) && p.nth(1) == MOVE_KW && p.nth(2) == PIPE)
+            || (p.at(T![async]) && p.nth(1) == T![move] && p.nth(2) == T![|])
    );
    let m = p.start();
-    p.eat(ASYNC_KW);
+    p.eat(T![async]);
-    p.eat(MOVE_KW);
+    p.eat(T![move]);
    params::param_list_opt_types(p);
    if opt_fn_ret_type(p) {
-        if !p.at(L_CURLY) {
+        if !p.at(T!['{']) {
            p.error("expected `{`");
        }
    }
@@ -224,14 +224,14 @@ fn lambda_expr(p: &mut Parser) -> CompletedMarker {
 //     if S {};
 // }
 fn if_expr(p: &mut Parser) -> CompletedMarker {
-    assert!(p.at(IF_KW));
+    assert!(p.at(T![if]));
    let m = p.start();
    p.bump();
    cond(p);
    block(p);
-    if p.at(ELSE_KW) {
+    if p.at(T![else]) {
        p.bump();
-        if p.at(IF_KW) {
+        if p.at(T![if]) {
            if_expr(p);
        } else {
            block(p);
@@ -247,7 +247,7 @@ fn if_expr(p: &mut Parser) -> CompletedMarker {
 //     'c: for x in () {}
 // }
 fn label(p: &mut Parser) {
-    assert!(p.at(LIFETIME) && p.nth(1) == COLON);
+    assert!(p.at(LIFETIME) && p.nth(1) == T![:]);
    let m = p.start();
    p.bump();
    p.bump();
@@ -259,7 +259,7 @@ fn label(p: &mut Parser) {
 //     loop {};
 // }
 fn loop_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
-    assert!(p.at(LOOP_KW));
+    assert!(p.at(T![loop]));
    let m = m.unwrap_or_else(|| p.start());
    p.bump();
    block(p);
@@ -272,7 +272,7 @@ fn loop_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
 //     while let Some(x) = it.next() {};
 // }
 fn while_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
-    assert!(p.at(WHILE_KW));
+    assert!(p.at(T![while]));
    let m = m.unwrap_or_else(|| p.start());
    p.bump();
    cond(p);
@@ -285,11 +285,11 @@ fn while_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
 //     for x in [] {};
 // }
 fn for_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
-    assert!(p.at(FOR_KW));
+    assert!(p.at(T![for]));
    let m = m.unwrap_or_else(|| p.start());
    p.bump();
    patterns::pattern(p);
-    p.expect(IN_KW);
+    p.expect(T![in]);
    expr_no_struct(p);
    block(p);
    m.complete(p, FOR_EXPR)
@@ -305,9 +305,9 @@ fn for_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
 // }
 fn cond(p: &mut Parser) {
    let m = p.start();
-    if p.eat(LET_KW) {
+    if p.eat(T![let]) {
        patterns::pattern_list(p);
-        p.expect(EQ);
+        p.expect(T![=]);
    }
    expr_no_struct(p);
    m.complete(p, CONDITION);
@@ -319,11 +319,11 @@ fn cond(p: &mut Parser) {
 //     match S {};
 // }
 fn match_expr(p: &mut Parser) -> CompletedMarker {
-    assert!(p.at(MATCH_KW));
+    assert!(p.at(T![match]));
    let m = p.start();
    p.bump();
    expr_no_struct(p);
-    if p.at(L_CURLY) {
+    if p.at(T!['{']) {
        match_arm_list(p);
    } else {
        p.error("expected `{`")
@@ -332,9 +332,9 @@ fn match_expr(p: &mut Parser) -> CompletedMarker {
 }
 pub(crate) fn match_arm_list(p: &mut Parser) {
-    assert!(p.at(L_CURLY));
+    assert!(p.at(T!['{']));
    let m = p.start();
-    p.eat(L_CURLY);
+    p.eat(T!['{']);
    // test match_arms_inner_attribute
    // fn foo() {
@@ -347,8 +347,8 @@ pub(crate) fn match_arm_list(p: &mut Parser) {
    // }
    attributes::inner_attributes(p);
-    while !p.at(EOF) && !p.at(R_CURLY) {
+    while !p.at(EOF) && !p.at(T!['}']) {
-        if p.at(L_CURLY) {
+        if p.at(T!['{']) {
            error_block(p, "expected match arm");
            continue;
        }
@@ -362,12 +362,12 @@ pub(crate) fn match_arm_list(p: &mut Parser) {
        //     }
        // }
        if match_arm(p).is_block() {
-            p.eat(COMMA);
+            p.eat(T![,]);
-        } else if !p.at(R_CURLY) {
+        } else if !p.at(T!['}']) {
-            p.expect(COMMA);
+            p.expect(T![,]);
        }
    }
-    p.expect(R_CURLY);
+    p.expect(T!['}']);
    m.complete(p, MATCH_ARM_LIST);
 }
@@ -399,10 +399,10 @@ fn match_arm(p: &mut Parser) -> BlockLike {
    attributes::outer_attributes(p);
    patterns::pattern_list_r(p, TokenSet::empty());
-    if p.at(IF_KW) {
+    if p.at(T![if]) {
        match_guard(p);
    }
-    p.expect(FAT_ARROW);
+    p.expect(T![=>]);
    let blocklike = expr_stmt(p).1;
    m.complete(p, MATCH_ARM);
    blocklike
@@ -415,7 +415,7 @@ fn match_arm(p: &mut Parser) -> BlockLike {
 //     }
 // }
 fn match_guard(p: &mut Parser) -> CompletedMarker {
-    assert!(p.at(IF_KW));
+    assert!(p.at(T![if]));
    let m = p.start();
    p.bump();
    expr(p);
@@ -429,7 +429,7 @@ fn match_guard(p: &mut Parser) -> CompletedMarker {
 //     'label: {};
 // }
 fn block_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
-    assert!(p.at(L_CURLY));
+    assert!(p.at(T!['{']));
    let m = m.unwrap_or_else(|| p.start());
    block(p);
    m.complete(p, BLOCK_EXPR)
@@ -441,7 +441,7 @@ fn block_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
 //     return 92;
 // }
 fn return_expr(p: &mut Parser) -> CompletedMarker {
-    assert!(p.at(RETURN_KW));
+    assert!(p.at(T![return]));
    let m = p.start();
    p.bump();
    if p.at_ts(EXPR_FIRST) {
@@ -458,7 +458,7 @@ fn return_expr(p: &mut Parser) -> CompletedMarker {
 //     }
 // }
 fn continue_expr(p: &mut Parser) -> CompletedMarker {
-    assert!(p.at(CONTINUE_KW));
+    assert!(p.at(T![continue]));
    let m = p.start();
    p.bump();
    p.eat(LIFETIME);
@@ -475,7 +475,7 @@ fn continue_expr(p: &mut Parser) -> CompletedMarker {
 //     }
 // }
 fn break_expr(p: &mut Parser, r: Restrictions) -> CompletedMarker {
-    assert!(p.at(BREAK_KW));
+    assert!(p.at(T![break]));
    let m = p.start();
    p.bump();
    p.eat(LIFETIME);
@@ -486,7 +486,7 @@ fn break_expr(p: &mut Parser, r: Restrictions) -> CompletedMarker {
    //     for i in break {}
    //     match break {}
    // }
-    if p.at_ts(EXPR_FIRST) && !(r.forbid_structs && p.at(L_CURLY)) {
+    if p.at_ts(EXPR_FIRST) && !(r.forbid_structs && p.at(T!['{'])) {
        expr(p);
    }
    m.complete(p, BREAK_EXPR)
diff --git a/crates/ra_parser/src/grammar/items.rs b/crates/ra_parser/src/grammar/items.rs
index 97f8122a9..6728e395f 100644
--- a/crates/ra_parser/src/grammar/items.rs
+++ b/crates/ra_parser/src/grammar/items.rs
@@ -19,7 +19,7 @@ use super::*;
 // 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)) {
+    while !p.at(EOF) && !(stop_on_r_curly && p.at(T!['}'])) {
        item_or_macro(p, stop_on_r_curly, ItemFlavor::Mod)
    }
 }
@@ -45,20 +45,20 @@ pub(super) fn item_or_macro(p: &mut Parser, stop_on_r_curly: bool, flavor: ItemF
        match macro_call(p) {
            BlockLike::Block => (),
            BlockLike::NotBlock => {
-                p.expect(SEMI);
+                p.expect(T![;]);
            }
        }
        m.complete(p, MACRO_CALL);
    } else {
        m.abandon(p);
-        if p.at(L_CURLY) {
+        if p.at(T!['{']) {
            error_block(p, "expected an item");
-        } else if p.at(R_CURLY) && !stop_on_r_curly {
+        } else if p.at(T!['}']) && !stop_on_r_curly {
            let e = p.start();
            p.error("unmatched `}`");
            p.bump();
            e.complete(p, ERROR);
-        } else if !p.at(EOF) && !p.at(R_CURLY) {
+        } else if !p.at(EOF) && !p.at(T!['}']) {
            p.err_and_bump("expected an item");
        } else {
            p.error("expected an item");
@@ -79,32 +79,32 @@ pub(super) fn maybe_item(p: &mut Parser, m: Marker, flavor: ItemFlavor) -> Resul
    let mut has_mods = false;
    // modifiers
-    has_mods |= p.eat(CONST_KW);
+    has_mods |= p.eat(T![const]);
    // test_err unsafe_block_in_mod
    // fn foo(){} unsafe { } fn bar(){}
-    if p.at(UNSAFE_KW) && p.nth(1) != L_CURLY {
+    if p.at(T![unsafe]) && p.nth(1) != T!['{'] {
-        p.eat(UNSAFE_KW);
+        p.eat(T![unsafe]);
        has_mods = true;
    }
    // test_err async_without_semicolon
    // fn foo() { let _ = async {} }
-    if p.at(ASYNC_KW) && p.nth(1) != L_CURLY && p.nth(1) != MOVE_KW && p.nth(1) != PIPE {
+    if p.at(T![async]) && p.nth(1) != T!['{'] && p.nth(1) != T![move] && p.nth(1) != T![|] {
-        p.eat(ASYNC_KW);
+        p.eat(T![async]);
        has_mods = true;
    }
-    if p.at(EXTERN_KW) {
+    if p.at(T![extern]) {
        has_mods = true;
        abi(p);
    }
-    if p.at(IDENT) && p.at_contextual_kw("auto") && p.nth(1) == TRAIT_KW {
+    if p.at(IDENT) && p.at_contextual_kw("auto") && p.nth(1) == T![trait] {
-        p.bump_remap(AUTO_KW);
+        p.bump_remap(T![auto]);
        has_mods = true;
    }
-    if p.at(IDENT) && p.at_contextual_kw("default") && p.nth(1) == IMPL_KW {
+    if p.at(IDENT) && p.at_contextual_kw("default") && p.nth(1) == T![impl ] {
-        p.bump_remap(DEFAULT_KW);
+        p.bump_remap(T![default]);
        has_mods = true;
    }
@@ -135,7 +135,7 @@ pub(super) fn maybe_item(p: &mut Parser, m: Marker, flavor: ItemFlavor) -> Resul
        // test_err wrong_order_fns
        // async unsafe fn foo() {}
        // unsafe const fn bar() {}
-        FN_KW => {
+        T![fn] => {
            fn_def(p, flavor);
            m.complete(p, FN_DEF);
        }
@@ -148,7 +148,7 @@ pub(super) fn maybe_item(p: &mut Parser, m: Marker, flavor: ItemFlavor) -> Resul
        // test unsafe_auto_trait
        // unsafe auto trait T {}
-        TRAIT_KW => {
+        T![trait] => {
            traits::trait_def(p);
            m.complete(p, TRAIT_DEF);
        }
@@ -161,7 +161,7 @@ pub(super) fn maybe_item(p: &mut Parser, m: Marker, flavor: ItemFlavor) -> Resul
        // test unsafe_default_impl
        // unsafe default impl Foo {}
-        IMPL_KW => {
+        T![impl ] => {
            traits::impl_block(p);
            m.complete(p, IMPL_BLOCK);
        }
@@ -186,10 +186,10 @@ fn items_without_modifiers(p: &mut Parser, m: Marker) -> Result<(), Marker> {
    match p.current() {
        // test extern_crate
        // extern crate foo;
-        EXTERN_KW if la == CRATE_KW => extern_crate_item(p, m),
+        T![extern] if la == T![crate] => extern_crate_item(p, m),
-        TYPE_KW => type_def(p, m),
+        T![type] => type_def(p, m),
-        MOD_KW => mod_item(p, m),
+        T![mod] => mod_item(p, m),
-        STRUCT_KW => {
+        T![struct] => {
            // test struct_items
            // struct Foo;
            // struct Foo {}
@@ -199,7 +199,7 @@ fn items_without_modifiers(p: &mut Parser, m: Marker) -> Result<(), Marker> {
            //     a: i32,
            //     b: f32,
            // }
-            nominal::struct_def(p, m, STRUCT_KW);
+            nominal::struct_def(p, m, T![struct]);
        }
        IDENT if p.at_contextual_kw("union") && p.nth(1) == IDENT => {
            // test union_items
@@ -208,16 +208,16 @@ fn items_without_modifiers(p: &mut Parser, m: Marker) -> Result<(), Marker> {
            //     a: i32,
            //     b: f32,
            // }
-            nominal::struct_def(p, m, UNION_KW);
+            nominal::struct_def(p, m, T![union]);
        }
-        ENUM_KW => nominal::enum_def(p, m),
+        T![enum] => nominal::enum_def(p, m),
-        USE_KW => use_item::use_item(p, m),
+        T![use] => use_item::use_item(p, m),
-        CONST_KW if (la == IDENT || la == MUT_KW) => consts::const_def(p, m),
+        T![const] if (la == IDENT || la == T![mut]) => consts::const_def(p, m),
-        STATIC_KW => consts::static_def(p, m),
+        T![static] => consts::static_def(p, m),
        // test extern_block
        // extern {}
-        EXTERN_KW
+        T![extern]
-            if la == L_CURLY || ((la == STRING || la == RAW_STRING) && p.nth(2) == L_CURLY) =>
+            if la == T!['{'] || ((la == STRING || la == RAW_STRING) && p.nth(2) == T!['{']) =>
        {
            abi(p);
            extern_item_list(p);
@@ -225,7 +225,7 @@ fn items_without_modifiers(p: &mut Parser, m: Marker) -> Result<(), Marker> {
        }
        _ => return Err(m),
    };
-    if p.at(SEMI) {
+    if p.at(T![;]) {
        p.err_and_bump(
            "expected item, found `;`\n\
             consider removing this semicolon",
@@ -235,27 +235,27 @@ fn items_without_modifiers(p: &mut Parser, m: Marker) -> Result<(), Marker> {
 }
 fn extern_crate_item(p: &mut Parser, m: Marker) {
-    assert!(p.at(EXTERN_KW));
+    assert!(p.at(T![extern]));
    p.bump();
-    assert!(p.at(CRATE_KW));
+    assert!(p.at(T![crate]));
    p.bump();
    name_ref(p);
    opt_alias(p);
-    p.expect(SEMI);
+    p.expect(T![;]);
    m.complete(p, EXTERN_CRATE_ITEM);
 }
 pub(crate) fn extern_item_list(p: &mut Parser) {
-    assert!(p.at(L_CURLY));
+    assert!(p.at(T!['{']));
    let m = p.start();
    p.bump();
    mod_contents(p, true);
-    p.expect(R_CURLY);
+    p.expect(T!['}']);
    m.complete(p, EXTERN_ITEM_LIST);
 }
 fn fn_def(p: &mut Parser, flavor: ItemFlavor) {
-    assert!(p.at(FN_KW));
+    assert!(p.at(T![fn]));
    p.bump();
    name_r(p, ITEM_RECOVERY_SET);
@@ -263,7 +263,7 @@ fn fn_def(p: &mut Parser, flavor: ItemFlavor) {
    // fn foo<T: Clone + Copy>(){}
    type_params::opt_type_param_list(p);
-    if p.at(L_PAREN) {
+    if p.at(T!['(']) {
        match flavor {
            ItemFlavor::Mod => params::param_list(p),
            ItemFlavor::Trait => params::param_list_opt_patterns(p),
@@ -282,7 +282,7 @@ fn fn_def(p: &mut Parser, flavor: ItemFlavor) {
    // test fn_decl
    // trait T { fn foo(); }
-    if p.at(SEMI) {
+    if p.at(T![;]) {
        p.bump();
    } else {
        expressions::block(p)
@@ -292,7 +292,7 @@ fn fn_def(p: &mut Parser, flavor: ItemFlavor) {
 // test type_item
 // type Foo = Bar;
 fn type_def(p: &mut Parser, m: Marker) {
-    assert!(p.at(TYPE_KW));
+    assert!(p.at(T![type]));
    p.bump();
    name(p);
@@ -301,7 +301,7 @@ fn type_def(p: &mut Parser, m: Marker) {
    // type Result<T> = ();
    type_params::opt_type_param_list(p);
-    if p.at(COLON) {
+    if p.at(T![:]) {
        type_params::bounds(p);
    }
@@ -309,32 +309,32 @@ fn type_def(p: &mut Parser, m: Marker) {
    // type Foo where Foo: Copy = ();
    type_params::opt_where_clause(p);
-    if p.eat(EQ) {
+    if p.eat(T![=]) {
        types::type_(p);
    }
-    p.expect(SEMI);
+    p.expect(T![;]);
    m.complete(p, TYPE_ALIAS_DEF);
 }
 pub(crate) fn mod_item(p: &mut Parser, m: Marker) {
-    assert!(p.at(MOD_KW));
+    assert!(p.at(T![mod]));
    p.bump();
    name(p);
-    if p.at(L_CURLY) {
+    if p.at(T!['{']) {
        mod_item_list(p);
-    } else if !p.eat(SEMI) {
+    } else if !p.eat(T![;]) {
        p.error("expected `;` or `{`");
    }
    m.complete(p, MODULE);
 }
 pub(crate) fn mod_item_list(p: &mut Parser) {
-    assert!(p.at(L_CURLY));
+    assert!(p.at(T!['{']));
    let m = p.start();
    p.bump();
    mod_contents(p, true);
-    p.expect(R_CURLY);
+    p.expect(T!['}']);
    m.complete(p, ITEM_LIST);
 }
@@ -345,16 +345,16 @@ fn macro_call(p: &mut Parser) -> BlockLike {
 }
 pub(super) fn macro_call_after_excl(p: &mut Parser) -> BlockLike {
-    p.expect(EXCL);
+    p.expect(T![!]);
    if p.at(IDENT) {
        name(p);
    }
    match p.current() {
-        L_CURLY => {
+        T!['{'] => {
            token_tree(p);
            BlockLike::Block
        }