70 files changed, 1291 insertions, 1045 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 7305d6dd5..5aa4ff5de 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -141,9 +141,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
 name = "chalk-engine"
 version = "0.9.0"
-source = "git+https://github.com/rust-lang/chalk.git#b92c15327f1d336fec7573c7de323ab247cca386"
+source = "git+https://github.com/flodiebold/chalk.git?branch=fuel#fba97af88ff2e0266db12490e2baf47d17e557e3"
 dependencies = [
- "chalk-macros 0.1.1 (git+https://github.com/rust-lang/chalk.git)",
+ "chalk-macros 0.1.1 (git+https://github.com/flodiebold/chalk.git?branch=fuel)",
  "rustc-hash 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "stacker 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -151,17 +151,17 @@ dependencies = [
 [[package]]
 name = "chalk-ir"
 version = "0.1.0"
-source = "git+https://github.com/rust-lang/chalk.git#b92c15327f1d336fec7573c7de323ab247cca386"
+source = "git+https://github.com/flodiebold/chalk.git?branch=fuel#fba97af88ff2e0266db12490e2baf47d17e557e3"
 dependencies = [
- "chalk-engine 0.9.0 (git+https://github.com/rust-lang/chalk.git)",
- "chalk-macros 0.1.1 (git+https://github.com/rust-lang/chalk.git)",
+ "chalk-engine 0.9.0 (git+https://github.com/flodiebold/chalk.git?branch=fuel)",
+ "chalk-macros 0.1.1 (git+https://github.com/flodiebold/chalk.git?branch=fuel)",
  "lalrpop-intern 0.15.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "chalk-macros"
 version = "0.1.1"
-source = "git+https://github.com/rust-lang/chalk.git#b92c15327f1d336fec7573c7de323ab247cca386"
+source = "git+https://github.com/flodiebold/chalk.git?branch=fuel#fba97af88ff2e0266db12490e2baf47d17e557e3"
 dependencies = [
  "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -169,22 +169,22 @@ dependencies = [
 [[package]]
 name = "chalk-rust-ir"
 version = "0.1.0"
-source = "git+https://github.com/rust-lang/chalk.git#b92c15327f1d336fec7573c7de323ab247cca386"
+source = "git+https://github.com/flodiebold/chalk.git?branch=fuel#fba97af88ff2e0266db12490e2baf47d17e557e3"
 dependencies = [
- "chalk-engine 0.9.0 (git+https://github.com/rust-lang/chalk.git)",
- "chalk-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git)",
- "chalk-macros 0.1.1 (git+https://github.com/rust-lang/chalk.git)",
+ "chalk-engine 0.9.0 (git+https://github.com/flodiebold/chalk.git?branch=fuel)",
+ "chalk-ir 0.1.0 (git+https://github.com/flodiebold/chalk.git?branch=fuel)",
+ "chalk-macros 0.1.1 (git+https://github.com/flodiebold/chalk.git?branch=fuel)",
 ]
 
 [[package]]
 name = "chalk-solve"
 version = "0.1.0"
-source = "git+https://github.com/rust-lang/chalk.git#b92c15327f1d336fec7573c7de323ab247cca386"
+source = "git+https://github.com/flodiebold/chalk.git?branch=fuel#fba97af88ff2e0266db12490e2baf47d17e557e3"
 dependencies = [
- "chalk-engine 0.9.0 (git+https://github.com/rust-lang/chalk.git)",
- "chalk-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git)",
- "chalk-macros 0.1.1 (git+https://github.com/rust-lang/chalk.git)",
- "chalk-rust-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git)",
+ "chalk-engine 0.9.0 (git+https://github.com/flodiebold/chalk.git?branch=fuel)",
+ "chalk-ir 0.1.0 (git+https://github.com/flodiebold/chalk.git?branch=fuel)",
+ "chalk-macros 0.1.1 (git+https://github.com/flodiebold/chalk.git?branch=fuel)",
+ "chalk-rust-ir 0.1.0 (git+https://github.com/flodiebold/chalk.git?branch=fuel)",
  "derive-new 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "ena 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -257,7 +257,7 @@ dependencies = [
  "encode_unicode 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "libc 0.2.54 (registry+https://github.com/rust-lang/crates.io-index)",
- "parking_lot 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "regex 1.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "termios 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "unicode-width 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -487,7 +487,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "gen_lsp_server"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "crossbeam-channel 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -551,7 +551,7 @@ dependencies = [
  "console 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "number_prefix 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
- "parking_lot 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "regex 1.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "insta"
-version = "0.7.4"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "chrono 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1109,12 +1109,12 @@ name = "ra_hir"
 version = "0.1.0"
 dependencies = [
  "arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
- "chalk-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git)",
- "chalk-rust-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git)",
- "chalk-solve 0.1.0 (git+https://github.com/rust-lang/chalk.git)",
+ "chalk-ir 0.1.0 (git+https://github.com/flodiebold/chalk.git?branch=fuel)",
+ "chalk-rust-ir 0.1.0 (git+https://github.com/flodiebold/chalk.git?branch=fuel)",
+ "chalk-solve 0.1.0 (git+https://github.com/flodiebold/chalk.git?branch=fuel)",
  "ena 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "flexi_logger 0.11.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "insta 0.7.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "insta 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "join_to_string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1134,7 +1134,7 @@ name = "ra_ide_api"
 version = "0.1.0"
 dependencies = [
  "fst 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "insta 0.7.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "insta 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "jemalloc-ctl 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "jemallocator 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1165,7 +1165,7 @@ dependencies = [
  "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "flexi_logger 0.11.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "gen_lsp_server 0.1.0",
+ "gen_lsp_server 0.2.0",
  "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "lsp-types 0.57.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1211,6 +1211,7 @@ dependencies = [
 name = "ra_prof"
 version = "0.1.0"
 dependencies = [
+ "itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "once_cell 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
@@ -1242,9 +1243,9 @@ dependencies = [
  "ra_parser 0.1.0",
  "ra_text_edit 0.1.0",
  "rowan 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "smol_str 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "smol_str 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
  "test_utils 0.1.0",
- "text_unit 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "text_unit 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "walkdir 2.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -1255,14 +1256,14 @@ version = "0.1.0"
 dependencies = [
  "proptest 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "test_utils 0.1.0",
- "text_unit 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "text_unit 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "ra_tt"
 version = "0.1.0"
 dependencies = [
- "smol_str 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "smol_str 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -1467,8 +1468,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "colosseum 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "smol_str 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
- "text_unit 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "smol_str 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
+ "text_unit 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -1625,7 +1626,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "smol_str"
-version = "0.1.10"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "serde 1.0.91 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1748,12 +1749,12 @@ dependencies = [
  "difference 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_json 1.0.39 (registry+https://github.com/rust-lang/crates.io-index)",
- "text_unit 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "text_unit 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "text_unit"
-version = "0.1.6"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "serde 1.0.91 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -2036,11 +2037,11 @@ dependencies = [
 "checksum cargo_metadata 0.7.4 (registry+https://github.com/rust-lang/crates.io-index)" = "178d62b240c34223f265a4c1e275e37d62da163d421fc8d7f7e3ee340f803c57"
 "checksum cc 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)" = "a0c56216487bb80eec9c4516337b2588a4f2a2290d72a1416d930e4dcdb0c90d"
 "checksum cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "11d43355396e872eefb45ce6342e4374ed7bc2b3a502d1b28e36d6e23c05d1f4"
-"checksum chalk-engine 0.9.0 (git+https://github.com/rust-lang/chalk.git)" = "<none>"
-"checksum chalk-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git)" = "<none>"
-"checksum chalk-macros 0.1.1 (git+https://github.com/rust-lang/chalk.git)" = "<none>"
-"checksum chalk-rust-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git)" = "<none>"
-"checksum chalk-solve 0.1.0 (git+https://github.com/rust-lang/chalk.git)" = "<none>"
+"checksum chalk-engine 0.9.0 (git+https://github.com/flodiebold/chalk.git?branch=fuel)" = "<none>"
+"checksum chalk-ir 0.1.0 (git+https://github.com/flodiebold/chalk.git?branch=fuel)" = "<none>"
+"checksum chalk-macros 0.1.1 (git+https://github.com/flodiebold/chalk.git?branch=fuel)" = "<none>"
+"checksum chalk-rust-ir 0.1.0 (git+https://github.com/flodiebold/chalk.git?branch=fuel)" = "<none>"
+"checksum chalk-solve 0.1.0 (git+https://github.com/flodiebold/chalk.git?branch=fuel)" = "<none>"
 "checksum chrono 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "45912881121cb26fad7c38c17ba7daa18764771836b34fab7d3fbd93ed633878"
 "checksum ci_info 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e5e881307a989a3a5e20d52a32cc05950e3c2178cccfcc9428271a6cde09f902"
 "checksum clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5067f5bb2d80ef5d68b4c87db81601f0b75bca627bc2ef76b141d7b846a3c6d9"
@@ -2087,7 +2088,7 @@ dependencies = [
 "checksum indicatif 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2c60da1c9abea75996b70a931bba6c750730399005b61ccd853cee50ef3d0d0c"
 "checksum inotify 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "40b54539f3910d6f84fbf9a643efd6e3aa6e4f001426c0329576128255994718"
 "checksum inotify-sys 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e74a1aa87c59aeff6ef2cc2fa62d41bc43f54952f55652656b18a02fd5e356c0"
-"checksum insta 0.7.4 (registry+https://github.com/rust-lang/crates.io-index)" = "03e7d88a87d342ce8bd698516151be43e6eb2e84b683db528696cb4a382f734a"
+"checksum insta 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "8bbbb69ec4557c37b2bf4d525d106d828e0c2fbd6c44bc98cd3798da13c73b9f"
 "checksum iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dbe6e417e7d0975db6512b90796e8ce223145ac4e33c377e4a42882a0e88bb08"
 "checksum itertools 0.7.11 (registry+https://github.com/rust-lang/crates.io-index)" = "0d47946d458e94a1b7bcabbf6521ea7c037062c81f534615abcad76e84d4970d"
 "checksum itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5b8467d9c1cebe26feb08c640139247fac215782d35371ade9a2136ed6085358"
@@ -2181,7 +2182,7 @@ dependencies = [
 "checksum slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8"
 "checksum slug 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "b3bc762e6a4b6c6fcaade73e77f9ebc6991b676f88bb2358bddb56560f073373"
 "checksum smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)" = "c4488ae950c49d403731982257768f48fada354a5203fe81f9bb6f43ca9002be"
-"checksum smol_str 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "d077b3367211e9c6e2e012fb804c444e0d80ab5a51ae4137739b58e6446dcaef"
+"checksum smol_str 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "e6507d018aa8dfcaa08aaab587605591cd2109df66a921486a2220e2daf9fa29"
 "checksum stable_deref_trait 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "dba1a27d3efae4351c8051072d619e3ade2820635c3958d826bfea39d59b54c8"
 "checksum stacker 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "fb79482f57cf598af52094ec4cc3b3c42499d3ce5bd426f2ac41515b7e57404b"
 "checksum strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
@@ -2193,7 +2194,7 @@ dependencies = [
 "checksum teraron 0.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0d89ad4617d1dec55331067fadaa041e813479e1779616f3d3ce9308bf46184e"
 "checksum termion 1.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dde0593aeb8d47accea5392b39350015b5eccb12c0d98044d856983d89548dea"
 "checksum termios 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "72b620c5ea021d75a735c943269bb07d30c9b77d6ac6b236bc8b5c496ef05625"
-"checksum text_unit 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "158bb1c22b638b1da3c95a8ad9f061ea40d4d39fd0301be3a520f92efeeb189e"
+"checksum text_unit 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "019e5bc4c698b63073968610964c8c0869b60455d8f2e303a0ee7ad2e4f6ade4"
 "checksum textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
 "checksum thread_local 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c6b53e329000edc2b34dbe8545fd20e55a333362d0a321909685a19bd28c3f1b"
 "checksum threadpool 1.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e2f0c90a5f3459330ac8bc0d2f879c693bb7a2f59689c1083fc4ef83834da865"
diff --git a/README.md b/README.md
index 8df991246..dbc110a90 100644
--- a/README.md
+++ b/README.md
@@ -11,7 +11,8 @@ https://github.com/rust-lang/compiler-team/tree/master/working-groups/rls-2.0
 
 Work on the Rust Analyzer is sponsored by
 
-[![Ferrous Systems](https://ferrous-systems.com/images/ferrous-logo-text.svg)](https://ferrous-systems.com/)
+[<img src="https://user-images.githubusercontent.com/1711539/58105231-cf306900-7bee-11e9-83d8-9f1102e59d29.png" alt="Ferrous Systems" width="300">](https://ferrous-systems.com/)
+- [Mozilla](https://www.mozilla.org/en-US/)
 
 ## Language Server Quick Start
 
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::{
-        L_PAREN, R_PAREN, L_CURLY, R_CURLY, L_BRACK, R_BRACK, EXCL
-    },
+    T
 };
 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 "",
-        L_CURLY => {
+        T!['('] | T!['['] => return "",
+        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 "",
-        R_CURLY => {
+        T![')'] | T![']'] => return "",
+        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-rust-ir = { git = "https://github.com/rust-lang/chalk.git" }
-chalk-ir = { 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/flodiebold/chalk.git", branch = "fuel" }
+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,
-    Function,
-    Name,
+    HirDatabase, 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];
-        if let Some((AdtDef::Struct(s), _)) = struct_ty.as_adt() {
-            let missed_fields: Vec<Name> = s
-                .fields(db)
-                .iter()
-                .filter_map(|f| {
-                    let name = f.name(db);
-                    if lit_fields.contains(&name) {
-                        None
-                    } else {
-                        Some(name)
-                    }
-                })
-                .collect();
-            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_file = db.parse(file_id.original_file(db));
-            if let Some(field_list_node) = source_map
-                .expr_syntax(id)
-                .map(|ptr| ptr.to_node(source_file.syntax()))
-                .and_then(StructLit::cast)
-                .and_then(|lit| lit.named_field_list())
-            {
-                let field_list_ptr = AstPtr::new(field_list_node);
-                self.sink.push(MissingFields {
-                    file: file_id,
-                    field_list: field_list_ptr,
-                    missed_fields,
-                })
-            }
+        let missed_fields: Vec<Name> = struct_def
+            .fields(db)
+            .iter()
+            .filter_map(|f| {
+                let name = f.name(db);
+                if lit_fields.contains(&name) {
+                    None
+                } else {
+                    Some(name)
+                }
+            })
+            .collect();
+        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_file = db.parse(file_id.original_file(db));
+        if let Some(field_list_node) = source_map
+            .expr_syntax(id)
+            .map(|ptr| ptr.to_node(source_file.syntax()))
+            .and_then(StructLit::cast)
+            .and_then(|lit| lit.named_field_list())
+        {
+            let field_list_ptr = AstPtr::new(field_list_node);
+            self.sink.push(MissingFields {
+                file: file_id,
+                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 {
-    let dm = compute_crate_def_map(fixtute, Some(graph));
+fn def_map_with_crate_graph(fixture: &str, graph: CrateGraphFixture) -> String {
+    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
-V: t v
-E: t
-foo: t
-S: t v
-
-crate::foo
-bar: t
-f: v
-
-crate::foo::bar
-Baz: t v
-E: t
-"###
-    )
+        ⋮crate
+        ⋮E: t
+        ⋮S: t v
+        ⋮V: t v
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮bar: t
+        ⋮f: v
+        ⋮
+        ⋮crate::foo::bar
+        ⋮Baz: t v
+        ⋮E: t
+    "###)
 }
 
 #[test]
@@ -113,12 +119,12 @@ fn bogus_paths() {
         ",
     );
     assert_snapshot_matches!(map, @r###"
-crate
-foo: t
-S: t v
-
-crate::foo
-"###
+   ⋮crate
+   ⋮S: t v
+   ⋮foo: t
+   ⋮
+   ⋮crate::foo
+    "###
     )
 }
 
@@ -137,13 +143,13 @@ fn use_as() {
     );
     assert_snapshot_matches!(map,
         @r###"
-crate
-Foo: t v
-foo: t
-
-crate::foo
-Baz: t v
-"###
+   ⋮crate
+   ⋮Foo: t v
+   ⋮foo: t
+   ⋮
+   ⋮crate::foo
+   ⋮Baz: t v
+    "###
     );
 }
 
@@ -164,21 +170,19 @@ fn use_trees() {
         pub enum Quux {};
         ",
     );
-    assert_snapshot_matches!(map,
-        @r###"
-crate
-Quux: t
-Baz: t v
-foo: t
-
-crate::foo
-bar: t
-
-crate::foo::bar
-Quux: t
-Baz: t v
-"###
-    );
+    assert_snapshot_matches!(map, @r###"
+        ⋮crate
+        ⋮Baz: t v
+        ⋮Quux: t
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮bar: t
+        ⋮
+        ⋮crate::foo::bar
+        ⋮Baz: t v
+        ⋮Quux: t
+    "###);
 }
 
 #[test]
@@ -199,20 +203,18 @@ fn re_exports() {
         pub struct Baz;
         ",
     );
-    assert_snapshot_matches!(map,
-        @r###"
-crate
-Baz: t v
-foo: t
-
-crate::foo
-bar: t
-Baz: t v
-
-crate::foo::bar
-Baz: t v
-"###
-    );
+    assert_snapshot_matches!(map, @r###"
+        ⋮crate
+        ⋮Baz: t v
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮Baz: t v
+        ⋮bar: t
+        ⋮
+        ⋮crate::foo::bar
+        ⋮Baz: t v
+    "###);
 }
 
 #[test]
@@ -237,10 +239,10 @@ fn std_prelude() {
         },
     );
     assert_snapshot_matches!(map, @r###"
-crate
-Bar: t v
-Baz: t v
-"###);
+        ⋮crate
+        ⋮Bar: t v
+        ⋮Baz: t v
+    "###);
 }
 
 #[test]
@@ -254,10 +256,10 @@ fn can_import_enum_variant() {
         ",
     );
     assert_snapshot_matches!(map, @r###"
-crate
-V: t v
-E: t
-"###
+        ⋮crate
+        ⋮E: t
+        ⋮V: t v
+    "###
     );
 }
 
@@ -285,20 +287,18 @@ fn edition_2015_imports() {
         },
     );
 
-    assert_snapshot_matches!(map,
-        @r###"
-crate
-bar: t
-foo: t
-
-crate::bar
-Bar: t v
-
-crate::foo
-FromLib: t v
-Bar: t v
-"###
-    );
+    assert_snapshot_matches!(map, @r###"
+        ⋮crate
+        ⋮bar: t
+        ⋮foo: t
+        ⋮
+        ⋮crate::bar
+        ⋮Bar: t v
+        ⋮
+        ⋮crate::foo
+        ⋮Bar: t v
+        ⋮FromLib: t v
+    "###);
 }
 
 #[test]
@@ -317,16 +317,14 @@ fn module_resolution_works_for_non_standard_filenames() {
         },
     );
 
-    assert_snapshot_matches!(map,
-        @r###"
-crate
-Bar: t v
-foo: t
-
-crate::foo
-Bar: t v
-"###
-    );
+    assert_snapshot_matches!(map, @r###"
+        ⋮crate
+        ⋮Bar: t v
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮Bar: t v
+    "###);
 }
 
 #[test]
@@ -348,12 +346,10 @@ fn name_res_works_for_broken_modules() {
         pub struct Baz;
         ",
     );
-    assert_snapshot_matches!(map,
-        @r###"
-crate
-Baz: _
-"###
-    );
+    assert_snapshot_matches!(map, @r###"
+        ⋮crate
+        ⋮Baz: _
+    "###);
 }
 
 #[test]
@@ -369,19 +365,17 @@ fn item_map_using_self() {
         pub struct Baz;
         ",
     );
-    assert_snapshot_matches!(map,
-        @r###"
-crate
-Baz: t v
-foo: t
-
-crate::foo
-bar: t
-
-crate::foo::bar
-Baz: t v
-"###
-    );
+    assert_snapshot_matches!(map, @r###"
+        ⋮crate
+        ⋮Baz: t v
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮bar: t
+        ⋮
+        ⋮crate::foo::bar
+        ⋮Baz: t v
+    "###);
 }
 
 #[test]
@@ -400,12 +394,10 @@ fn item_map_across_crates() {
         },
     );
 
-    assert_snapshot_matches!(map,
-        @r###"
-crate
-Baz: t v
-"###
-    );
+    assert_snapshot_matches!(map, @r###"
+        ⋮crate
+        ⋮Baz: t v
+    "###);
 }
 
 #[test]
@@ -430,12 +422,14 @@ fn extern_crate_rename() {
         },
     );
 
-    assert_snapshot_matches!(map,
-        @r###"
-crate
-Arc: t v
-"###
-    );
+    assert_snapshot_matches!(map, @r###"
+   ⋮crate
+   ⋮alloc_crate: t
+   ⋮sync: t
+   ⋮
+   ⋮crate::sync
+   ⋮Arc: t v
+    "###);
 }
 
 #[test]
@@ -462,9 +456,13 @@ fn extern_crate_rename_2015_edition() {
 
     assert_snapshot_matches!(map,
         @r###"
-crate
-Arc: t v
-"###
+   ⋮crate
+   ⋮alloc_crate: t
+   ⋮sync: t
+   ⋮
+   ⋮crate::sync
+   ⋮Arc: t v
+    "###
     );
 }
 
@@ -490,12 +488,10 @@ fn import_across_source_roots() {
         },
     );
 
-    assert_snapshot_matches!(map,
-        @r###"
-crate
-C: t v
-"###
-    );
+    assert_snapshot_matches!(map, @r###"
+        ⋮crate
+        ⋮C: t v
+    "###);
 }
 
 #[test]
@@ -519,12 +515,10 @@ fn reexport_across_crates() {
         },
     );
 
-    assert_snapshot_matches!(map,
-        @r###"
-crate
-Baz: t v
-"###
-    );
+    assert_snapshot_matches!(map, @r###"
+        ⋮crate
+        ⋮Baz: t v
+    "###);
 }
 
 #[test]
@@ -544,13 +538,11 @@ fn values_dont_shadow_extern_crates() {
         },
     );
 
-    assert_snapshot_matches!(map,
-        @r###"
-crate
-Bar: t v
-foo: v
-"###
-    );
+    assert_snapshot_matches!(map, @r###"
+        ⋮crate
+        ⋮Bar: t 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
-bar: t
-Foo: t v
-Baz: t v
-foo: t
-
-crate::foo
-bar: t
-Foo: t v
-Baz: t v
-
-crate::foo::bar
-Baz: t v
-"###
+   ⋮crate
+   ⋮Baz: t v
+   ⋮Foo: t v
+   ⋮bar: t
+   ⋮foo: t
+   ⋮
+   ⋮crate::foo
+   ⋮Baz: t v
+   ⋮Foo: t v
+   ⋮bar: t
+   ⋮
+   ⋮crate::foo::bar
+   ⋮Baz: t v
+    "###
     );
 }
 
@@ -54,22 +54,22 @@ fn glob_2() {
         ",
     );
     assert_snapshot_matches!(map, @r###"
-crate
-bar: t
-Foo: t v
-Baz: t v
-foo: t
-
-crate::foo
-bar: t
-Foo: t v
-Baz: t v
-
-crate::foo::bar
-bar: t
-Foo: t v
-Baz: t v
-"###
+   ⋮crate
+   ⋮Baz: t v
+   ⋮Foo: t v
+   ⋮bar: t
+   ⋮foo: t
+   ⋮
+   ⋮crate::foo
+   ⋮Baz: t v
+   ⋮Foo: t v
+   ⋮bar: t
+   ⋮
+   ⋮crate::foo::bar
+   ⋮Baz: t v
+   ⋮Foo: t v
+   ⋮bar: t
+    "###
     );
 }
 
@@ -90,9 +90,9 @@ fn glob_across_crates() {
         },
     );
     assert_snapshot_matches!(map, @r###"
-crate
-Baz: t v
-"###
+   ⋮crate
+   ⋮Baz: t v
+    "###
     );
 }
 
@@ -109,10 +109,10 @@ fn glob_enum() {
         ",
     );
     assert_snapshot_matches!(map, @r###"
-crate
-Foo: t
-Bar: t v
-Baz: t v
-"###
+   ⋮crate
+   ⋮Bar: 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
-nested: t
-Foo: t v
-
-crate::nested
-Bar: t v
-Baz: t v
-"###);
+   ⋮crate
+   ⋮Foo: t v
+   ⋮nested: t
+   ⋮
+   ⋮crate::nested
+   ⋮Bar: t v
+   ⋮Baz: t v
+    "###);
 }
 
 #[test]
@@ -45,15 +45,15 @@ fn macro_rules_can_define_modules() {
         ",
     );
     assert_snapshot_matches!(map, @r###"
-crate
-n1: t
-
-crate::n1
-n2: t
-
-crate::n1::n2
-X: t v
-"###);
+   ⋮crate
+   ⋮n1: t
+   ⋮
+   ⋮crate::n1
+   ⋮n2: t
+   ⋮
+   ⋮crate::n1::n2
+   ⋮X: t v
+    "###);
 }
 
 #[test]
@@ -81,14 +81,14 @@ fn macro_rules_from_other_crates_are_visible() {
         },
     );
     assert_snapshot_matches!(map, @r###"
-crate
-bar: t
-Foo: t v
-Bar: t v
-
-crate::bar
-bar: t
-Foo: t v
-Bar: t v
-"###);
+   ⋮crate
+   ⋮Bar: t v
+   ⋮Foo: t v
+   ⋮bar: t
+   ⋮
+   ⋮crate::bar
+   ⋮Bar: t v
+   ⋮Foo: 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 infer::{infer, InferenceResult, InferTy};
+pub(crate) use lower::{TypableDef, type_for_def, type_for_field, callable_item_sig, generic_predicates, generic_defaults};
+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,
-    ModuleDef, TypeAlias,
-    Const, Static,
+    Function, Struct, StructField, Enum, EnumVariant, Path, ModuleDef, TypeAlias, Const, Static,
     HirDatabase,
     type_ref::TypeRef,
     name::KnownName,
     nameres::Namespace,
     resolve::{Resolver, Resolution},
     path::{PathSegment, GenericArg},
-    generics::{GenericParams, HasGenericParams},
-    adt::VariantDef, Trait, generics::{ WherePredicate, GenericDef}
+    generics::{HasGenericParams},
+    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 {
-            TypableDef::Function(func) => func.generic_params(db),
-            TypableDef::Struct(s) => s.generic_params(db),
-            TypableDef::Enum(e) => e.generic_params(db),
-            TypableDef::EnumVariant(var) => var.parent_enum(db).generic_params(db),
-            TypableDef::TypeAlias(t) => t.generic_params(db),
-            TypableDef::Const(_) | TypableDef::Static(_) => GenericParams::default().into(),
+        let def_generic: Option<GenericDef> = match resolved {
+            TypableDef::Function(func) => Some(func.into()),
+            TypableDef::Struct(s) => Some(s.into()),
+            TypableDef::Enum(e) => Some(e.into()),
+            TypableDef::EnumVariant(var) => Some(var.parent_enum(db).into()),
+            TypableDef::TypeAlias(t) => Some(t.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 {
-    let generics = s.generic_params(db);
-    Ty::apply(TypeCtor::Adt(s.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_adt(db: &impl HirDatabase, adt: impl Into<AdtDef> + HasGenericParams) -> Ty {
+    let generics = adt.generic_params(db);
+    Ty::apply(TypeCtor::Adt(adt.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()
-        == SyntaxKind::SELF_KW
-    {
+    if single_use_tree.path()?.segment()?.syntax().first_child_or_token()?.kind() == T![self] {
         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::Brace => ([L_CURLY, R_CURLY], "{}"),
-        tt::Delimiter::Bracket => ([L_BRACK, R_BRACK], "[]"),
+        tt::Delimiter::Parenthesis => ([T!['('], T![')']], "()"),
+        tt::Delimiter::Brace => ([T!['{'], T!['}']], "{}"),
+        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,
-            "false" => SyntaxKind::FALSE_KW,
+            "true" => T![true],
+            "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,
-        ':' => COLON,
-        '=' => EQ,
-        '!' => EXCL,
-        '-' => MINUS,
+        '.' => T![.],
+        ':' => T![:],
+        '=' => T![=],
+        '!' => T![!],
+        '-' => 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),
-        (L_CURLY, R_CURLY) => (tt::Delimiter::Brace, true),
-        (L_BRACK, R_BRACK) => (tt::Delimiter::Bracket, true),
+        (T!['('], T![')']) => (tt::Delimiter::Parenthesis, true),
+        (T!['{'], T!['}']) => (tt::Delimiter::Brace, 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
-                        || token.kind() == SyntaxKind::FALSE_KW
-                    {
-                        tt::Leaf::from(tt::Literal { text: token.text().clone() }).into()
-                    } else if token.kind().is_keyword()
-                        || token.kind() == IDENT
-                        || token.kind() == LIFETIME
-                    {
-                        let relative_range = token.range() - global_offset;
-                        let id = token_map.alloc(relative_range);
-                        let text = token.text().clone();
-                        tt::Leaf::from(tt::Ident { text, id }).into()
-                    } else if token.kind().is_literal() {
-                        tt::Leaf::from(tt::Literal { text: token.text().clone() }).into()
-                    } else {
-                        return None;
-                    };
+                    let child: tt::TokenTree =
+                        if token.kind() == T![true] || token.kind() == T![false] {
+                            tt::Leaf::from(tt::Literal { text: token.text().clone() }).into()
+                        } else if token.kind().is_keyword()
+                            || token.kind() == IDENT
+                            || token.kind() == LIFETIME
+                        {
+                            let relative_range = token.range() - global_offset;
+                            let id = token_map.alloc(relative_range);
+                            let text = token.text().clone();
+                            tt::Leaf::from(tt::Ident { text, id }).into()
+                        } else if token.kind().is_literal() {
+                            tt::Leaf::from(tt::Literal { text: token.text().clone() }).into()
+                        } else {
+                            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(),
-                EQ => {
+                IDENT | T![::] | T![super] | T![self] | T![crate] => p.bump(),
+                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) {
-                    p.eat(SEMI);
+                if p.at(T![;]) {
+                    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) {
-                    p.eat(SEMI);
+                if p.at(T![;]) {
+                    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)),
-            (R_ANGLE, R_ANGLE, EQ) => return (1, Op::Composite(SHREQ, 3)),
+            (T![<], T![<], T![=]) => return (1, Op::Composite(T![<<=], 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)),
-            (MINUS, EQ) => return (1, Op::Composite(MINUSEQ, 2)),
-            (STAR, EQ) => return (1, Op::Composite(STAREQ, 2)),
-            (PERCENT, EQ) => return (1, Op::Composite(PERCENTEQ, 2)),
-            (SLASH, EQ) => return (1, Op::Composite(SLASHEQ, 2)),
-            (PIPE, EQ) => return (1, Op::Composite(PIPEEQ, 2)),
-            (AMP, EQ) => return (1, Op::Composite(AMPEQ, 2)),
-            (CARET, EQ) => return (1, Op::Composite(CARETEQ, 2)),
-            (PIPE, PIPE) => return (3, Op::Composite(PIPEPIPE, 2)),
-            (AMP, AMP) => return (4, Op::Composite(AMPAMP, 2)),
-            (L_ANGLE, EQ) => return (5, Op::Composite(LTEQ, 2)),
-            (R_ANGLE, EQ) => return (5, Op::Composite(GTEQ, 2)),
-            (L_ANGLE, L_ANGLE) => return (9, Op::Composite(SHL, 2)),
-            (R_ANGLE, R_ANGLE) => return (9, Op::Composite(SHR, 2)),
+            (T![+], T![=]) => return (1, Op::Composite(T![+=], 2)),
+            (T![-], T![=]) => return (1, Op::Composite(T![-=], 2)),
+            (T![*], T![=]) => return (1, Op::Composite(T![*=], 2)),
+            (T![%], T![=]) => return (1, Op::Composite(T![%=], 2)),
+            (T![/], T![=]) => return (1, Op::Composite(T![/=], 2)),
+            (T![|], T![=]) => return (1, Op::Composite(T![|=], 2)),
+            (T![&], T![=]) => return (1, Op::Composite(T![&=], 2)),
+            (T![^], T![=]) => return (1, Op::Composite(T![^=], 2)),
+            (T![|], T![|]) => return (3, Op::Composite(T![||], 2)),
+            (T![&], T![&]) => return (4, Op::Composite(T![&&], 2)),
+            (T![<], T![=]) => return (5, Op::Composite(T![<=], 2)),
+            (T![>], T![=]) => return (5, Op::Composite(T![>=], 2)),
+            (T![<], T![<]) => return (9, Op::Composite(T![<<], 2)),
+            (T![>], T![>]) => return (9, Op::Composite(T![>>], 2)),
             _ => (),
         }
     }
 
     let bp = match p.current() {
-        EQ => 1,
-        DOTDOT | DOTDOTEQ => 2,
-        EQEQ | NEQ | L_ANGLE | R_ANGLE => 5,
-        PIPE => 6,
-        CARET => 7,
-        AMP => 8,
-        MINUS | PLUS => 10,
-        STAR | SLASH | PERCENT => 11,
+        T![=] => 1,
+        T![..] | T![..=] => 2,
+        T![==] | T![!=] | T![<] | T![>] => 5,
+        T![|] => 6,
+        T![^] => 7,
+        T![&] => 8,
+        T![-] | T![+] => 10,
+        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),
-            L_BRACK if allow_calls => index_expr(p, lhs),
-            DOT if p.nth(1) == IDENT && (p.nth(2) == L_PAREN || p.nth(2) == COLONCOLON) => {
+            T!['('] if allow_calls => call_expr(p, lhs),
+            T!['['] if allow_calls => index_expr(p, lhs),
+            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),
-            AS_KW => cast_expr(p, lhs),
+            T![?] => try_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) {
-            p.expect(COMMA);
+        if !p.at(T!['}']) {
+            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),
-        L_BRACK => array_expr(p),
-        PIPE => lambda_expr(p),
-        MOVE_KW if la == PIPE => lambda_expr(p),
-        ASYNC_KW if la == PIPE || (la == MOVE_KW && p.nth(2) == PIPE) => lambda_expr(p),
-        IF_KW => if_expr(p),
+        T!['('] => tuple_expr(p),
+        T!['['] => array_expr(p),
+        T![|] => lambda_expr(p),
+        T![move] if la == T![|] => lambda_expr(p),
+        T![async] if la == T![|] || (la == T![move] && p.nth(2) == T![|]) => lambda_expr(p),
+        T![if] => if_expr(p),
 
-        LOOP_KW => loop_expr(p, None),
-        FOR_KW => for_expr(p, None),
-        WHILE_KW => while_expr(p, None),
-        LIFETIME if la == COLON => {
+        T![loop] => loop_expr(p, None),
+        T![for] => for_expr(p, None),
+        T![while] => while_expr(p, None),
+        LIFETIME if la == T![:] => {
             let m = p.start();
             label(p);
             match p.current() {
-                LOOP_KW => loop_expr(p, Some(m)),
-                FOR_KW => for_expr(p, Some(m)),
-                WHILE_KW => while_expr(p, Some(m)),
-                L_CURLY => block_expr(p, Some(m)),
+                T![loop] => loop_expr(p, Some(m)),
+                T![for] => for_expr(p, Some(m)),
+                T![while] => while_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),
-        UNSAFE_KW if la == L_CURLY => {
+        T![match] => match_expr(p),
+        T![unsafe] if la == T!['{'] => {
             let m = p.start();
             p.bump();
             block_expr(p, Some(m))
         }
-        L_CURLY => block_expr(p, None),
-        RETURN_KW => return_expr(p),
-        CONTINUE_KW => continue_expr(p),
-        BREAK_KW => break_expr(p, r),
+        T!['{'] => block_expr(p, None),
+        T![return] => return_expr(p),
+        T![continue] => continue_expr(p),
+        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) {
-        p.expect(COMMA);
-        if p.at(R_BRACK) {
+    while !p.at(EOF) && !p.at(T![']']) {
+        p.expect(T![,]);
+        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(MOVE_KW) && p.nth(1) == PIPE)
-            || (p.at(ASYNC_KW) && p.nth(1) == PIPE)
-            || (p.at(ASYNC_KW) && p.nth(1) == MOVE_KW && p.nth(2) == PIPE)
+        p.at(T![|])
+            || (p.at(T![move]) && p.nth(1) == T![|])
+            || (p.at(T![async]) && p.nth(1) == T![|])
+            || (p.at(T![async]) && p.nth(1) == T![move] && p.nth(2) == T![|])
     );
     let m = p.start();
-    p.eat(ASYNC_KW);
-    p.eat(MOVE_KW);
+    p.eat(T![async]);
+    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) {
-        if p.at(L_CURLY) {
+    while !p.at(EOF) && !p.at(T!['}']) {
+        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);
-        } else if !p.at(R_CURLY) {
-            p.expect(COMMA);
+            p.eat(T![,]);
+        } else if !p.at(T!['}']) {
+            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);