63 files changed, 1211 insertions, 892 deletions

diff --git a/.gitignore b/.gitignore
index aef0fac33..472fe1a13 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,6 +7,5 @@ crates/*/target
 *.log
 *.iml
 .vscode/settings.json
-*.html
 generated_assists.adoc
 generated_features.adoc
diff --git a/Cargo.lock b/Cargo.lock
index a70c22a94..b19d697f5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -30,7 +30,7 @@ version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
 dependencies = [
- "winapi 0.3.8",
+ "winapi 0.3.9",
 ]
 
 [[package]]
@@ -135,8 +135,9 @@ checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
 
 [[package]]
 name = "chalk-derive"
-version = "0.15.0-dev.0"
-source = "git+https://github.com/rust-lang/chalk#57037a53f7decc965d25972606c3ea930e9cb39f"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7379caa72d04103fcfd9bde5642b816f58e3ffd6a0d39347e9e35a066648226"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -146,8 +147,9 @@ dependencies = [
 
 [[package]]
 name = "chalk-engine"
-version = "0.15.0-dev.0"
-source = "git+https://github.com/rust-lang/chalk#57037a53f7decc965d25972606c3ea930e9cb39f"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e8afe48b5663504b485791ab4fae69cf4864869a71ceec9c758fd4d03423722"
 dependencies = [
  "chalk-derive",
  "chalk-ir",
@@ -157,8 +159,9 @@ dependencies = [
 
 [[package]]
 name = "chalk-ir"
-version = "0.15.0-dev.0"
-source = "git+https://github.com/rust-lang/chalk#57037a53f7decc965d25972606c3ea930e9cb39f"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "231e391a03c1fc45874171d92be9542efedc939bac59d9501ee28b9521feb406"
 dependencies = [
  "chalk-derive",
  "lazy_static",
@@ -166,8 +169,9 @@ dependencies = [
 
 [[package]]
 name = "chalk-solve"
-version = "0.15.0-dev.0"
-source = "git+https://github.com/rust-lang/chalk#57037a53f7decc965d25972606c3ea930e9cb39f"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72c969c0fd06ad50538253327ca3445ff02cc9d0209f94c3cbf198ad9d365b48"
 dependencies = [
  "chalk-derive",
  "chalk-engine",
@@ -554,9 +558,9 @@ dependencies = [
 
 [[package]]
 name = "instant"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7777a24a1ce5de49fcdde84ec46efa487c3af49d5b6e6e0a50367cc5c1096182"
+checksum = "69da7ce1490173c2bf4d26bc8be429aaeeaf4cce6c4b970b7949651fa17655fe"
 
 [[package]]
 name = "iovec"
@@ -1791,7 +1795,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ca8a50ef2360fbd1eeb0ecd46795a87a19024eb4b53c5dc916ca1fd95fe62438"
 dependencies = [
  "libc",
- "winapi 0.3.8",
+ "winapi 0.3.9",
 ]
 
 [[package]]
diff --git a/crates/flycheck/src/lib.rs b/crates/flycheck/src/lib.rs
index 92ec4f92e..1023d3040 100644
--- a/crates/flycheck/src/lib.rs
+++ b/crates/flycheck/src/lib.rs
@@ -5,8 +5,9 @@
 use std::{
     fmt,
     io::{self, BufReader},
+    ops,
     path::PathBuf,
-    process::{Command, Stdio},
+    process::{self, Command, Stdio},
     time::Duration,
 };
 
@@ -49,8 +50,8 @@ impl fmt::Display for FlycheckConfig {
 #[derive(Debug)]
 pub struct FlycheckHandle {
     // XXX: drop order is significant
-    cmd_send: Sender<Restart>,
-    handle: jod_thread::JoinHandle,
+    sender: Sender<Restart>,
+    thread: jod_thread::JoinHandle,
 }
 
 impl FlycheckHandle {
@@ -59,16 +60,15 @@ impl FlycheckHandle {
         config: FlycheckConfig,
         workspace_root: PathBuf,
     ) -> FlycheckHandle {
-        let (cmd_send, cmd_recv) = unbounded::<Restart>();
-        let handle = jod_thread::spawn(move || {
-            FlycheckActor::new(sender, config, workspace_root).run(cmd_recv);
-        });
-        FlycheckHandle { cmd_send, handle }
+        let actor = FlycheckActor::new(sender, config, workspace_root);
+        let (sender, receiver) = unbounded::<Restart>();
+        let thread = jod_thread::spawn(move || actor.run(receiver));
+        FlycheckHandle { sender, thread }
     }
 
     /// Schedule a re-start of the cargo check worker.
     pub fn update(&self) {
-        self.cmd_send.send(Restart).unwrap();
+        self.sender.send(Restart).unwrap();
     }
 }
 
@@ -85,7 +85,7 @@ pub enum Message {
 pub enum Progress {
     DidStart,
     DidCheckCrate(String),
-    DidFinish,
+    DidFinish(io::Result<()>),
     DidCancel,
 }
 
@@ -100,8 +100,7 @@ struct FlycheckActor {
     /// doesn't provide a way to read sub-process output without blocking, so we
     /// have to wrap sub-processes output handling in a thread and pass messages
     /// back over a channel.
-    // XXX: drop order is significant
-    check_process: Option<(Receiver<cargo_metadata::Message>, jod_thread::JoinHandle)>,
+    cargo_handle: Option<CargoHandle>,
 }
 
 enum Event {
@@ -115,29 +114,36 @@ impl FlycheckActor {
         config: FlycheckConfig,
         workspace_root: PathBuf,
     ) -> FlycheckActor {
-        FlycheckActor { sender, config, workspace_root, check_process: None }
+        FlycheckActor { sender, config, workspace_root, cargo_handle: None }
     }
     fn next_event(&self, inbox: &Receiver<Restart>) -> Option<Event> {
-        let check_chan = self.check_process.as_ref().map(|(chan, _thread)| chan);
+        let check_chan = self.cargo_handle.as_ref().map(|cargo| &cargo.receiver);
         select! {
             recv(inbox) -> msg => msg.ok().map(Event::Restart),
             recv(check_chan.unwrap_or(&never())) -> msg => Some(Event::CheckEvent(msg.ok())),
         }
     }
-    fn run(&mut self, inbox: Receiver<Restart>) {
+    fn run(mut self, inbox: Receiver<Restart>) {
         while let Some(event) = self.next_event(&inbox) {
             match event {
                 Event::Restart(Restart) => {
                     while let Ok(Restart) = inbox.recv_timeout(Duration::from_millis(50)) {}
+
                     self.cancel_check_process();
-                    self.check_process = Some(self.start_check_process());
-                    self.send(Message::Progress(Progress::DidStart));
+
+                    let mut command = self.check_command();
+                    command.stdout(Stdio::piped()).stderr(Stdio::null()).stdin(Stdio::null());
+                    if let Ok(child) = command.spawn().map(JodChild) {
+                        self.cargo_handle = Some(CargoHandle::spawn(child));
+                        self.send(Message::Progress(Progress::DidStart));
+                    }
                 }
                 Event::CheckEvent(None) => {
                     // Watcher finished, replace it with a never channel to
                     // avoid busy-waiting.
-                    assert!(self.check_process.take().is_some());
-                    self.send(Message::Progress(Progress::DidFinish));
+                    let cargo_handle = self.cargo_handle.take().unwrap();
+                    let res = cargo_handle.join();
+                    self.send(Message::Progress(Progress::DidFinish(res)));
                 }
                 Event::CheckEvent(Some(message)) => match message {
                     cargo_metadata::Message::CompilerArtifact(msg) => {
@@ -162,11 +168,11 @@ impl FlycheckActor {
         self.cancel_check_process();
     }
     fn cancel_check_process(&mut self) {
-        if self.check_process.take().is_some() {
+        if self.cargo_handle.take().is_some() {
             self.send(Message::Progress(Progress::DidCancel));
         }
     }
-    fn start_check_process(&self) -> (Receiver<cargo_metadata::Message>, jod_thread::JoinHandle) {
+    fn check_command(&self) -> Command {
         let mut cmd = match &self.config {
             FlycheckConfig::CargoCommand {
                 command,
@@ -198,33 +204,7 @@ impl FlycheckActor {
             }
         };
         cmd.current_dir(&self.workspace_root);
-
-        let (message_send, message_recv) = unbounded();
-        let thread = jod_thread::spawn(move || {
-            // If we trigger an error here, we will do so in the loop instead,
-            // which will break out of the loop, and continue the shutdown
-            let res = run_cargo(cmd, &mut |message| {
-                // Skip certain kinds of messages to only spend time on what's useful
-                match &message {
-                    cargo_metadata::Message::CompilerArtifact(artifact) if artifact.fresh => {
-                        return true
-                    }
-                    cargo_metadata::Message::BuildScriptExecuted(_)
-                    | cargo_metadata::Message::Unknown => return true,
-                    _ => {}
-                }
-
-                // if the send channel was closed, we want to shutdown
-                message_send.send(message).is_ok()
-            });
-
-            if let Err(err) = res {
-                // FIXME: make the `message_send` to be `Sender<Result<CheckEvent, CargoError>>`
-                // to display user-caused misconfiguration errors instead of just logging them here
-                log::error!("Cargo watcher failed {:?}", err);
-            }
-        });
-        (message_recv, thread)
+        cmd
     }
 
     fn send(&self, check_task: Message) {
@@ -232,54 +212,104 @@ impl FlycheckActor {
     }
 }
 
-fn run_cargo(
-    mut command: Command,
-    on_message: &mut dyn FnMut(cargo_metadata::Message) -> bool,
-) -> io::Result<()> {
-    let mut child =
-        command.stdout(Stdio::piped()).stderr(Stdio::null()).stdin(Stdio::null()).spawn()?;
+struct CargoHandle {
+    child: JodChild,
+    #[allow(unused)]
+    thread: jod_thread::JoinHandle<io::Result<bool>>,
+    receiver: Receiver<cargo_metadata::Message>,
+}
 
-    // We manually read a line at a time, instead of using serde's
-    // stream deserializers, because the deserializer cannot recover
-    // from an error, resulting in it getting stuck, because we try to
-    // be resillient against failures.
-    //
-    // Because cargo only outputs one JSON object per line, we can
-    // simply skip a line if it doesn't parse, which just ignores any
-    // erroneus output.
-    let stdout = BufReader::new(child.stdout.take().unwrap());
-    let mut read_at_least_one_message = false;
-    for message in cargo_metadata::Message::parse_stream(stdout) {
-        let message = match message {
-            Ok(message) => message,
-            Err(err) => {
-                log::error!("Invalid json from cargo check, ignoring ({})", err);
-                continue;
-            }
-        };
+impl CargoHandle {
+    fn spawn(mut child: JodChild) -> CargoHandle {
+        let child_stdout = child.stdout.take().unwrap();
+        let (sender, receiver) = unbounded();
+        let actor = CargoActor::new(child_stdout, sender);
+        let thread = jod_thread::spawn(move || actor.run());
+        CargoHandle { child, thread, receiver }
+    }
+    fn join(mut self) -> io::Result<()> {
+        // It is okay to ignore the result, as it only errors if the process is already dead
+        let _ = self.child.kill();
+        let exit_status = self.child.wait()?;
+        let read_at_least_one_message = self.thread.join()?;
+        if !exit_status.success() && !read_at_least_one_message {
+            // FIXME: Read the stderr to display the reason, see `read2()` reference in PR comment:
+            // https://github.com/rust-analyzer/rust-analyzer/pull/3632#discussion_r395605298
+            return Err(io::Error::new(
+                io::ErrorKind::Other,
+                format!(
+                    "Cargo watcher failed,the command produced no valid metadata (exit code: {:?})",
+                    exit_status
+                ),
+            ));
+        }
+        Ok(())
+    }
+}
+
+struct CargoActor {
+    child_stdout: process::ChildStdout,
+    sender: Sender<cargo_metadata::Message>,
+}
+
+impl CargoActor {
+    fn new(
+        child_stdout: process::ChildStdout,
+        sender: Sender<cargo_metadata::Message>,
+    ) -> CargoActor {
+        CargoActor { child_stdout, sender }
+    }
+    fn run(self) -> io::Result<bool> {
+        // We manually read a line at a time, instead of using serde's
+        // stream deserializers, because the deserializer cannot recover
+        // from an error, resulting in it getting stuck, because we try to
+        // be resilient against failures.
+        //
+        // Because cargo only outputs one JSON object per line, we can
+        // simply skip a line if it doesn't parse, which just ignores any
+        // erroneus output.
+        let stdout = BufReader::new(self.child_stdout);
+        let mut read_at_least_one_message = false;
+        for message in cargo_metadata::Message::parse_stream(stdout) {
+            let message = match message {
+                Ok(message) => message,
+                Err(err) => {
+                    log::error!("Invalid json from cargo check, ignoring ({})", err);
+                    continue;
+                }
+            };
 
-        read_at_least_one_message = true;
+            read_at_least_one_message = true;
 
-        if !on_message(message) {
-            break;
+            // Skip certain kinds of messages to only spend time on what's useful
+            match &message {
+                cargo_metadata::Message::CompilerArtifact(artifact) if artifact.fresh => (),
+                cargo_metadata::Message::BuildScriptExecuted(_)
+                | cargo_metadata::Message::Unknown => (),
+                _ => self.sender.send(message).unwrap(),
+            }
         }
+        Ok(read_at_least_one_message)
     }
+}
 
-    // It is okay to ignore the result, as it only errors if the process is already dead
-    let _ = child.kill();
+struct JodChild(process::Child);
 
-    let exit_status = child.wait()?;
-    if !exit_status.success() && !read_at_least_one_message {
-        // FIXME: Read the stderr to display the reason, see `read2()` reference in PR comment:
-        // https://github.com/rust-analyzer/rust-analyzer/pull/3632#discussion_r395605298
-        return Err(io::Error::new(
-            io::ErrorKind::Other,
-            format!(
-                "the command produced no valid metadata (exit code: {:?}): {:?}",
-                exit_status, command
-            ),
-        ));
+impl ops::Deref for JodChild {
+    type Target = process::Child;
+    fn deref(&self) -> &process::Child {
+        &self.0
     }
+}
 
-    Ok(())
+impl ops::DerefMut for JodChild {
+    fn deref_mut(&mut self) -> &mut process::Child {
+        &mut self.0
+    }
+}
+
+impl Drop for JodChild {
+    fn drop(&mut self) {
+        let _ = self.0.kill();
+    }
 }
diff --git a/crates/ra_assists/src/handlers/change_visibility.rs b/crates/ra_assists/src/handlers/change_visibility.rs
index c21d75be0..157c7b665 100644
--- a/crates/ra_assists/src/handlers/change_visibility.rs
+++ b/crates/ra_assists/src/handlers/change_visibility.rs
@@ -1,15 +1,12 @@
 use ra_syntax::{
     ast::{self, NameOwner, VisibilityOwner},
     AstNode,
-    SyntaxKind::{
-        ATTR, COMMENT, CONST_DEF, ENUM_DEF, FN_DEF, MODULE, STRUCT_DEF, TRAIT_DEF, VISIBILITY,
-        WHITESPACE,
-    },
-    SyntaxNode, TextSize, T,
+    SyntaxKind::{CONST_DEF, ENUM_DEF, FN_DEF, MODULE, STRUCT_DEF, TRAIT_DEF, VISIBILITY},
+    T,
 };
 use test_utils::mark;
 
-use crate::{AssistContext, AssistId, Assists};
+use crate::{utils::vis_offset, AssistContext, AssistId, Assists};
 
 // Assist: change_visibility
 //
@@ -30,9 +27,8 @@ pub(crate) fn change_visibility(acc: &mut Assists, ctx: &AssistContext) -> Optio
 }
 
 fn add_vis(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let item_keyword = ctx.token_at_offset().find(|leaf| match leaf.kind() {
-        T![const] | T![fn] | T![mod] | T![struct] | T![enum] | T![trait] => true,
-        _ => false,
+    let item_keyword = ctx.token_at_offset().find(|leaf| {
+        matches!(leaf.kind(), T![const] | T![fn] | T![mod] | T![struct] | T![enum] | T![trait])
     });
 
     let (offset, target) = if let Some(keyword) = item_keyword {
@@ -71,17 +67,6 @@ fn add_vis(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     })
 }
 
-fn vis_offset(node: &SyntaxNode) -> TextSize {
-    node.children_with_tokens()
-        .skip_while(|it| match it.kind() {
-            WHITESPACE | COMMENT | ATTR => true,
-            _ => false,
-        })
-        .next()
-        .map(|it| it.text_range().start())
-        .unwrap_or_else(|| node.text_range().start())
-}
-
 fn change_vis(acc: &mut Assists, vis: ast::Visibility) -> Option<()> {
     if vis.syntax().text() == "pub" {
         let target = vis.syntax().text_range();
diff --git a/crates/ra_assists/src/handlers/fix_visibility.rs b/crates/ra_assists/src/handlers/fix_visibility.rs
index 54601d1f3..19d4dac5e 100644
--- a/crates/ra_assists/src/handlers/fix_visibility.rs
+++ b/crates/ra_assists/src/handlers/fix_visibility.rs
@@ -1,12 +1,8 @@
 use hir::{db::HirDatabase, HasSource, HasVisibility, PathResolution};
 use ra_db::FileId;
-use ra_syntax::{
-    ast, AstNode,
-    SyntaxKind::{ATTR, COMMENT, WHITESPACE},
-    SyntaxNode, TextRange, TextSize,
-};
+use ra_syntax::{ast, AstNode, TextRange, TextSize};
 
-use crate::{AssistContext, AssistId, Assists};
+use crate::{utils::vis_offset, AssistContext, AssistId, Assists};
 
 // FIXME: this really should be a fix for diagnostic, rather than an assist.
 
@@ -177,17 +173,6 @@ fn target_data_for_def(
     Some((offset, target, target_file, target_name))
 }
 
-fn vis_offset(node: &SyntaxNode) -> TextSize {
-    node.children_with_tokens()
-        .skip_while(|it| match it.kind() {
-            WHITESPACE | COMMENT | ATTR => true,
-            _ => false,
-        })
-        .next()
-        .map(|it| it.text_range().start())
-        .unwrap_or_else(|| node.text_range().start())
-}
-
 #[cfg(test)]
 mod tests {
     use crate::tests::{check_assist, check_assist_not_applicable};
diff --git a/crates/ra_assists/src/handlers/merge_match_arms.rs b/crates/ra_assists/src/handlers/merge_match_arms.rs
index ca04ec671..90ce66378 100644
--- a/crates/ra_assists/src/handlers/merge_match_arms.rs
+++ b/crates/ra_assists/src/handlers/merge_match_arms.rs
@@ -81,10 +81,7 @@ pub(crate) fn merge_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option
 }
 
 fn contains_placeholder(a: &ast::MatchArm) -> bool {
-    match a.pat() {
-        Some(ra_syntax::ast::Pat::PlaceholderPat(..)) => true,
-        _ => false,
-    }
+    matches!(a.pat(), Some(ast::Pat::PlaceholderPat(..)))
 }
 
 #[cfg(test)]
diff --git a/crates/ra_assists/src/handlers/reorder_fields.rs b/crates/ra_assists/src/handlers/reorder_fields.rs
index 897da2832..bc58ce5fe 100644
--- a/crates/ra_assists/src/handlers/reorder_fields.rs
+++ b/crates/ra_assists/src/handlers/reorder_fields.rs
@@ -1,7 +1,7 @@
-use std::collections::HashMap;
+use itertools::Itertools;
+use rustc_hash::FxHashMap;
 
 use hir::{Adt, ModuleDef, PathResolution, Semantics, Struct};
-use itertools::Itertools;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{algo, ast, match_ast, AstNode, SyntaxKind, SyntaxKind::*, SyntaxNode};
 
@@ -87,7 +87,7 @@ fn struct_definition(path: &ast::Path, sema: &Semantics<RootDatabase>) -> Option
     }
 }
 
-fn compute_fields_ranks(path: &ast::Path, ctx: &AssistContext) -> Option<HashMap<String, usize>> {
+fn compute_fields_ranks(path: &ast::Path, ctx: &AssistContext) -> Option<FxHashMap<String, usize>> {
     Some(
         struct_definition(path, &ctx.sema)?
             .fields(ctx.db)
diff --git a/crates/ra_assists/src/utils.rs b/crates/ra_assists/src/utils.rs
index b7c45a619..02de902d6 100644
--- a/crates/ra_assists/src/utils.rs
+++ b/crates/ra_assists/src/utils.rs
@@ -7,7 +7,9 @@ use hir::{Adt, Crate, Enum, ScopeDef, Semantics, Trait, Type};
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
     ast::{self, make, NameOwner},
-    AstNode, SyntaxNode, T,
+    AstNode,
+    SyntaxKind::*,
+    SyntaxNode, TextSize, T,
 };
 use rustc_hash::FxHashSet;
 
@@ -120,6 +122,13 @@ pub(crate) fn resolve_target_trait(
     }
 }
 
+pub(crate) fn vis_offset(node: &SyntaxNode) -> TextSize {
+    node.children_with_tokens()
+        .find(|it| !matches!(it.kind(), WHITESPACE | COMMENT | ATTR))
+        .map(|it| it.text_range().start())
+        .unwrap_or_else(|| node.text_range().start())
+}
+
 pub(crate) fn invert_boolean_expression(expr: ast::Expr) -> ast::Expr {
     if let Some(expr) = invert_special_case(&expr) {
         return expr;
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index a379b9f49..e86077dd6 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -26,8 +26,10 @@ use hir_ty::{
     autoderef,
     display::{HirDisplayError, HirFormatter},
     expr::ExprValidator,
-    method_resolution, ApplicationTy, Canonical, GenericPredicate, InEnvironment, Substs,
-    TraitEnvironment, Ty, TyDefId, TypeCtor,
+    method_resolution,
+    unsafe_validation::UnsafeValidator,
+    ApplicationTy, Canonical, GenericPredicate, InEnvironment, Substs, TraitEnvironment, Ty,
+    TyDefId, TypeCtor,
 };
 use ra_db::{CrateId, CrateName, Edition, FileId};
 use ra_prof::profile;
@@ -541,7 +543,7 @@ impl_froms!(Adt: Struct, Union, Enum);
 impl Adt {
     pub fn has_non_default_type_params(self, db: &dyn HirDatabase) -> bool {
         let subst = db.generic_defaults(self.into());
-        subst.iter().any(|ty| ty == &Ty::Unknown)
+        subst.iter().any(|ty| &ty.value == &Ty::Unknown)
     }
 
     /// Turns this ADT into a type. Any type parameters of the ADT will be
@@ -677,7 +679,9 @@ impl Function {
         let _p = profile("Function::diagnostics");
         let infer = db.infer(self.id.into());
         infer.add_diagnostics(db, self.id, sink);
-        let mut validator = ExprValidator::new(self.id, infer, sink);
+        let mut validator = ExprValidator::new(self.id, infer.clone(), sink);
+        validator.validate_body(db);
+        let mut validator = UnsafeValidator::new(self.id, infer, sink);
         validator.validate_body(db);
     }
 }
@@ -771,7 +775,7 @@ pub struct TypeAlias {
 impl TypeAlias {
     pub fn has_non_default_type_params(self, db: &dyn HirDatabase) -> bool {
         let subst = db.generic_defaults(self.id.into());
-        subst.iter().any(|ty| ty == &Ty::Unknown)
+        subst.iter().any(|ty| &ty.value == &Ty::Unknown)
     }
 
     pub fn module(self, db: &dyn HirDatabase) -> Module {
@@ -1031,7 +1035,10 @@ impl TypeParam {
         let local_idx = hir_ty::param_idx(db, self.id)?;
         let resolver = self.id.parent.resolver(db.upcast());
         let environment = TraitEnvironment::lower(db, &resolver);
-        params.get(local_idx).cloned().map(|ty| Type {
+        let ty = params.get(local_idx)?.clone();
+        let subst = Substs::type_params(db, self.id.parent);
+        let ty = ty.subst(&subst.prefix(local_idx));
+        Some(Type {
             krate: self.id.parent.module(db.upcast()).krate,
             ty: InEnvironment { value: ty, environment },
         })
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index a7e2e0982..c6bc85e2f 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -176,6 +176,7 @@ impl ExprCollector<'_> {
         if !self.expander.is_cfg_enabled(&expr) {
             return self.missing_expr();
         }
+
         match expr {
             ast::Expr::IfExpr(e) => {
                 let then_branch = self.collect_block_opt(e.then_branch());
@@ -218,8 +219,12 @@ impl ExprCollector<'_> {
                     let body = self.collect_block_opt(e.block_expr());
                     self.alloc_expr(Expr::TryBlock { body }, syntax_ptr)
                 }
+                ast::Effect::Unsafe(_) => {
+                    let body = self.collect_block_opt(e.block_expr());
+                    self.alloc_expr(Expr::Unsafe { body }, syntax_ptr)
+                }
                 // FIXME: we need to record these effects somewhere...
-                ast::Effect::Async(_) | ast::Effect::Label(_) | ast::Effect::Unsafe(_) => {
+                ast::Effect::Async(_) | ast::Effect::Label(_) => {
                     self.collect_block_opt(e.block_expr())
                 }
             },
@@ -445,7 +450,6 @@ impl ExprCollector<'_> {
                     Mutability::from_mutable(e.mut_token().is_some())
                 };
                 let rawness = Rawness::from_raw(raw_tok);
-
                 self.alloc_expr(Expr::Ref { expr, rawness, mutability }, syntax_ptr)
             }
             ast::Expr::PrefixExpr(e) => {
diff --git a/crates/ra_hir_def/src/expr.rs b/crates/ra_hir_def/src/expr.rs
index ca49b26d1..e41cfc16b 100644
--- a/crates/ra_hir_def/src/expr.rs
+++ b/crates/ra_hir_def/src/expr.rs
@@ -150,6 +150,9 @@ pub enum Expr {
     Tuple {
         exprs: Vec<ExprId>,
     },
+    Unsafe {
+        body: ExprId,
+    },
     Array(Array),
     Literal(Literal),
 }
@@ -247,7 +250,7 @@ impl Expr {
                     f(*expr);
                 }
             }
-            Expr::TryBlock { body } => f(*body),
+            Expr::TryBlock { body } | Expr::Unsafe { body } => f(*body),
             Expr::Loop { body, .. } => f(*body),
             Expr::While { condition, body, .. } => {
                 f(*condition);
diff --git a/crates/ra_hir_expand/src/builtin_macro.rs b/crates/ra_hir_expand/src/builtin_macro.rs
index b50eb347c..626f9efd0 100644
--- a/crates/ra_hir_expand/src/builtin_macro.rs
+++ b/crates/ra_hir_expand/src/builtin_macro.rs
@@ -99,6 +99,8 @@ register_builtin! {
     EAGER:
     (concat, Concat) => concat_expand,
     (include, Include) => include_expand,
+    (include_bytes, IncludeBytes) => include_bytes_expand,
+    (include_str, IncludeStr) => include_str_expand,
     (env, Env) => env_expand,
     (option_env, OptionEnv) => option_env_expand
 }
@@ -292,11 +294,16 @@ fn concat_expand(
     Ok((quote!(#text), FragmentKind::Expr))
 }
 
-fn relative_file(db: &dyn AstDatabase, call_id: MacroCallId, path: &str) -> Option<FileId> {
+fn relative_file(
+    db: &dyn AstDatabase,
+    call_id: MacroCallId,
+    path: &str,
+    allow_recursion: bool,
+) -> Option<FileId> {
     let call_site = call_id.as_file().original_file(db);
     let res = db.resolve_path(call_site, path)?;
     // Prevent include itself
-    if res == call_site {
+    if res == call_site && !allow_recursion {
         None
     } else {
         Some(res)
@@ -319,8 +326,8 @@ fn include_expand(
     tt: &tt::Subtree,
 ) -> Result<(tt::Subtree, FragmentKind), mbe::ExpandError> {
     let path = parse_string(tt)?;
-    let file_id =
-        relative_file(db, arg_id.into(), &path).ok_or_else(|| mbe::ExpandError::ConversionError)?;
+    let file_id = relative_file(db, arg_id.into(), &path, false)
+        .ok_or_else(|| mbe::ExpandError::ConversionError)?;
 
     // FIXME:
     // Handle include as expression
@@ -331,6 +338,48 @@ fn include_expand(
     Ok((res, FragmentKind::Items))
 }
 
+fn include_bytes_expand(
+    _db: &dyn AstDatabase,
+    _arg_id: EagerMacroId,
+    tt: &tt::Subtree,
+) -> Result<(tt::Subtree, FragmentKind), mbe::ExpandError> {
+    let _path = parse_string(tt)?;
+
+    // FIXME: actually read the file here if the user asked for macro expansion
+    let res = tt::Subtree {
+        delimiter: None,
+        token_trees: vec![tt::TokenTree::Leaf(tt::Leaf::Literal(tt::Literal {
+            text: r#"b"""#.into(),
+            id: tt::TokenId::unspecified(),
+        }))],
+    };
+    Ok((res, FragmentKind::Expr))
+}
+
+fn include_str_expand(
+    db: &dyn AstDatabase,
+    arg_id: EagerMacroId,
+    tt: &tt::Subtree,
+) -> Result<(tt::Subtree, FragmentKind), mbe::ExpandError> {
+    let path = parse_string(tt)?;
+
+    // FIXME: we're not able to read excluded files (which is most of them because
+    // it's unusual to `include_str!` a Rust file), but we can return an empty string.
+    // Ideally, we'd be able to offer a precise expansion if the user asks for macro
+    // expansion.
+    let file_id = match relative_file(db, arg_id.into(), &path, true) {
+        Some(file_id) => file_id,
+        None => {
+            return Ok((quote!(""), FragmentKind::Expr));
+        }
+    };
+
+    let text = db.file_text(file_id);
+    let text = &*text;
+
+    Ok((quote!(#text), FragmentKind::Expr))
+}
+
 fn get_env_inner(db: &dyn AstDatabase, arg_id: EagerMacroId, key: &str) -> Option<String> {
     let krate = db.lookup_intern_eager_expansion(arg_id).krate;
     db.crate_graph()[krate].env.get(key)
@@ -581,4 +630,20 @@ mod tests {
             r#"std::fmt::Arguments::new_v1(&[], &[std::fmt::ArgumentV1::new(&(arg1(a,b,c)),std::fmt::Display::fmt),std::fmt::ArgumentV1::new(&(arg2),std::fmt::Display::fmt),])"#
         );
     }
+
+    #[test]
+    fn test_include_bytes_expand() {
+        let expanded = expand_builtin_macro(
+            r#"
+            #[rustc_builtin_macro]
+            macro_rules! include_bytes {
+                ($file:expr) => {{ /* compiler built-in */ }};
+                ($file:expr,) => {{ /* compiler built-in */ }};
+            }
+            include_bytes("foo");
+            "#,
+        );
+
+        assert_eq!(expanded, r#"b"""#);
+    }
 }
diff --git a/crates/ra_hir_expand/src/name.rs b/crates/ra_hir_expand/src/name.rs
index 660bdfe33..1b0303685 100644
--- a/crates/ra_hir_expand/src/name.rs
+++ b/crates/ra_hir_expand/src/name.rs
@@ -191,6 +191,8 @@ pub mod known {
         stringify,
         concat,
         include,
+        include_bytes,
+        include_str,
         format_args,
         format_args_nl,
         env,
diff --git a/crates/ra_hir_ty/Cargo.toml b/crates/ra_hir_ty/Cargo.toml
index 407322dc1..d6df48db2 100644
--- a/crates/ra_hir_ty/Cargo.toml
+++ b/crates/ra_hir_ty/Cargo.toml
@@ -27,8 +27,8 @@ test_utils = { path = "../test_utils" }
 
 scoped-tls = "1"
 
-chalk-solve = { version = "0.15.0-dev.0", git = "https://github.com/rust-lang/chalk" }
-chalk-ir = { version = "0.15.0-dev.0", git = "https://github.com/rust-lang/chalk" }
+chalk-solve = { version = "0.15.0" }
+chalk-ir = { version = "0.15.0" }
 
 [dev-dependencies]
 insta = "0.16.0"
diff --git a/crates/ra_hir_ty/src/db.rs b/crates/ra_hir_ty/src/db.rs
index 7889b8d2c..cad553273 100644
--- a/crates/ra_hir_ty/src/db.rs
+++ b/crates/ra_hir_ty/src/db.rs
@@ -14,7 +14,7 @@ use crate::{
     method_resolution::CrateImplDefs,
     traits::{chalk, AssocTyValue, Impl},
     Binders, CallableDef, GenericPredicate, InferenceResult, OpaqueTyId, PolyFnSig,
-    ReturnTypeImplTraits, Substs, TraitRef, Ty, TyDefId, TypeCtor, ValueTyDefId,
+    ReturnTypeImplTraits, TraitRef, Ty, TyDefId, TypeCtor, ValueTyDefId,
 };
 use hir_expand::name::Name;
 
@@ -65,7 +65,7 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
     fn generic_predicates(&self, def: GenericDefId) -> Arc<[Binders<GenericPredicate>]>;
 
     #[salsa::invoke(crate::lower::generic_defaults_query)]
-    fn generic_defaults(&self, def: GenericDefId) -> Substs;
+    fn generic_defaults(&self, def: GenericDefId) -> Arc<[Binders<Ty>]>;
 
     #[salsa::invoke(crate::method_resolution::CrateImplDefs::impls_in_crate_query)]
     fn impls_in_crate(&self, krate: CrateId) -> Arc<CrateImplDefs>;
diff --git a/crates/ra_hir_ty/src/diagnostics.rs b/crates/ra_hir_ty/src/diagnostics.rs
index ebd9cb08f..a59efb347 100644
--- a/crates/ra_hir_ty/src/diagnostics.rs
+++ b/crates/ra_hir_ty/src/diagnostics.rs
@@ -169,3 +169,31 @@ impl AstDiagnostic for BreakOutsideOfLoop {
         ast::Expr::cast(node).unwrap()
     }
 }
+
+#[derive(Debug)]
+pub struct MissingUnsafe {
+    pub file: HirFileId,
+    pub expr: AstPtr<ast::Expr>,
+}
+
+impl Diagnostic for MissingUnsafe {
+    fn message(&self) -> String {
+        format!("This operation is unsafe and requires an unsafe function or block")
+    }
+    fn source(&self) -> InFile<SyntaxNodePtr> {
+        InFile { file_id: self.file, value: self.expr.clone().into() }
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+}
+
+impl AstDiagnostic for MissingUnsafe {
+    type AST = ast::Expr;
+
+    fn ast(&self, db: &impl AstDatabase) -> Self::AST {
+        let root = db.parse_or_expand(self.source().file_id).unwrap();
+        let node = self.source().value.to_node(&root);
+        ast::Expr::cast(node).unwrap()
+    }
+}
diff --git a/crates/ra_hir_ty/src/display.rs b/crates/ra_hir_ty/src/display.rs
index 3c97e1354..23cea1a2a 100644
--- a/crates/ra_hir_ty/src/display.rs
+++ b/crates/ra_hir_ty/src/display.rs
@@ -308,7 +308,6 @@ impl HirDisplay for ApplicationTy {
                 }
 
                 if self.parameters.len() > 0 {
-                    let mut non_default_parameters = Vec::with_capacity(self.parameters.len());
                     let parameters_to_write =
                         if f.display_target.is_source_code() || f.omit_verbose_types() {
                             match self
@@ -319,20 +318,23 @@ impl HirDisplay for ApplicationTy {
                             {
                                 None => self.parameters.0.as_ref(),
                                 Some(default_parameters) => {
+                                    let mut default_from = 0;
                                     for (i, parameter) in self.parameters.iter().enumerate() {
                                         match (parameter, default_parameters.get(i)) {
                                             (&Ty::Unknown, _) | (_, None) => {
-                                                non_default_parameters.push(parameter.clone())
+                                                default_from = i + 1;
                                             }
-                                            (_, Some(default_parameter))
-                                                if parameter != default_parameter =>
-                                            {
-                                                non_default_parameters.push(parameter.clone())
+                                            (_, Some(default_parameter)) => {
+                                                let actual_default = default_parameter
+                                                    .clone()
+                                                    .subst(&self.parameters.prefix(i));
+                                                if parameter != &actual_default {
+                                                    default_from = i + 1;
+                                                }
                                             }
-                                            _ => (),
                                         }
                                     }
-                                    &non_default_parameters
+                                    &self.parameters.0[0..default_from]
                                 }
                             }
                         } else {
diff --git a/crates/ra_hir_ty/src/infer/expr.rs b/crates/ra_hir_ty/src/infer/expr.rs
index a9565a58d..22884522a 100644
--- a/crates/ra_hir_ty/src/infer/expr.rs
+++ b/crates/ra_hir_ty/src/infer/expr.rs
@@ -142,6 +142,7 @@ impl<'a> InferenceContext<'a> {
                 // FIXME: Breakable block inference
                 self.infer_block(statements, *tail, expected)
             }
+            Expr::Unsafe { body } => self.infer_expr(*body, expected),
             Expr::TryBlock { body } => {
                 let _inner = self.infer_expr(*body, expected);
                 // FIXME should be std::result::Result<{inner}, _>
@@ -784,11 +785,7 @@ impl<'a> InferenceContext<'a> {
         for &check_closures in &[false, true] {
             let param_iter = param_tys.iter().cloned().chain(repeat(Ty::Unknown));
             for (&arg, param_ty) in args.iter().zip(param_iter) {
-                let is_closure = match &self.body[arg] {
-                    Expr::Lambda { .. } => true,
-                    _ => false,
-                };
-
+                let is_closure = matches!(&self.body[arg], Expr::Lambda { .. });
                 if is_closure != check_closures {
                     continue;
                 }
diff --git a/crates/ra_hir_ty/src/lib.rs b/crates/ra_hir_ty/src/lib.rs
index f22232324..c9513b752 100644
--- a/crates/ra_hir_ty/src/lib.rs
+++ b/crates/ra_hir_ty/src/lib.rs
@@ -37,6 +37,7 @@ pub(crate) mod utils;
 pub mod db;
 pub mod diagnostics;
 pub mod expr;
+pub mod unsafe_validation;
 
 #[cfg(test)]
 mod tests;
@@ -619,17 +620,11 @@ pub enum GenericPredicate {
 
 impl GenericPredicate {
     pub fn is_error(&self) -> bool {
-        match self {
-            GenericPredicate::Error => true,
-            _ => false,
-        }
+        matches!(self, GenericPredicate::Error)
     }
 
     pub fn is_implemented(&self) -> bool {
-        match self {
-            GenericPredicate::Implemented(_) => true,
-            _ => false,
-        }
+        matches!(self, GenericPredicate::Implemented(_))
     }
 
     pub fn trait_ref(&self, db: &dyn HirDatabase) -> Option<TraitRef> {
diff --git a/crates/ra_hir_ty/src/lower.rs b/crates/ra_hir_ty/src/lower.rs
index d5154f436..3dc154e92 100644
--- a/crates/ra_hir_ty/src/lower.rs
+++ b/crates/ra_hir_ty/src/lower.rs
@@ -578,11 +578,13 @@ fn substs_from_path_segment(
     // (i.e. defaults aren't used).
     if !infer_args || had_explicit_args {
         if let Some(def_generic) = def_generic {
-            let default_substs = ctx.db.generic_defaults(def_generic);
-            assert_eq!(total_len, default_substs.len());
+            let defaults = ctx.db.generic_defaults(def_generic);
+            assert_eq!(total_len, defaults.len());
 
-            for default_ty in default_substs.iter().skip(substs.len()) {
-                substs.push(default_ty.clone());
+            for default_ty in defaults.iter().skip(substs.len()) {
+                // each default can depend on the previous parameters
+                let substs_so_far = Substs(substs.clone().into());
+                substs.push(default_ty.clone().subst(&substs_so_far));
             }
         }
     }
@@ -945,17 +947,42 @@ pub(crate) fn generic_predicates_query(
 }
 
 /// Resolve the default type params from generics
-pub(crate) fn generic_defaults_query(db: &dyn HirDatabase, def: GenericDefId) -> Substs {
+pub(crate) fn generic_defaults_query(
+    db: &dyn HirDatabase,
+    def: GenericDefId,
+) -> Arc<[Binders<Ty>]> {
     let resolver = def.resolver(db.upcast());
-    let ctx = TyLoweringContext::new(db, &resolver);
+    let ctx =
+        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
     let generic_params = generics(db.upcast(), def);
 
     let defaults = generic_params
         .iter()
-        .map(|(_idx, p)| p.default.as_ref().map_or(Ty::Unknown, |t| Ty::from_hir(&ctx, t)))
+        .enumerate()
+        .map(|(idx, (_, p))| {
+            let mut ty = p.default.as_ref().map_or(Ty::Unknown, |t| Ty::from_hir(&ctx, t));
+
+            // Each default can only refer to previous parameters.
+            ty.walk_mut_binders(
+                &mut |ty, binders| match ty {
+                    Ty::Bound(BoundVar { debruijn, index }) if *debruijn == binders => {
+                        if *index >= idx {
+                            // type variable default referring to parameter coming
+                            // after it. This is forbidden (FIXME: report
+                            // diagnostic)
+                            *ty = Ty::Unknown;
+                        }
+                    }
+                    _ => {}
+                },
+                DebruijnIndex::INNERMOST,
+            );
+
+            Binders::new(idx, ty)
+        })
         .collect();
 
-    Substs(defaults)
+    defaults
 }
 
 fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> PolyFnSig {
diff --git a/crates/ra_hir_ty/src/test_db.rs b/crates/ra_hir_ty/src/test_db.rs
index ad04e3e0f..0481a7b12 100644
--- a/crates/ra_hir_ty/src/test_db.rs
+++ b/crates/ra_hir_ty/src/test_db.rs
@@ -11,7 +11,10 @@ use ra_db::{salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, SourceDataba
 use rustc_hash::FxHashSet;
 use stdx::format_to;
 
-use crate::{db::HirDatabase, diagnostics::Diagnostic, expr::ExprValidator};
+use crate::{
+    db::HirDatabase, diagnostics::Diagnostic, expr::ExprValidator,
+    unsafe_validation::UnsafeValidator,
+};
 
 #[salsa::database(
     ra_db::SourceDatabaseExtStorage,
@@ -119,7 +122,9 @@ impl TestDB {
                 let infer = self.infer(f.into());
                 let mut sink = DiagnosticSink::new(&mut cb);
                 infer.add_diagnostics(self, f, &mut sink);
-                let mut validator = ExprValidator::new(f, infer, &mut sink);
+                let mut validator = ExprValidator::new(f, infer.clone(), &mut sink);
+                validator.validate_body(self);
+                let mut validator = UnsafeValidator::new(f, infer, &mut sink);
                 validator.validate_body(self);
             }
         }
@@ -149,6 +154,19 @@ impl TestDB {
         });
         (buf, count)
     }
+
+    pub fn all_files(&self) -> Vec<FileId> {
+        let mut res = Vec::new();
+        let crate_graph = self.crate_graph();
+        for krate in crate_graph.iter() {
+            let crate_def_map = self.crate_def_map(krate);
+            for (module_id, _) in crate_def_map.modules.iter() {
+                let file_id = crate_def_map[module_id].origin.file_id();
+                res.extend(file_id)
+            }
+        }
+        res
+    }
 }
 
 impl TestDB {
diff --git a/crates/ra_hir_ty/src/tests.rs b/crates/ra_hir_ty/src/tests.rs
index 85ff26a36..5424e6bb1 100644
--- a/crates/ra_hir_ty/src/tests.rs
+++ b/crates/ra_hir_ty/src/tests.rs
@@ -17,17 +17,18 @@ use hir_def::{
     item_scope::ItemScope,
     keys,
     nameres::CrateDefMap,
-    AssocItemId, DefWithBodyId, LocalModuleId, Lookup, ModuleDefId, ModuleId,
+    AssocItemId, DefWithBodyId, LocalModuleId, Lookup, ModuleDefId,
 };
 use hir_expand::{db::AstDatabase, InFile};
 use insta::assert_snapshot;
-use ra_db::{fixture::WithFixture, salsa::Database, FilePosition, SourceDatabase};
+use ra_db::{fixture::WithFixture, salsa::Database, FileRange, SourceDatabase};
 use ra_syntax::{
     algo,
     ast::{self, AstNode},
     SyntaxNode,
 };
 use stdx::format_to;
+use test_utils::extract_annotations;
 
 use crate::{
     db::HirDatabase, display::HirDisplay, infer::TypeMismatch, test_db::TestDB, InferenceResult, Ty,
@@ -37,21 +38,38 @@ use crate::{
 // against snapshots of the expected results using insta. Use cargo-insta to
 // update the snapshots.
 
-fn type_at_pos(db: &TestDB, pos: FilePosition) -> String {
-    type_at_pos_displayed(db, pos, |ty, _| ty.display(db).to_string())
+fn check_types(ra_fixture: &str) {
+    check_types_impl(ra_fixture, false)
 }
 
-fn displayed_source_at_pos(db: &TestDB, pos: FilePosition) -> String {
-    type_at_pos_displayed(db, pos, |ty, module_id| ty.display_source_code(db, module_id).unwrap())
+fn check_types_source_code(ra_fixture: &str) {
+    check_types_impl(ra_fixture, true)
 }
 
-fn type_at_pos_displayed(
-    db: &TestDB,
-    pos: FilePosition,
-    display_fn: impl FnOnce(&Ty, ModuleId) -> String,
-) -> String {
+fn check_types_impl(ra_fixture: &str, display_source: bool) {
+    let db = TestDB::with_files(ra_fixture);
+    let mut checked_one = false;
+    for file_id in db.all_files() {
+        let text = db.parse(file_id).syntax_node().to_string();
+        let annotations = extract_annotations(&text);
+        for (range, expected) in annotations {
+            let ty = type_at_range(&db, FileRange { file_id, range });
+            let actual = if display_source {
+                let module = db.module_for_file(file_id);
+                ty.display_source_code(&db, module).unwrap()
+            } else {
+                ty.display(&db).to_string()
+            };
+            assert_eq!(expected, actual);
+            checked_one = true;
+        }
+    }
+    assert!(checked_one, "no `//^` annotations found");
+}
+
+fn type_at_range(db: &TestDB, pos: FileRange) -> Ty {
     let file = db.parse(pos.file_id).ok().unwrap();
-    let expr = algo::find_node_at_offset::<ast::Expr>(file.syntax(), pos.offset).unwrap();
+    let expr = algo::find_node_at_range::<ast::Expr>(file.syntax(), pos.range).unwrap();
     let fn_def = expr.syntax().ancestors().find_map(ast::FnDef::cast).unwrap();
     let module = db.module_for_file(pos.file_id);
     let func = *module.child_by_source(db)[keys::FUNCTION]
@@ -61,17 +79,11 @@ fn type_at_pos_displayed(
     let (_body, source_map) = db.body_with_source_map(func.into());
     if let Some(expr_id) = source_map.node_expr(InFile::new(pos.file_id.into(), &expr)) {
         let infer = db.infer(func.into());
-        let ty = &infer[expr_id];
-        return display_fn(ty, module);
+        return infer[expr_id].clone();
     }
     panic!("Can't find expression")
 }
 
-fn type_at(ra_fixture: &str) -> String {
-    let (db, file_pos) = TestDB::with_position(ra_fixture);
-    type_at_pos(&db, file_pos)
-}
-
 fn infer(ra_fixture: &str) -> String {
     infer_with_mismatches(ra_fixture, false)
 }
@@ -539,6 +551,155 @@ fn missing_record_pat_field_no_diagnostic_if_not_exhaustive() {
 }
 
 #[test]
+fn missing_unsafe_diagnostic_with_raw_ptr() {
+    let diagnostics = TestDB::with_files(
+        r"
+//- /lib.rs
+fn missing_unsafe() {
+    let x = &5 as *const usize;
+    let y = *x;
+}
+",
+    )
+    .diagnostics()
+    .0;
+
+    assert_snapshot!(diagnostics, @r#""*x": This operation is unsafe and requires an unsafe function or block"#);
+}
+
+#[test]
+fn missing_unsafe_diagnostic_with_unsafe_call() {
+    let diagnostics = TestDB::with_files(
+        r"
+//- /lib.rs
+unsafe fn unsafe_fn() {
+    let x = &5 as *const usize;
+    let y = *x;
+}
+
+fn missing_unsafe() {
+    unsafe_fn();
+}
+",
+    )
+    .diagnostics()
+    .0;
+
+    assert_snapshot!(diagnostics, @r#""unsafe_fn()": This operation is unsafe and requires an unsafe function or block"#);
+}
+
+#[test]
+fn missing_unsafe_diagnostic_with_unsafe_method_call() {
+    let diagnostics = TestDB::with_files(
+        r"
+struct HasUnsafe;
+
+impl HasUnsafe {
+    unsafe fn unsafe_fn(&self) {
+        let x = &5 as *const usize;
+        let y = *x;
+    }
+}
+
+fn missing_unsafe() {
+    HasUnsafe.unsafe_fn();
+}
+
+",
+    )
+    .diagnostics()
+    .0;
+
+    assert_snapshot!(diagnostics, @r#""HasUnsafe.unsafe_fn()": This operation is unsafe and requires an unsafe function or block"#);
+}
+
+#[test]
+fn no_missing_unsafe_diagnostic_with_raw_ptr_in_unsafe_block() {
+    let diagnostics = TestDB::with_files(
+        r"
+fn nothing_to_see_move_along() {
+    let x = &5 as *const usize;
+    unsafe {
+        let y = *x;
+    }
+}
+",
+    )
+    .diagnostics()
+    .0;
+
+    assert_snapshot!(diagnostics, @"");
+}
+
+#[test]
+fn missing_unsafe_diagnostic_with_raw_ptr_outside_unsafe_block() {
+    let diagnostics = TestDB::with_files(
+        r"
+fn nothing_to_see_move_along() {
+    let x = &5 as *const usize;
+    unsafe {
+        let y = *x;
+    }
+    let z = *x;
+}
+",
+    )
+    .diagnostics()
+    .0;
+
+    assert_snapshot!(diagnostics, @r#""*x": This operation is unsafe and requires an unsafe function or block"#);
+}
+
+#[test]
+fn no_missing_unsafe_diagnostic_with_unsafe_call_in_unsafe_block() {
+    let diagnostics = TestDB::with_files(
+        r"
+unsafe fn unsafe_fn() {
+    let x = &5 as *const usize;
+    let y = *x;
+}
+
+fn nothing_to_see_move_along() {
+    unsafe {
+        unsafe_fn();
+    }
+}
+",
+    )
+    .diagnostics()
+    .0;
+
+    assert_snapshot!(diagnostics, @"");
+}
+
+#[test]
+fn no_missing_unsafe_diagnostic_with_unsafe_method_call_in_unsafe_block() {
+    let diagnostics = TestDB::with_files(
+        r"
+struct HasUnsafe;
+
+impl HasUnsafe {
+    unsafe fn unsafe_fn() {
+        let x = &5 as *const usize;
+        let y = *x;
+    }
+}
+
+fn nothing_to_see_move_along() {
+    unsafe {
+        HasUnsafe.unsafe_fn();
+    }
+}
+
+",
+    )
+    .diagnostics()
+    .0;
+
+    assert_snapshot!(diagnostics, @"");
+}
+
+#[test]
 fn break_outside_of_loop() {
     let diagnostics = TestDB::with_files(
         r"
diff --git a/crates/ra_hir_ty/src/tests/coercion.rs b/crates/ra_hir_ty/src/tests/coercion.rs
index 5a1c6ccc3..136d28a91 100644
--- a/crates/ra_hir_ty/src/tests/coercion.rs
+++ b/crates/ra_hir_ty/src/tests/coercion.rs
@@ -1,7 +1,8 @@
-use super::infer_with_mismatches;
 use insta::assert_snapshot;
 use test_utils::mark;
 
+use super::infer_with_mismatches;
+
 // Infer with some common definitions and impls.
 fn infer(source: &str) -> String {
     let defs = r#"
diff --git a/crates/ra_hir_ty/src/tests/display_source_code.rs b/crates/ra_hir_ty/src/tests/display_source_code.rs
index 5dfa0a014..b502135d8 100644
--- a/crates/ra_hir_ty/src/tests/display_source_code.rs
+++ b/crates/ra_hir_ty/src/tests/display_source_code.rs
@@ -1,50 +1,41 @@
-use super::displayed_source_at_pos;
-use crate::test_db::TestDB;
-use ra_db::fixture::WithFixture;
+use super::check_types_source_code;
 
 #[test]
 fn qualify_path_to_submodule() {
-    let (db, pos) = TestDB::with_position(
+    check_types_source_code(
         r#"
-//- /main.rs
-
 mod foo {
     pub struct Foo;
 }
 
 fn bar() {
     let foo: foo::Foo = foo::Foo;
-    foo<|>
-}
+    foo
+}  //^ foo::Foo
 
 "#,
     );
-    assert_eq!("foo::Foo", displayed_source_at_pos(&db, pos));
 }
 
 #[test]
 fn omit_default_type_parameters() {
-    let (db, pos) = TestDB::with_position(
-        r"
-        //- /main.rs
-        struct Foo<T = u8> { t: T }
-        fn main() {
-            let foo = Foo { t: 5u8 };
-            foo<|>;
-        }
-        ",
+    check_types_source_code(
+        r#"
+struct Foo<T = u8> { t: T }
+fn main() {
+    let foo = Foo { t: 5u8 };
+    foo;
+}  //^ Foo
+"#,
     );
-    assert_eq!("Foo", displayed_source_at_pos(&db, pos));
 
-    let (db, pos) = TestDB::with_position(
-        r"
-        //- /main.rs
-        struct Foo<K, T = u8> { k: K, t: T }
-        fn main() {
-            let foo = Foo { k: 400, t: 5u8 };
-            foo<|>;
-        }
-        ",
+    check_types_source_code(
+        r#"
+struct Foo<K, T = u8> { k: K, t: T }
+fn main() {
+    let foo = Foo { k: 400, t: 5u8 };
+    foo;
+}   //^ Foo<i32>
+"#,
     );
-    assert_eq!("Foo<i32>", displayed_source_at_pos(&db, pos));
 }
diff --git a/crates/ra_hir_ty/src/tests/macros.rs b/crates/ra_hir_ty/src/tests/macros.rs
index be2b48dcc..45c4e309e 100644
--- a/crates/ra_hir_ty/src/tests/macros.rs
+++ b/crates/ra_hir_ty/src/tests/macros.rs
@@ -1,16 +1,13 @@
 use std::fs;
 
 use insta::assert_snapshot;
-use ra_db::fixture::WithFixture;
 use test_utils::project_dir;
 
-use crate::test_db::TestDB;
-
-use super::{infer, type_at, type_at_pos};
+use super::{check_types, infer};
 
 #[test]
 fn cfg_impl_def() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:foo cfg:test
 use foo::S as T;
@@ -28,8 +25,8 @@ impl S {
 
 fn test() {
     let t = (S.foo1(), S.foo2(), T.foo3(), T.foo4());
-    t<|>;
-}
+    t;
+} //^ (i32, {unknown}, i32, {unknown})
 
 //- /foo.rs crate:foo
 struct S;
@@ -45,7 +42,6 @@ impl S {
 }
 "#,
     );
-    assert_eq!("(i32, {unknown}, i32, {unknown})", type_at_pos(&db, pos));
 }
 
 #[test]
@@ -253,26 +249,24 @@ fn foo() {
 
 #[test]
 fn processes_impls_generated_by_macros() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 macro_rules! m {
     ($ident:ident) => (impl Trait for $ident {})
 }
 trait Trait { fn foo(self) -> u128 {} }
 struct S;
 m!(S);
-fn test() { S.foo()<|>; }
+fn test() { S.foo(); }
+                //^ u128
 "#,
     );
-    assert_eq!(t, "u128");
 }
 
 #[test]
 fn infer_assoc_items_generated_by_macros() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 macro_rules! m {
     () => (fn foo(&self) -> u128 {0})
 }
@@ -281,17 +275,16 @@ impl S {
     m!();
 }
 
-fn test() { S.foo()<|>; }
+fn test() { S.foo(); }
+                //^ u128
 "#,
     );
-    assert_eq!(t, "u128");
 }
 
 #[test]
 fn infer_assoc_items_generated_by_macros_chain() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 macro_rules! m_inner {
     () => {fn foo(&self) -> u128 {0}}
 }
@@ -304,21 +297,21 @@ impl S {
     m!();
 }
 
-fn test() { S.foo()<|>; }
+fn test() { S.foo(); }
+                //^ u128
 "#,
     );
-    assert_eq!(t, "u128");
 }
 
 #[test]
 fn infer_macro_with_dollar_crate_is_correct_in_expr() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:foo
 fn test() {
     let x = (foo::foo!(1), foo::foo!(2));
-    x<|>;
-}
+    x;
+} //^ (i32, usize)
 
 //- /lib.rs crate:foo
 #[macro_export]
@@ -335,12 +328,11 @@ macro_rules! bar {
 pub fn baz() -> usize { 31usize }
 "#,
     );
-    assert_eq!("(i32, usize)", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_macro_with_dollar_crate_is_correct_in_trait_associate_type() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:foo
 use foo::Trait;
@@ -348,7 +340,8 @@ use foo::Trait;
 fn test() {
     let msg = foo::Message(foo::MessageRef);
     let r = msg.deref();
-    r<|>;
+    r;
+  //^ &MessageRef
 }
 
 //- /lib.rs crate:foo
@@ -375,7 +368,6 @@ macro_rules! expand {
 expand!();
 "#,
     );
-    assert_eq!("&MessageRef", type_at_pos(&db, pos));
 }
 
 #[test]
@@ -429,13 +421,13 @@ fn main() {
 
 #[test]
 fn infer_local_inner_macros() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:foo
 fn test() {
     let x = foo::foo!(1);
-    x<|>;
-}
+    x;
+} //^ i32
 
 //- /lib.rs crate:foo
 #[macro_export(local_inner_macros)]
@@ -450,7 +442,6 @@ macro_rules! bar {
 
 "#,
     );
-    assert_eq!("i32", type_at_pos(&db, pos));
 }
 
 #[test]
@@ -531,7 +522,7 @@ fn main() {
 
 #[test]
 fn infer_builtin_macros_include() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs
 #[rustc_builtin_macro]
@@ -540,14 +531,13 @@ macro_rules! include {() => {}}
 include!("foo.rs");
 
 fn main() {
-    bar()<|>;
-}
+    bar();
+}     //^ u32
 
 //- /foo.rs
 fn bar() -> u32 {0}
 "#,
     );
-    assert_eq!("u32", type_at_pos(&db, pos));
 }
 
 #[test]
@@ -565,18 +555,17 @@ macro_rules! include {() => {}}
 include!("foo.rs");
 
 fn main() {
-    RegisterBlock { }<|>;
+    RegisterBlock { };
+                  //^ RegisterBlock
 }
     "#;
     let fixture = format!("{}\n//- /foo.rs\n{}", fixture, big_file);
-
-    let (db, pos) = TestDB::with_position(&fixture);
-    assert_eq!("RegisterBlock", type_at_pos(&db, pos));
+    check_types(&fixture);
 }
 
 #[test]
 fn infer_builtin_macros_include_concat() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs
 #[rustc_builtin_macro]
@@ -588,19 +577,18 @@ macro_rules! concat {() => {}}
 include!(concat!("f", "oo.rs"));
 
 fn main() {
-    bar()<|>;
-}
+    bar();
+}     //^ u32
 
 //- /foo.rs
 fn bar() -> u32 {0}
 "#,
     );
-    assert_eq!("u32", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_builtin_macros_include_concat_with_bad_env_should_failed() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs
 #[rustc_builtin_macro]
@@ -615,32 +603,29 @@ macro_rules! env {() => {}}
 include!(concat!(env!("OUT_DIR"), "/foo.rs"));
 
 fn main() {
-    bar()<|>;
-}
+    bar();
+}     //^ {unknown}
 
 //- /foo.rs
 fn bar() -> u32 {0}
 "#,
     );
-    assert_eq!("{unknown}", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_builtin_macros_include_itself_should_failed() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
-//- /main.rs
 #[rustc_builtin_macro]
 macro_rules! include {() => {}}
 
 include!("main.rs");
 
 fn main() {
-    0<|>
-}
+    0
+} //^ i32
 "#,
     );
-    assert_eq!("i32", type_at_pos(&db, pos));
 }
 
 #[test]
@@ -686,14 +671,14 @@ fn main() {
 
 #[test]
 fn infer_derive_clone_simple() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:core
 #[derive(Clone)]
 struct S;
 fn test() {
-    S.clone()<|>;
-}
+    S.clone();
+}         //^ S
 
 //- /lib.rs crate:core
 #[prelude_import]
@@ -705,12 +690,11 @@ mod clone {
 }
 "#,
     );
-    assert_eq!("S", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_derive_clone_in_core() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /lib.rs crate:core
 #[prelude_import]
@@ -726,16 +710,15 @@ pub struct S;
 //- /main.rs crate:main deps:core
 use core::S;
 fn test() {
-    S.clone()<|>;
-}
+    S.clone();
+}         //^ S
 "#,
     );
-    assert_eq!("S", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_derive_clone_with_params() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:core
 #[derive(Clone)]
@@ -744,7 +727,8 @@ struct S;
 struct Wrapper<T>(T);
 struct NonClone;
 fn test() {
-    (Wrapper(S).clone(), Wrapper(NonClone).clone())<|>;
+    (Wrapper(S).clone(), Wrapper(NonClone).clone());
+  //^ (Wrapper<S>, {unknown})
 }
 
 //- /lib.rs crate:core
@@ -757,13 +741,12 @@ mod clone {
 }
 "#,
     );
-    assert_eq!("(Wrapper<S>, {unknown})", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_custom_derive_simple() {
     // FIXME: this test current now do nothing
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main
 use foo::Foo;
@@ -772,11 +755,10 @@ use foo::Foo;
 struct S{}
 
 fn test() {
-    S{}<|>;
-}
+    S{};
+}   //^ S
 "#,
     );
-    assert_eq!("S", type_at_pos(&db, pos));
 }
 
 #[test]
diff --git a/crates/ra_hir_ty/src/tests/method_resolution.rs b/crates/ra_hir_ty/src/tests/method_resolution.rs
index 20329bae4..9c8f22314 100644
--- a/crates/ra_hir_ty/src/tests/method_resolution.rs
+++ b/crates/ra_hir_ty/src/tests/method_resolution.rs
@@ -1,7 +1,6 @@
-use super::{infer, type_at, type_at_pos};
-use crate::test_db::TestDB;
 use insta::assert_snapshot;
-use ra_db::fixture::WithFixture;
+
+use super::{check_types, infer};
 
 #[test]
 fn infer_slice_method() {
@@ -246,13 +245,13 @@ fn test() {
 
 #[test]
 fn cross_crate_associated_method_call() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:other_crate
 fn test() {
     let x = other_crate::foo::S::thing();
-    x<|>;
-}
+    x;
+} //^ i128
 
 //- /lib.rs crate:other_crate
 mod foo {
@@ -263,7 +262,6 @@ mod foo {
 }
 "#,
     );
-    assert_eq!("i128", type_at_pos(&db, pos));
 }
 
 #[test]
@@ -684,135 +682,127 @@ fn test() {
 
 #[test]
 fn method_resolution_unify_impl_self_type() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 struct S<T>;
 impl S<u32> { fn foo(&self) -> u8 {} }
 impl S<i32> { fn foo(&self) -> i8 {} }
-fn test() { (S::<u32>.foo(), S::<i32>.foo())<|>; }
+fn test() { (S::<u32>.foo(), S::<i32>.foo()); }
+          //^ (u8, i8)
 "#,
     );
-    assert_eq!(t, "(u8, i8)");
 }
 
 #[test]
 fn method_resolution_trait_before_autoref() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl S { fn foo(&self) -> i8 { 0 } }
 impl Trait for S { fn foo(self) -> u128 { 0 } }
-fn test() { S.foo()<|>; }
+fn test() { S.foo(); }
+                //^ u128
 "#,
     );
-    assert_eq!(t, "u128");
 }
 
 #[test]
 fn method_resolution_by_value_before_autoref() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Clone { fn clone(&self) -> Self; }
 struct S;
 impl Clone for S {}
 impl Clone for &S {}
-fn test() { (S.clone(), (&S).clone(), (&&S).clone())<|>; }
+fn test() { (S.clone(), (&S).clone(), (&&S).clone()); }
+          //^ (S, S, &S)
 "#,
     );
-    assert_eq!(t, "(S, S, &S)");
 }
 
 #[test]
 fn method_resolution_trait_before_autoderef() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl S { fn foo(self) -> i8 { 0 } }
 impl Trait for &S { fn foo(self) -> u128 { 0 } }
-fn test() { (&S).foo()<|>; }
+fn test() { (&S).foo(); }
+                   //^ u128
 "#,
     );
-    assert_eq!(t, "u128");
 }
 
 #[test]
 fn method_resolution_impl_before_trait() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl S { fn foo(self) -> i8 { 0 } }
 impl Trait for S { fn foo(self) -> u128 { 0 } }
-fn test() { S.foo()<|>; }
+fn test() { S.foo(); }
+                //^ i8
 "#,
     );
-    assert_eq!(t, "i8");
 }
 
 #[test]
 fn method_resolution_impl_ref_before_trait() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl S { fn foo(&self) -> i8 { 0 } }
 impl Trait for &S { fn foo(self) -> u128 { 0 } }
-fn test() { S.foo()<|>; }
+fn test() { S.foo(); }
+                //^ i8
 "#,
     );
-    assert_eq!(t, "i8");
 }
 
 #[test]
 fn method_resolution_trait_autoderef() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl Trait for S { fn foo(self) -> u128 { 0 } }
-fn test() { (&S).foo()<|>; }
+fn test() { (&S).foo(); }
+                   //^ u128
 "#,
     );
-    assert_eq!(t, "u128");
 }
 
 #[test]
 fn method_resolution_unsize_array() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 #[lang = "slice"]
 impl<T> [T] {
     fn len(&self) -> usize { loop {} }
 }
 fn test() {
     let a = [1, 2, 3];
-    a.len()<|>;
-}
+    a.len();
+}       //^ usize
 "#,
     );
-    assert_eq!(t, "usize");
 }
 
 #[test]
 fn method_resolution_trait_from_prelude() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:other_crate
 struct S;
 impl Clone for S {}
 
 fn test() {
-    S.clone()<|>;
+    S.clone();
+          //^ S
 }
 
 //- /lib.rs crate:other_crate
@@ -825,115 +815,107 @@ mod foo {
 }
 "#,
     );
-    assert_eq!("S", type_at_pos(&db, pos));
 }
 
 #[test]
 fn method_resolution_where_clause_for_unknown_trait() {
     // The blanket impl currently applies because we ignore the unresolved where clause
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl<T> Trait for T where T: UnknownTrait {}
-fn test() { (&S).foo()<|>; }
+fn test() { (&S).foo(); }
+                   //^ u128
 "#,
     );
-    assert_eq!(t, "u128");
 }
 
 #[test]
 fn method_resolution_where_clause_not_met() {
     // The blanket impl shouldn't apply because we can't prove S: Clone
-    let t = type_at(
+    // This is also to make sure that we don't resolve to the foo method just
+    // because that's the only method named foo we can find, which would make
+    // the below tests not work
+    check_types(
         r#"
-//- /main.rs
 trait Clone {}
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl<T> Trait for T where T: Clone {}
-fn test() { (&S).foo()<|>; }
+fn test() { (&S).foo(); }
+                   //^ {unknown}
 "#,
     );
-    // This is also to make sure that we don't resolve to the foo method just
-    // because that's the only method named foo we can find, which would make
-    // the below tests not work
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn method_resolution_where_clause_inline_not_met() {
     // The blanket impl shouldn't apply because we can't prove S: Clone
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Clone {}
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl<T: Clone> Trait for T {}
-fn test() { (&S).foo()<|>; }
+fn test() { (&S).foo(); }
+                   //^ {unknown}
 "#,
     );
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn method_resolution_where_clause_1() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Clone {}
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl Clone for S {}
 impl<T> Trait for T where T: Clone {}
-fn test() { S.foo()<|>; }
+fn test() { S.foo(); }
+                //^ u128
 "#,
     );
-    assert_eq!(t, "u128");
 }
 
 #[test]
 fn method_resolution_where_clause_2() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Into<T> { fn into(self) -> T; }
 trait From<T> { fn from(other: T) -> Self; }
 struct S1;
 struct S2;
 impl From<S2> for S1 {}
 impl<T, U> Into<U> for T where U: From<T> {}
-fn test() { S2.into()<|>; }
+fn test() { S2.into(); }
+                  //^ {unknown}
 "#,
     );
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn method_resolution_where_clause_inline() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Into<T> { fn into(self) -> T; }
 trait From<T> { fn from(other: T) -> Self; }
 struct S1;
 struct S2;
 impl From<S2> for S1 {}
 impl<T, U: From<T>> Into<U> for T {}
-fn test() { S2.into()<|>; }
+fn test() { S2.into(); }
+                  //^ {unknown}
 "#,
     );
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn method_resolution_overloaded_method() {
     test_utils::mark::check!(impl_self_type_match_without_receiver);
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 struct Wrapper<T>(T);
 struct Foo<T>(T);
 struct Bar<T>(T);
@@ -953,30 +935,30 @@ impl<T> Wrapper<Bar<T>> {
 fn main() {
     let a = Wrapper::<Foo<f32>>::new(1.0);
     let b = Wrapper::<Bar<f32>>::new(1.0);
-    (a, b)<|>;
+    (a, b);
+  //^ (Wrapper<Foo<f32>>, Wrapper<Bar<f32>>)
 }
 "#,
     );
-    assert_eq!(t, "(Wrapper<Foo<f32>>, Wrapper<Bar<f32>>)")
 }
 
 #[test]
 fn method_resolution_encountering_fn_type() {
-    type_at(
+    check_types(
         r#"
 //- /main.rs
 fn foo() {}
 trait FnOnce { fn call(self); }
-fn test() { foo.call()<|>; }
+fn test() { foo.call(); }
+                   //^ {unknown}
 "#,
     );
 }
 
 #[test]
 fn method_resolution_non_parameter_type() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 mod a {
     pub trait Foo {
         fn foo(&self);
@@ -988,18 +970,16 @@ fn foo<T>(t: Wrapper<T>)
 where
     Wrapper<T>: a::Foo,
 {
-    t.foo()<|>;
-}
+    t.foo();
+}       //^ {unknown}
 "#,
     );
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn method_resolution_3373() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 struct A<T>(T);
 
 impl A<i32> {
@@ -1007,19 +987,17 @@ impl A<i32> {
 }
 
 fn main() {
-    A::from(3)<|>;
-}
+    A::from(3);
+}          //^ A<i32>
 "#,
     );
-    assert_eq!(t, "A<i32>");
 }
 
 #[test]
 fn method_resolution_slow() {
     // this can get quite slow if we set the solver size limit too high
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait SendX {}
 
 struct S1; impl SendX for S1 {}
@@ -1037,10 +1015,10 @@ trait FnX {}
 
 impl<B, C> Trait for S<B, C> where C: FnX, B: SendX {}
 
-fn test() { (S {}).method()<|>; }
+fn test() { (S {}).method(); }
+                        //^ ()
 "#,
     );
-    assert_eq!(t, "()");
 }
 
 #[test]
diff --git a/crates/ra_hir_ty/src/tests/never_type.rs b/crates/ra_hir_ty/src/tests/never_type.rs
index ab9a990f5..64d421d40 100644
--- a/crates/ra_hir_ty/src/tests/never_type.rs
+++ b/crates/ra_hir_ty/src/tests/never_type.rs
@@ -1,99 +1,91 @@
 use insta::assert_snapshot;
 
-use super::{infer_with_mismatches, type_at};
+use super::{check_types, infer_with_mismatches};
 
 #[test]
 fn infer_never1() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 fn test() {
     let t = return;
-    t<|>;
-}
+    t;
+} //^ !
 "#,
     );
-    assert_eq!(t, "!");
 }
 
 #[test]
 fn infer_never2() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 fn gen<T>() -> T { loop {} }
 
 fn test() {
     let a = gen();
     if false { a } else { loop {} };
-    a<|>;
-}
+    a;
+} //^ !
 "#,
     );
-    assert_eq!(t, "!");
 }
 
 #[test]
 fn infer_never3() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 fn gen<T>() -> T { loop {} }
 
 fn test() {
     let a = gen();
     if false { loop {} } else { a };
-    a<|>;
+    a;
+  //^ !
 }
 "#,
     );
-    assert_eq!(t, "!");
 }
 
 #[test]
 fn never_type_in_generic_args() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 enum Option<T> { None, Some(T) }
 
 fn test() {
     let a = if true { Option::None } else { Option::Some(return) };
-    a<|>;
-}
+    a;
+} //^ Option<!>
 "#,
     );
-    assert_eq!(t, "Option<!>");
 }
 
 #[test]
 fn never_type_can_be_reinferred1() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 fn gen<T>() -> T { loop {} }
 
 fn test() {
     let a = gen();
     if false { loop {} } else { a };
-    a<|>;
+    a;
+  //^ ()
     if false { a };
 }
 "#,
     );
-    assert_eq!(t, "()");
 }
 
 #[test]
 fn never_type_can_be_reinferred2() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 enum Option<T> { None, Some(T) }
 
 fn test() {
     let a = if true { Option::None } else { Option::Some(return) };
-    a<|>;
+    a;
+  //^ Option<i32>
     match 42 {
         42 => a,
         _ => Option::Some(42),
@@ -101,19 +93,18 @@ fn test() {
 }
 "#,
     );
-    assert_eq!(t, "Option<i32>");
 }
 
 #[test]
 fn never_type_can_be_reinferred3() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 enum Option<T> { None, Some(T) }
 
 fn test() {
     let a = if true { Option::None } else { Option::Some(return) };
-    a<|>;
+    a;
+  //^ Option<&str>
     match 42 {
         42 => a,
         _ => Option::Some("str"),
@@ -121,82 +112,72 @@ fn test() {
 }
 "#,
     );
-    assert_eq!(t, "Option<&str>");
 }
 
 #[test]
 fn match_no_arm() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 enum Void {}
 
 fn test(a: Void) {
     let t = match a {};
-    t<|>;
-}
+    t;
+} //^ !
 "#,
     );
-    assert_eq!(t, "!");
 }
 
 #[test]
 fn match_unknown_arm() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 fn test(a: Option) {
     let t = match 0 {
         _ => unknown,
     };
-    t<|>;
-}
+    t;
+} //^ {unknown}
 "#,
     );
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn if_never() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 fn test() {
     let i = if true {
         loop {}
     } else {
         3.0
     };
-    i<|>;
-}
+    i;
+} //^ f64
 "#,
     );
-    assert_eq!(t, "f64");
 }
 
 #[test]
 fn if_else_never() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 fn test(input: bool) {
     let i = if input {
         2.0
     } else {
         return
     };
-    i<|>;
-}
+    i;
+} //^ f64
 "#,
     );
-    assert_eq!(t, "f64");
 }
 
 #[test]
 fn match_first_arm_never() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 fn test(a: i32) {
     let i = match a {
         1 => return,
@@ -204,18 +185,16 @@ fn test(a: i32) {
         3 => loop {},
         _ => 3.0,
     };
-    i<|>;
-}
+    i;
+} //^ f64
 "#,
     );
-    assert_eq!(t, "f64");
 }
 
 #[test]
 fn match_second_arm_never() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 fn test(a: i32) {
     let i = match a {
         1 => 3.0,
@@ -223,45 +202,40 @@ fn test(a: i32) {
         3 => 3.0,
         _ => return,
     };
-    i<|>;
-}
+    i;
+} //^ f64
 "#,
     );
-    assert_eq!(t, "f64");
 }
 
 #[test]
 fn match_all_arms_never() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 fn test(a: i32) {
     let i = match a {
         2 => return,
         _ => loop {},
     };
-    i<|>;
-}
+    i;
+} //^ !
 "#,
     );
-    assert_eq!(t, "!");
 }
 
 #[test]
 fn match_no_never_arms() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 fn test(a: i32) {
     let i = match a {
         2 => 2.0,
         _ => 3.0,
     };
-    i<|>;
-}
+    i;
+} //^ f64
 "#,
     );
-    assert_eq!(t, "f64");
 }
 
 #[test]
diff --git a/crates/ra_hir_ty/src/tests/regression.rs b/crates/ra_hir_ty/src/tests/regression.rs
index aa37326df..d806e0ffb 100644
--- a/crates/ra_hir_ty/src/tests/regression.rs
+++ b/crates/ra_hir_ty/src/tests/regression.rs
@@ -1,10 +1,7 @@
 use insta::assert_snapshot;
-use ra_db::fixture::WithFixture;
 use test_utils::mark;
 
-use crate::test_db::TestDB;
-
-use super::infer;
+use super::{check_types, infer};
 
 #[test]
 fn bug_484() {
@@ -404,13 +401,13 @@ fn test() {
 
 #[test]
 fn issue_2683_chars_impl() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:std
 fn test() {
     let chars: std::str::Chars<'_>;
-    (chars.next(), chars.nth(1))<|>;
-}
+    (chars.next(), chars.nth(1));
+} //^ (Option<char>, Option<char>)
 
 //- /std.rs crate:std
 #[prelude_import]
@@ -449,15 +446,12 @@ pub mod str {
 }
 "#,
     );
-
-    assert_eq!("(Option<char>, Option<char>)", super::type_at_pos(&db, pos));
 }
 
 #[test]
 fn issue_3642_bad_macro_stackover() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
-//- /main.rs
 #[macro_export]
 macro_rules! match_ast {
     (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) };
@@ -472,7 +466,8 @@ macro_rules! match_ast {
 }
 
 fn main() {
-    let anchor<|> = match_ast! {
+    let anchor = match_ast! {
+       //^ ()
         match parent {
             as => {},
             _ => return None
@@ -480,8 +475,6 @@ fn main() {
     };
 }"#,
     );
-
-    assert_eq!("()", super::type_at_pos(&db, pos));
 }
 
 #[test]
diff --git a/crates/ra_hir_ty/src/tests/simple.rs b/crates/ra_hir_ty/src/tests/simple.rs
index 7d8197f8b..de63f4cce 100644
--- a/crates/ra_hir_ty/src/tests/simple.rs
+++ b/crates/ra_hir_ty/src/tests/simple.rs
@@ -1,19 +1,17 @@
-use super::{infer, type_at, type_at_pos};
-use crate::test_db::TestDB;
 use insta::assert_snapshot;
-use ra_db::fixture::WithFixture;
+
+use super::{check_types, infer};
 
 #[test]
 fn infer_box() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:std
-
 fn test() {
     let x = box 1;
     let t = (x, box x, box &1, box [1]);
-    t<|>;
-}
+    t;
+} //^ (Box<i32>, Box<Box<i32>>, Box<&i32>, Box<[i32; _]>)
 
 //- /std.rs crate:std
 #[prelude_import] use prelude::*;
@@ -25,29 +23,24 @@ mod boxed {
         inner: *mut T,
     }
 }
-
 "#,
     );
-    assert_eq!("(Box<i32>, Box<Box<i32>>, Box<&i32>, Box<[i32; _]>)", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_adt_self() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
-//- /main.rs
 enum Nat { Succ(Self), Demo(Nat), Zero }
 
 fn test() {
     let foo: Nat = Nat::Zero;
     if let Nat::Succ(x) = foo {
-        x<|>
-    }
+        x
+    } //^ Nat
 }
-
 "#,
     );
-    assert_eq!("Nat", type_at_pos(&db, pos));
 }
 
 #[test]
@@ -93,7 +86,7 @@ fn foo() {
 
 #[test]
 fn infer_ranges() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:core
 fn test() {
@@ -105,8 +98,8 @@ fn test() {
     let f = 'a'..='z';
 
     let t = (a, b, c, d, e, f);
-    t<|>;
-}
+    t;
+} //^ (RangeFull, RangeFrom<i32>, RangeTo<u32>, Range<usize>, RangeToInclusive<i32>, RangeInclusive<char>)
 
 //- /core.rs crate:core
 #[prelude_import] use prelude::*;
@@ -135,29 +128,22 @@ pub mod ops {
 }
 "#,
     );
-    assert_eq!(
-        "(RangeFull, RangeFrom<i32>, RangeTo<u32>, Range<usize>, RangeToInclusive<i32>, RangeInclusive<char>)",
-        type_at_pos(&db, pos),
-    );
 }
 
 #[test]
 fn infer_while_let() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
-//- /main.rs
 enum Option<T> { Some(T), None }
 
 fn test() {
     let foo: Option<f32> = None;
     while let Option::Some(x) = foo {
-        <|>x
-    }
+        x
+    } //^ f32
 }
-
 "#,
     );
-    assert_eq!("f32", type_at_pos(&db, pos));
 }
 
 #[test]
@@ -1687,9 +1673,8 @@ fn test() {
 
 #[test]
 fn shadowing_primitive() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 struct i32;
 struct Foo;
 
@@ -1697,15 +1682,15 @@ impl i32 { fn foo(&self) -> Foo { Foo } }
 
 fn main() {
     let x: i32 = i32;
-    x.foo()<|>;
+    x.foo();
+        //^ Foo
 }"#,
     );
-    assert_eq!(t, "Foo");
 }
 
 #[test]
 fn not_shadowing_primitive_by_module() {
-    let t = type_at(
+    check_types(
         r#"
 //- /str.rs
 fn foo() {}
@@ -1715,15 +1700,15 @@ mod str;
 fn foo() -> &'static str { "" }
 
 fn main() {
-    foo()<|>;
+    foo();
+      //^ &str
 }"#,
     );
-    assert_eq!(t, "&str");
 }
 
 #[test]
 fn not_shadowing_module_by_primitive() {
-    let t = type_at(
+    check_types(
         r#"
 //- /str.rs
 fn foo() -> u32 {0}
@@ -1733,10 +1718,10 @@ mod str;
 fn foo() -> &'static str { "" }
 
 fn main() {
-    str::foo()<|>;
+    str::foo();
+           //^ u32
 }"#,
     );
-    assert_eq!(t, "u32");
 }
 
 // This test is actually testing the shadowing behavior within ra_hir_def. It
@@ -1744,27 +1729,7 @@ fn main() {
 // capable of asserting the necessary conditions.
 #[test]
 fn should_be_shadowing_imports() {
-    let t = type_at(
-        r#"
-mod a {
-    pub fn foo() -> i8 {0}
-    pub struct foo { a: i8 }
-}
-mod b { pub fn foo () -> u8 {0} }
-mod c { pub struct foo { a: u8 } }
-mod d {
-    pub use super::a::*;
-    pub use super::c::foo;
-    pub use super::b::foo;
-}
-
-fn main() {
-    d::foo()<|>;
-}"#,
-    );
-    assert_eq!(t, "u8");
-
-    let t = type_at(
+    check_types(
         r#"
 mod a {
     pub fn foo() -> i8 {0}
@@ -1779,10 +1744,12 @@ mod d {
 }
 
 fn main() {
-    d::foo{a:0<|>};
+    d::foo();
+         //^ u8
+    d::foo{a:0};
+           //^ u8
 }"#,
     );
-    assert_eq!(t, "u8");
 }
 
 #[test]
@@ -1880,6 +1847,7 @@ fn main() {
         @r###"
     10..130 '{     ...2 }; }': ()
     20..21 'x': i32
+    24..37 'unsafe { 92 }': i32
     31..37 '{ 92 }': i32
     33..35 '92': i32
     47..48 'y': {unknown}
@@ -2151,3 +2119,48 @@ fn test() {
     "###
     );
 }
+
+#[test]
+fn generic_default_depending_on_other_type_arg() {
+    assert_snapshot!(
+        infer(r#"
+struct Thing<T = u128, F = fn() -> T> { t: T }
+
+fn test(t1: Thing<u32>, t2: Thing) {
+    t1;
+    t2;
+    Thing::<_> { t: 1u32 };
+}
+"#),
+        // FIXME: the {unknown} is a bug
+        @r###"
+    56..58 't1': Thing<u32, fn() -> u32>
+    72..74 't2': Thing<u128, fn() -> u128>
+    83..130 '{     ...2 }; }': ()
+    89..91 't1': Thing<u32, fn() -> u32>
+    97..99 't2': Thing<u128, fn() -> u128>
+    105..127 'Thing:...1u32 }': Thing<u32, fn() -> {unknown}>
+    121..125 '1u32': u32
+    "###
+    );
+}
+
+#[test]
+fn generic_default_depending_on_other_type_arg_forward() {
+    assert_snapshot!(
+        infer(r#"
+struct Thing<F = fn() -> T, T = u128> { t: T }
+
+fn test(t1: Thing) {
+    t1;
+}
+"#),
+        // the {unknown} here is intentional, as defaults are not allowed to
+        // refer to type parameters coming later
+        @r###"
+    56..58 't1': Thing<fn() -> {unknown}, u128>
+    67..78 '{     t1; }': ()
+    73..75 't1': Thing<fn() -> {unknown}, u128>
+    "###
+    );
+}
diff --git a/crates/ra_hir_ty/src/tests/traits.rs b/crates/ra_hir_ty/src/tests/traits.rs
index 71c0c2d27..01c919a7e 100644
--- a/crates/ra_hir_ty/src/tests/traits.rs
+++ b/crates/ra_hir_ty/src/tests/traits.rs
@@ -1,17 +1,13 @@
 use insta::assert_snapshot;
-use ra_db::fixture::WithFixture;
 use test_utils::mark;
 
-use crate::test_db::TestDB;
-
-use super::{infer, infer_with_mismatches, type_at, type_at_pos};
+use super::{check_types, infer, infer_with_mismatches};
 
 #[test]
 fn infer_await() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:core
-
 struct IntFuture;
 
 impl Future for IntFuture {
@@ -21,8 +17,8 @@ impl Future for IntFuture {
 fn test() {
     let r = IntFuture;
     let v = r.await;
-    v<|>;
-}
+    v;
+} //^ u64
 
 //- /core.rs crate:core
 #[prelude_import] use future::*;
@@ -32,18 +28,15 @@ mod future {
         type Output;
     }
 }
-
 "#,
     );
-    assert_eq!("u64", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_async() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:core
-
 async fn foo() -> u64 {
     128
 }
@@ -51,8 +44,8 @@ async fn foo() -> u64 {
 fn test() {
     let r = foo();
     let v = r.await;
-    v<|>;
-}
+    v;
+} //^ u64
 
 //- /core.rs crate:core
 #[prelude_import] use future::*;
@@ -62,26 +55,23 @@ mod future {
         type Output;
     }
 }
-
 "#,
     );
-    assert_eq!("u64", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_desugar_async() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:core
-
 async fn foo() -> u64 {
     128
 }
 
 fn test() {
     let r = foo();
-    r<|>;
-}
+    r;
+} //^ impl Future<Output = u64>
 
 //- /core.rs crate:core
 #[prelude_import] use future::*;
@@ -93,23 +83,20 @@ mod future {
 
 "#,
     );
-    assert_eq!("impl Future<Output = u64>", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_try() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:core
-
 fn test() {
     let r: Result<i32, u64> = Result::Ok(1);
     let v = r?;
-    v<|>;
-}
+    v;
+} //^ i32
 
 //- /core.rs crate:core
-
 #[prelude_import] use ops::*;
 mod ops {
     trait Try {
@@ -130,30 +117,26 @@ mod result {
         type Error = E;
     }
 }
-
 "#,
     );
-    assert_eq!("i32", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_for_loop() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:core,alloc
-
 use alloc::collections::Vec;
 
 fn test() {
     let v = Vec::new();
     v.push("foo");
     for x in v {
-        x<|>;
-    }
+        x;
+    } //^ &str
 }
 
 //- /core.rs crate:core
-
 #[prelude_import] use iter::*;
 mod iter {
     trait IntoIterator {
@@ -162,7 +145,6 @@ mod iter {
 }
 
 //- /alloc.rs crate:alloc deps:core
-
 mod collections {
     struct Vec<T> {}
     impl<T> Vec<T> {
@@ -176,15 +158,13 @@ mod collections {
 }
 "#,
     );
-    assert_eq!("&str", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_ops_neg() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:std
-
 struct Bar;
 struct Foo;
 
@@ -195,11 +175,10 @@ impl std::ops::Neg for Bar {
 fn test() {
     let a = Bar;
     let b = -a;