17 files changed, 243 insertions, 363 deletions

diff --git a/Cargo.lock b/Cargo.lock
index a95f9139f..d80e58548 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -919,6 +919,8 @@ dependencies = [
  "ra_batch 0.1.0",
  "ra_db 0.1.0",
  "ra_hir 0.1.0",
+ "ra_hir_def 0.1.0",
+ "ra_hir_ty 0.1.0",
  "ra_ide 0.1.0",
  "ra_prof 0.1.0",
  "ra_syntax 0.1.0",
diff --git a/crates/ra_cli/Cargo.toml b/crates/ra_cli/Cargo.toml
index 21a37c7bf..12af075f7 100644
--- a/crates/ra_cli/Cargo.toml
+++ b/crates/ra_cli/Cargo.toml
@@ -12,7 +12,9 @@ env_logger = { version = "0.7.1", default-features = false, features = ["humanti
 ra_syntax = { path = "../ra_syntax" }
 ra_ide = { path = "../ra_ide" }
 ra_batch = { path = "../ra_batch" }
-ra_hir = { path = "../ra_hir" }
+hir = { path = "../ra_hir", package = "ra_hir" }
+hir_ty = { path = "../ra_hir_ty", package = "ra_hir_ty" }
+hir_def = { path = "../ra_hir_def", package = "ra_hir_def" }
 ra_db = { path = "../ra_db" }
 
 [dependencies.ra_prof]
diff --git a/crates/ra_cli/src/analysis_stats.rs b/crates/ra_cli/src/analysis_stats.rs
index 9b1802a5f..ac65415a5 100644
--- a/crates/ra_cli/src/analysis_stats.rs
+++ b/crates/ra_cli/src/analysis_stats.rs
@@ -2,8 +2,13 @@
 
 use std::{collections::HashSet, fmt::Write, path::Path, time::Instant};
 
+use hir::{
+    db::{DefDatabase, HirDatabase},
+    AssocItem, Crate, HasSource, HirDisplay, ModuleDef,
+};
+use hir_def::FunctionId;
+use hir_ty::{Ty, TypeWalk};
 use ra_db::SourceDatabaseExt;
-use ra_hir::{AssocItem, Crate, HasSource, HirDisplay, ModuleDef, Ty, TypeWalk};
 use ra_syntax::AstNode;
 
 use crate::{progress_report::ProgressReport, Result, Verbosity};
@@ -101,8 +106,9 @@ pub fn run(
                 continue;
             }
         }
-        let body = f.body(db);
-        let inference_result = f.infer(db);
+        let f_id = FunctionId::from(f);
+        let body = db.body(f_id.into());
+        let inference_result = db.infer(f_id.into());
         for (expr_id, _) in body.exprs.iter() {
             let ty = &inference_result[expr_id];
             num_exprs += 1;
@@ -122,7 +128,8 @@ pub fn run(
             if let Some(mismatch) = inference_result.type_mismatch_for_expr(expr_id) {
                 num_type_mismatches += 1;
                 if verbosity.is_verbose() {
-                    let src = f.body_source_map(db).expr_syntax(expr_id);
+                    let (_, sm) = db.body_with_source_map(f_id.into());
+                    let src = sm.expr_syntax(expr_id);
                     if let Some(src) = src {
                         // FIXME: it might be nice to have a function (on Analysis?) that goes from Source<T> -> (LineCol, LineCol) directly
                         let original_file = src.file_id.original_file(db);
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 4578a0ba8..7ac1bf461 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -7,7 +7,6 @@ use std::sync::Arc;
 use either::Either;
 use hir_def::{
     adt::VariantData,
-    body::{Body, BodySourceMap},
     builtin_type::BuiltinType,
     docs::Documentation,
     expr::{BindingAnnotation, Pat, PatId},
@@ -24,14 +23,15 @@ use hir_expand::{
     name::{self, AsName},
     MacroDefId,
 };
-use hir_ty::expr::ExprValidator;
-use ra_db::{CrateId, Edition};
+use hir_ty::{
+    autoderef, display::HirFormatter, expr::ExprValidator, ApplicationTy, Canonical, InEnvironment,
+    TraitEnvironment, Ty, TyDefId, TypeCtor, TypeWalk,
+};
+use ra_db::{CrateId, Edition, FileId};
 use ra_syntax::ast;
 
 use crate::{
     db::{DefDatabase, HirDatabase},
-    ty::display::HirFormatter,
-    ty::{self, InEnvironment, InferenceResult, TraitEnvironment, Ty, TyDefId, TypeCtor, TypeWalk},
     CallableDef, HirDisplay, InFile, Name,
 };
 
@@ -40,7 +40,7 @@ use crate::{
 /// root module.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Crate {
-    pub(crate) crate_id: CrateId,
+    pub(crate) id: CrateId,
 }
 
 #[derive(Debug)]
@@ -50,33 +50,43 @@ pub struct CrateDependency {
 }
 
 impl Crate {
-    pub fn crate_id(self) -> CrateId {
-        self.crate_id
-    }
-
     pub fn dependencies(self, db: &impl DefDatabase) -> Vec<CrateDependency> {
         db.crate_graph()
-            .dependencies(self.crate_id)
+            .dependencies(self.id)
             .map(|dep| {
-                let krate = Crate { crate_id: dep.crate_id() };
+                let krate = Crate { id: dep.crate_id() };
                 let name = dep.as_name();
                 CrateDependency { krate, name }
             })
             .collect()
     }
 
+    // FIXME: add `transitive_reverse_dependencies`.
+    pub fn reverse_dependencies(self, db: &impl DefDatabase) -> Vec<Crate> {
+        let crate_graph = db.crate_graph();
+        crate_graph
+            .iter()
+            .filter(|&krate| crate_graph.dependencies(krate).any(|it| it.crate_id == self.id))
+            .map(|id| Crate { id })
+            .collect()
+    }
+
     pub fn root_module(self, db: &impl DefDatabase) -> Option<Module> {
-        let module_id = db.crate_def_map(self.crate_id).root;
+        let module_id = db.crate_def_map(self.id).root;
         Some(Module::new(self, module_id))
     }
 
+    pub fn root_file(self, db: &impl DefDatabase) -> FileId {
+        db.crate_graph().crate_root(self.id)
+    }
+
     pub fn edition(self, db: &impl DefDatabase) -> Edition {
         let crate_graph = db.crate_graph();
-        crate_graph.edition(self.crate_id)
+        crate_graph.edition(self.id)
     }
 
     pub fn all(db: &impl DefDatabase) -> Vec<Crate> {
-        db.crate_graph().iter().map(|crate_id| Crate { crate_id }).collect()
+        db.crate_graph().iter().map(|id| Crate { id }).collect()
     }
 }
 
@@ -115,7 +125,7 @@ pub use hir_def::attr::Attrs;
 
 impl Module {
     pub(crate) fn new(krate: Crate, crate_module_id: LocalModuleId) -> Module {
-        Module { id: ModuleId { krate: krate.crate_id, local_id: crate_module_id } }
+        Module { id: ModuleId { krate: krate.id, local_id: crate_module_id } }
     }
 
     /// Name of this module.
@@ -133,7 +143,7 @@ impl Module {
 
     /// Returns the crate this module is part of.
     pub fn krate(self) -> Crate {
-        Crate { crate_id: self.id.krate }
+        Crate { id: self.id.krate }
     }
 
     /// Topmost parent of this module. Every module has a `crate_root`, but some
@@ -144,13 +154,6 @@ impl Module {
         self.with_module_id(def_map.root)
     }
 
-    /// Finds a child module with the specified name.
-    pub fn child(self, db: &impl DefDatabase, name: &Name) -> Option<Module> {
-        let def_map = db.crate_def_map(self.id.krate);
-        let child_id = def_map[self.id.local_id].children.get(name)?;
-        Some(self.with_module_id(*child_id))
-    }
-
     /// Iterates over all child modules.
     pub fn children(self, db: &impl DefDatabase) -> impl Iterator<Item = Module> {
         let def_map = db.crate_def_map(self.id.krate);
@@ -224,7 +227,7 @@ impl Module {
         def_map[self.id.local_id].impls.iter().copied().map(ImplBlock::from).collect()
     }
 
-    fn with_module_id(self, module_id: LocalModuleId) -> Module {
+    pub(crate) fn with_module_id(self, module_id: LocalModuleId) -> Module {
         Module::new(self.krate(), module_id)
     }
 }
@@ -251,8 +254,10 @@ impl StructField {
         self.parent.variant_data(db).fields()[self.id].name.clone()
     }
 
-    pub fn ty(&self, db: &impl HirDatabase) -> Ty {
-        db.field_types(self.parent.into())[self.id].clone()
+    pub fn ty(&self, db: &impl HirDatabase) -> Type {
+        let var_id = self.parent.into();
+        let ty = db.field_types(var_id)[self.id].clone();
+        Type::new(db, self.parent.module(db).id.krate.into(), var_id, ty)
     }
 
     pub fn parent_def(&self, _db: &impl HirDatabase) -> VariantDef {
@@ -287,23 +292,10 @@ impl Struct {
             .collect()
     }
 
-    pub fn field(self, db: &impl HirDatabase, name: &Name) -> Option<StructField> {
-        db.struct_data(self.id.into())
-            .variant_data
-            .fields()
-            .iter()
-            .find(|(_id, data)| data.name == *name)
-            .map(|(id, _)| StructField { parent: self.into(), id })
-    }
-
     pub fn ty(self, db: &impl HirDatabase) -> Type {
         Type::from_def(db, self.id.module(db).krate, self.id)
     }
 
-    pub fn constructor_ty(self, db: &impl HirDatabase) -> Ty {
-        db.value_ty(self.id.into())
-    }
-
     fn variant_data(self, db: &impl DefDatabase) -> Arc<VariantData> {
         db.struct_data(self.id.into()).variant_data.clone()
     }
@@ -336,15 +328,6 @@ impl Union {
             .collect()
     }
 
-    pub fn field(self, db: &impl HirDatabase, name: &Name) -> Option<StructField> {
-        db.union_data(self.id)
-            .variant_data
-            .fields()
-            .iter()
-            .find(|(_id, data)| data.name == *name)
-            .map(|(id, _)| StructField { parent: self.into(), id })
-    }
-
     fn variant_data(self, db: &impl DefDatabase) -> Arc<VariantData> {
         db.union_data(self.id).variant_data.clone()
     }
@@ -376,11 +359,6 @@ impl Enum {
             .collect()
     }
 
-    pub fn variant(self, db: &impl DefDatabase, name: &Name) -> Option<EnumVariant> {
-        let id = db.enum_data(self.id).variant(name)?;
-        Some(EnumVariant { parent: self, id })
-    }
-
     pub fn ty(self, db: &impl HirDatabase) -> Type {
         Type::from_def(db, self.id.module(db).krate, self.id)
     }
@@ -412,14 +390,6 @@ impl EnumVariant {
             .collect()
     }
 
-    pub fn field(self, db: &impl HirDatabase, name: &Name) -> Option<StructField> {
-        self.variant_data(db)
-            .fields()
-            .iter()
-            .find(|(_id, data)| data.name == *name)
-            .map(|(id, _)| StructField { parent: self.into(), id })
-    }
-
     pub(crate) fn variant_data(self, db: &impl DefDatabase) -> Arc<VariantData> {
         db.enum_data(self.parent.id).variants[self.id].variant_data.clone()
     }
@@ -537,48 +507,8 @@ impl Function {
         db.function_data(self.id).params.clone()
     }
 
-    pub fn body_source_map(self, db: &impl HirDatabase) -> Arc<BodySourceMap> {
-        db.body_with_source_map(self.id.into()).1
-    }
-
-    pub fn body(self, db: &impl HirDatabase) -> Arc<Body> {
-        db.body(self.id.into())
-    }
-
-    pub fn ty(self, db: &impl HirDatabase) -> Ty {
-        db.value_ty(self.id.into())
-    }
-
-    pub fn infer(self, db: &impl HirDatabase) -> Arc<InferenceResult> {
-        db.infer(self.id.into())
-    }
-
-    /// The containing impl block, if this is a method.
-    pub fn impl_block(self, db: &impl DefDatabase) -> Option<ImplBlock> {
-        match self.container(db) {
-            Some(Container::ImplBlock(it)) => Some(it),
-            _ => None,
-        }
-    }
-
-    /// The containing trait, if this is a trait method definition.
-    pub fn parent_trait(self, db: &impl DefDatabase) -> Option<Trait> {
-        match self.container(db) {
-            Some(Container::Trait(it)) => Some(it),
-            _ => None,
-        }
-    }
-
-    pub fn container(self, db: &impl DefDatabase) -> Option<Container> {
-        match self.id.lookup(db).container {
-            ContainerId::TraitId(it) => Some(Container::Trait(it.into())),
-            ContainerId::ImplId(it) => Some(Container::ImplBlock(it.into())),
-            ContainerId::ModuleId(_) => None,
-        }
-    }
-
     pub fn diagnostics(self, db: &impl HirDatabase, sink: &mut DiagnosticSink) {
-        let infer = self.infer(db);
+        let infer = db.infer(self.id.into());
         infer.add_diagnostics(db, self.id, sink);
         let mut validator = ExprValidator::new(self.id, infer, sink);
         validator.validate_body(db);
@@ -603,10 +533,6 @@ impl Const {
         db.const_data(self.id).name.clone()
     }
 
-    pub fn infer(self, db: &impl HirDatabase) -> Arc<InferenceResult> {
-        db.infer(self.id.into())
-    }
-
     /// The containing impl block, if this is a type alias.
     pub fn impl_block(self, db: &impl DefDatabase) -> Option<ImplBlock> {
         match self.container(db) {
@@ -645,10 +571,6 @@ impl Static {
     pub fn krate(self, db: &impl DefDatabase) -> Option<Crate> {
         Some(self.module(db).krate())
     }
-
-    pub fn infer(self, db: &impl HirDatabase) -> Arc<InferenceResult> {
-        db.infer(self.id.into())
-    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -763,15 +685,6 @@ impl AssocItem {
             AssocItem::TypeAlias(t) => t.module(db),
         }
     }
-
-    pub fn container(self, db: &impl DefDatabase) -> Container {
-        match self {
-            AssocItem::Function(f) => f.container(db),
-            AssocItem::Const(c) => c.container(db),
-            AssocItem::TypeAlias(t) => t.container(db),
-        }
-        .expect("AssocItem without container")
-    }
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
@@ -878,11 +791,11 @@ pub struct ImplBlock {
 
 impl ImplBlock {
     pub fn all_in_crate(db: &impl HirDatabase, krate: Crate) -> Vec<ImplBlock> {
-        let impls = db.impls_in_crate(krate.crate_id);
+        let impls = db.impls_in_crate(krate.id);
         impls.all_impls().map(Self::from).collect()
     }
     pub fn for_trait(db: &impl HirDatabase, krate: Crate, trait_: Trait) -> Vec<ImplBlock> {
-        let impls = db.impls_in_crate(krate.crate_id);
+        let impls = db.impls_in_crate(krate.id);
         impls.lookup_impl_blocks_for_trait(trait_.id).map(Self::from).collect()
     }
 
@@ -915,7 +828,7 @@ impl ImplBlock {
     }
 
     pub fn krate(&self, db: &impl DefDatabase) -> Crate {
-        Crate { crate_id: self.module(db).id.krate }
+        Crate { id: self.module(db).id.krate }
     }
 }
 
@@ -926,15 +839,19 @@ pub struct Type {
 }
 
 impl Type {
+    fn new(db: &impl HirDatabase, krate: CrateId, lexical_env: impl HasResolver, ty: Ty) -> Type {
+        let resolver = lexical_env.resolver(db);
+        let environment = TraitEnvironment::lower(db, &resolver);
+        Type { krate, ty: InEnvironment { value: ty, environment } }
+    }
+
     fn from_def(
         db: &impl HirDatabase,
         krate: CrateId,
         def: impl HasResolver + Into<TyDefId>,
     ) -> Type {
-        let resolver = def.resolver(db);
-        let environment = TraitEnvironment::lower(db, &resolver);
         let ty = db.ty(def.into());
-        Type { krate, ty: InEnvironment { value: ty, environment } }
+        Type::new(db, krate, def, ty)
     }
 
     pub fn is_bool(&self) -> bool {
@@ -984,7 +901,7 @@ impl Type {
     pub fn fields(&self, db: &impl HirDatabase) -> Vec<(StructField, Type)> {
         if let Ty::Apply(a_ty) = &self.ty.value {
             match a_ty.ctor {
-                ty::TypeCtor::Adt(AdtId::StructId(s)) => {
+                TypeCtor::Adt(AdtId::StructId(s)) => {
                     let var_def = s.into();
                     return db
                         .field_types(var_def)
@@ -1006,7 +923,7 @@ impl Type {
         let mut res = Vec::new();
         if let Ty::Apply(a_ty) = &self.ty.value {
             match a_ty.ctor {
-                ty::TypeCtor::Tuple { .. } => {
+                TypeCtor::Tuple { .. } => {
                     for ty in a_ty.parameters.iter() {
                         let ty = ty.clone().subst(&a_ty.parameters);
                         res.push(self.derived(ty));
@@ -1025,11 +942,16 @@ impl Type {
     ) -> Vec<(StructField, Type)> {
         // FIXME: check that ty and def match
         match &self.ty.value {
-            Ty::Apply(a_ty) => def
-                .fields(db)
-                .into_iter()
-                .map(|it| (it, self.derived(it.ty(db).subst(&a_ty.parameters))))
-                .collect(),
+            Ty::Apply(a_ty) => {
+                let field_types = db.field_types(def.into());
+                def.fields(db)
+                    .into_iter()
+                    .map(|it| {
+                        let ty = field_types[it.id].clone().subst(&a_ty.parameters);
+                        (it, self.derived(ty))
+                    })
+                    .collect()
+            }
             _ => Vec::new(),
         }
     }
@@ -1037,10 +959,10 @@ impl Type {
     pub fn autoderef<'a>(&'a self, db: &'a impl HirDatabase) -> impl Iterator<Item = Type> + 'a {
         // There should be no inference vars in types passed here
         // FIXME check that?
-        let canonical = crate::ty::Canonical { value: self.ty.value.clone(), num_vars: 0 };
+        let canonical = Canonical { value: self.ty.value.clone(), num_vars: 0 };
         let environment = self.ty.environment.clone();
         let ty = InEnvironment { value: canonical, environment: environment.clone() };
-        ty::autoderef(db, Some(self.krate), ty)
+        autoderef(db, Some(self.krate), ty)
             .map(|canonical| canonical.value)
             .map(move |ty| self.derived(ty))
     }
@@ -1053,7 +975,7 @@ impl Type {
         krate: Crate,
         mut callback: impl FnMut(AssocItem) -> Option<T>,
     ) -> Option<T> {
-        for krate in self.ty.value.def_crates(db, krate.crate_id)? {
+        for krate in self.ty.value.def_crates(db, krate.id)? {
             let impls = db.impls_in_crate(krate);
 
             for impl_block in impls.lookup_impl_blocks(&self.ty.value) {
@@ -1080,15 +1002,14 @@ impl Type {
     // FIXME: provide required accessors such that it becomes implementable from outside.
     pub fn is_equal_for_find_impls(&self, other: &Type) -> bool {
         match (&self.ty.value, &other.ty.value) {
-            (Ty::Apply(a_original_ty), Ty::Apply(ty::ApplicationTy { ctor, parameters })) => {
-                match ctor {
-                    TypeCtor::Ref(..) => match parameters.as_single() {
-                        Ty::Apply(a_ty) => a_original_ty.ctor == a_ty.ctor,
-                        _ => false,
-                    },
-                    _ => a_original_ty.ctor == *ctor,
-                }
-            }
+            (Ty::Apply(a_original_ty), Ty::Apply(ApplicationTy { ctor, parameters })) => match ctor
+            {
+                TypeCtor::Ref(..) => match parameters.as_single() {
+                    Ty::Apply(a_ty) => a_original_ty.ctor == a_ty.ctor,
+                    _ => false,
+                },
+                _ => a_original_ty.ctor == *ctor,
+            },
             _ => false,
         }
     }
diff --git a/crates/ra_hir/src/debug.rs b/crates/ra_hir/src/debug.rs
index 7a2810f71..6cd5c8cb9 100644
--- a/crates/ra_hir/src/debug.rs
+++ b/crates/ra_hir/src/debug.rs
@@ -57,9 +57,9 @@ pub trait HirDebugDatabase {
 impl<DB: HirDebugHelper> HirDebugDatabase for DB {
     fn debug_crate(&self, krate: Crate, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut builder = fmt.debug_tuple("Crate");
-        match self.crate_name(krate.crate_id) {
+        match self.crate_name(krate.id) {
             Some(name) => builder.field(&name),
-            None => builder.field(&krate.crate_id),
+            None => builder.field(&krate.id),
         }
         .finish()
     }
diff --git a/crates/ra_hir/src/from_id.rs b/crates/ra_hir/src/from_id.rs
index e96a18d12..75a1a7772 100644
--- a/crates/ra_hir/src/from_id.rs
+++ b/crates/ra_hir/src/from_id.rs
@@ -9,16 +9,10 @@ use hir_def::{
 };
 
 use crate::{
-    Adt, AssocItem, AttrDef, Crate, DefWithBody, EnumVariant, GenericDef, ModuleDef, StructField,
+    Adt, AssocItem, AttrDef, DefWithBody, EnumVariant, GenericDef, ModuleDef, StructField,
     VariantDef,
 };
 
-impl From<ra_db::CrateId> for Crate {
-    fn from(crate_id: ra_db::CrateId) -> Self {
-        Crate { crate_id }
-    }
-}
-
 macro_rules! from_id {
     ($(($id:path, $ty:path)),*) => {$(
         impl From<$id> for $ty {
@@ -26,10 +20,16 @@ macro_rules! from_id {
                 $ty { id }
             }
         }
+        impl From<$ty> for $id {
+            fn from(ty: $ty) -> $id {
+                ty.id
+            }
+        }
     )*}
 }
 
 from_id![
+    (ra_db::CrateId, crate::Crate),
     (hir_def::ModuleId, crate::Module),
     (hir_def::StructId, crate::Struct),
     (hir_def::UnionId, crate::Union),
diff --git a/crates/ra_hir/src/from_source.rs b/crates/ra_hir/src/from_source.rs
index 4acc038e4..307f3d5bf 100644
--- a/crates/ra_hir/src/from_source.rs
+++ b/crates/ra_hir/src/from_source.rs
@@ -95,7 +95,7 @@ impl FromSource for MacroDef {
 
         let module_src = ModuleSource::from_child_node(db, src.as_ref().map(|it| it.syntax()));
         let module = Module::from_definition(db, InFile::new(src.file_id, module_src))?;
-        let krate = Some(module.krate().crate_id());
+        let krate = Some(module.krate().id);
 
         let ast_id = Some(AstId::new(src.file_id, db.ast_id_map(src.file_id).ast_id(&src.value)));
 
@@ -216,8 +216,10 @@ impl Module {
             }
         }?;
 
-        let child_name = src.value.name()?;
-        parent_module.child(db, &child_name.as_name())
+        let child_name = src.value.name()?.as_name();
+        let def_map = db.crate_def_map(parent_module.id.krate);
+        let child_id = def_map[parent_module.id.local_id].children.get(&child_name)?;
+        Some(parent_module.with_module_id(*child_id))
     }
 
     pub fn from_definition(db: &impl DefDatabase, src: InFile<ModuleSource>) -> Option<Self> {
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 9eb34b5dc..bb22882b1 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -31,7 +31,6 @@ pub mod debug;
 pub mod db;
 pub mod source_binder;
 
-mod ty;
 pub mod diagnostics;
 
 mod from_id;
@@ -48,11 +47,6 @@ pub use crate::{
     },
     from_source::FromSource,
     source_binder::{PathResolution, ScopeEntryWithSyntax, SourceAnalyzer},
-    ty::{
-        display::HirDisplay,
-        primitive::{FloatBitness, FloatTy, IntBitness, IntTy, Signedness, Uncertain},
-        ApplicationTy, CallableDef, Substs, TraitRef, Ty, TypeCtor, TypeWalk,
-    },
 };
 
 pub use hir_def::{
@@ -66,3 +60,4 @@ pub use hir_def::{
 pub use hir_expand::{
     name::Name, HirFileId, InFile, MacroCallId, MacroCallLoc, MacroDefId, MacroFile,
 };
+pub use hir_ty::{display::HirDisplay, CallableDef};
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index c5a920688..9efd0477c 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -22,6 +22,10 @@ use hir_def::{
 use hir_expand::{
     hygiene::Hygiene, name::AsName, AstId, HirFileId, InFile, MacroCallId, MacroCallKind,
 };
+use hir_ty::{
+    method_resolution::{self, implements_trait},
+    Canonical, InEnvironment, InferenceResult, TraitEnvironment, Ty,
+};
 use ra_syntax::{
     ast::{self, AstNode},
     match_ast, AstPtr,
@@ -30,13 +34,9 @@ use ra_syntax::{
 };
 
 use crate::{
-    db::HirDatabase,
-    ty::{
-        method_resolution::{self, implements_trait},
-        InEnvironment, TraitEnvironment, Ty,
-    },
-    Adt, AssocItem, Const, DefWithBody, Enum, EnumVariant, FromSource, Function, ImplBlock, Local,
-    MacroDef, Name, Path, ScopeDef, Static, Struct, Trait, Type, TypeAlias, TypeParam,
+    db::HirDatabase, Adt, AssocItem, Const, DefWithBody, Enum, EnumVariant, FromSource, Function,
+    ImplBlock, Local, MacroDef, Name, Path, ScopeDef, Static, Struct, Trait, Type, TypeAlias,
+    TypeParam,
 };
 
 fn try_get_resolver_for_node(db: &impl HirDatabase, node: InFile<&SyntaxNode>) -> Option<Resolver> {
@@ -100,7 +100,7 @@ pub struct SourceAnalyzer {
     resolver: Resolver,
     body_owner: Option<DefWithBody>,
     body_source_map: Option<Arc<BodySourceMap>>,
-    infer: Option<Arc<crate::ty::InferenceResult>>,
+    infer: Option<Arc<InferenceResult>>,
     scopes: Option<Arc<ExprScopes>>,
 }
 
@@ -376,7 +376,7 @@ impl SourceAnalyzer {
         // There should be no inference vars in types passed here
         // FIXME check that?
         // FIXME replace Unknown by bound vars here
-        let canonical = crate::ty::Canonical { value: ty.ty.value.clone(), num_vars: 0 };
+        let canonical = Canonical { value: ty.ty.value.clone(), num_vars: 0 };
         method_resolution::iterate_method_candidates(
             &canonical,
             db,
@@ -400,7 +400,7 @@ impl SourceAnalyzer {
         // There should be no inference vars in types passed here
         // FIXME check that?
         // FIXME replace Unknown by bound vars here
-        let canonical = crate::ty::Canonical { value: ty.ty.value.clone(), num_vars: 0 };
+        let canonical = Canonical { value: ty.ty.value.clone(), num_vars: 0 };
         method_resolution::iterate_method_candidates(
             &canonical,
             db,
@@ -418,7 +418,7 @@ impl SourceAnalyzer {
     // ) -> impl Iterator<Item = Ty> + 'a {
     //     // There should be no inference vars in types passed here
     //     // FIXME check that?
-    //     let canonical = crate::ty::Canonical { value: ty, num_vars: 0 };
+    //     let canonical = Canonical { value: ty, num_vars: 0 };
     //     let krate = self.resolver.krate();
     //     let environment = TraitEnvironment::lower(db, &self.resolver);
     //     let ty = crate::ty::InEnvironment { value: canonical, environment };
@@ -440,7 +440,7 @@ impl SourceAnalyzer {
             _ => return false,
         };
 
-        let canonical_ty = crate::ty::Canonical { value: ty, num_vars: 0 };
+        let canonical_ty = Canonical { value: ty, num_vars: 0 };
         implements_trait(&canonical_ty, db, &self.resolver, krate.into(), std_future_trait)
     }
 
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
deleted file mode 100644
index 4ed69c00d..000000000
--- a/crates/ra_hir/src/ty.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-//! The type system. We currently use this to infer types for completion, hover
-//! information and various assists.
-
-pub use hir_ty::*;
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index 3ff071f9e..a80067979 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -12,7 +12,7 @@ use hir_expand::{
 use ra_cfg::CfgOptions;
 use ra_db::{CrateId, FileId};
 use ra_syntax::ast;
-use rustc_hash::{FxHashMap, FxHashSet};
+use rustc_hash::FxHashMap;
 use test_utils::tested_by;
 
 use crate::{
@@ -63,42 +63,12 @@ pub(super) fn collect_defs(db: &impl DefDatabase, mut def_map: CrateDefMap) -> C
         unexpanded_macros: Vec::new(),
         unexpanded_attribute_macros: Vec::new(),
         mod_dirs: FxHashMap::default(),
-        macro_stack_monitor: MacroStackMonitor::default(),
-        poison_macros: FxHashSet::default(),
         cfg_options,
     };
     collector.collect();
     collector.finish()
 }
 
-#[derive(Default)]
-struct MacroStackMonitor {
-    counts: FxHashMap<MacroDefId, u32>,
-
-    /// Mainly use for test
-    validator: Option<Box<dyn Fn(u32) -> bool>>,
-}
-
-impl MacroStackMonitor {
-    fn increase(&mut self, macro_def_id: MacroDefId) {
-        *self.counts.entry(macro_def_id).or_default() += 1;
-    }
-
-    fn decrease(&mut self, macro_def_id: MacroDefId) {
-        *self.counts.entry(macro_def_id).or_default() -= 1;
-    }
-
-    fn is_poison(&self, macro_def_id: MacroDefId) -> bool {
-        let cur = *self.counts.get(&macro_def_id).unwrap_or(&0);
-
-        if let Some(validator) = &self.validator {
-            validator(cur)
-        } else {
-            cur > 100
-        }
-    }
-}
-
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 enum PartialResolvedImport {
     /// None of any namespaces is resolved
@@ -127,6 +97,14 @@ struct ImportDirective {
     status: PartialResolvedImport,
 }
 
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct MacroDirective {
+    module_id: LocalModuleId,
+    ast_id: AstId<ast::MacroCall>,
+    path: Path,
+    legacy: Option<MacroCallId>,
+}
+
 /// Walks the tree of module recursively
 struct DefCollector<'a, DB> {
     db: &'a DB,
@@ -134,25 +112,9 @@ struct DefCollector<'a, DB> {
     glob_imports: FxHashMap<LocalModuleId, Vec<(LocalModuleId, LocalImportId)>>,
     unresolved_imports: Vec<ImportDirective>,
     resolved_imports: Vec<ImportDirective>,
-    unexpanded_macros: Vec<(LocalModuleId, AstId<ast::MacroCall>, Path)>,
+    unexpanded_macros: Vec<MacroDirective>,
     unexpanded_attribute_macros: Vec<(LocalModuleId, AstId<ast::ModuleItem>, Path)>,
     mod_dirs: FxHashMap<LocalModuleId, ModDir>,
-
-    /// Some macro use `$tt:tt which mean we have to handle the macro perfectly
-    /// To prevent stack overflow, we add a deep counter here for prevent that.
-    macro_stack_monitor: MacroStackMonitor,
-    /// Some macros are not well-behavior, which leads to infinite loop
-    /// e.g. macro_rules! foo { ($ty:ty) => { foo!($ty); } }
-    /// We mark it down and skip it in collector
-    ///
-    /// FIXME:
-    /// Right now it only handle a poison macro in a single crate,
-    /// such that if other crate try to call that macro,
-    /// the whole process will do again until it became poisoned in that crate.
-    /// We should handle this macro set globally
-    /// However, do we want to put it as a global variable?
-    poison_macros: FxHashSet<MacroDefId>,
-
     cfg_options: &'a CfgOptions,
 }
 
@@ -556,18 +518,24 @@ where
             std::mem::replace(&mut self.unexpanded_attribute_macros, Vec::new());
         let mut resolved = Vec::new();
         let mut res = ReachedFixedPoint::Yes;
-        macros.retain(|(module_id, ast_id, path)| {
+        macros.retain(|directive| {
+            if let Some(call_id) = directive.legacy {
+                res = ReachedFixedPoint::No;
+                resolved.push((directive.module_id, call_id));
+                return false;
+            }
+
             let resolved_res = self.def_map.resolve_path_fp_with_macro(
                 self.db,
                 ResolveMode::Other,
-                *module_id,
-                path,
+                directive.module_id,
+                &directive.path,
                 BuiltinShadowMode::Module,
             );
 
             if let Some(def) = resolved_res.resolved_def.take_macros() {
-                let call_id = def.as_call_id(self.db, MacroCallKind::FnLike(*ast_id));
-                resolved.push((*module_id, call_id, def));
+                let call_id = def.as_call_id(self.db, MacroCallKind::FnLike(directive.ast_id));
+                resolved.push((directive.module_id, call_id));
                 res = ReachedFixedPoint::No;
                 return false;
             }
@@ -579,7 +547,7 @@ where
 
             if let Some(def) = resolved_res {
                 let call_id = def.as_call_id(self.db, MacroCallKind::Attr(*ast_id));
-                resolved.push((*module_id, call_id, def));
+                resolved.push((*module_id, call_id));
                 res = ReachedFixedPoint::No;
                 return false;
             }
@@ -590,8 +558,8 @@ where
         self.unexpanded_macros = macros;
         self.unexpanded_attribute_macros = attribute_macros;
 
-        for (module_id, macro_call_id, macro_def_id) in resolved {
-            self.collect_macro_expansion(module_id, macro_call_id, macro_def_id);
+        for (module_id, macro_call_id) in resolved {
+            self.collect_macro_expansion(module_id, macro_call_id);
         }
 
         res
@@ -611,36 +579,18 @@ where
         None
     }
 
-    fn collect_macro_expansion(
-        &mut self,
-        module_id: LocalModuleId,
-        macro_call_id: MacroCallId,
-        macro_def_id: MacroDefId,
-    ) {
-        if self.poison_macros.contains(&macro_def_id) {
-            return;
-        }
-
-        self.macro_stack_monitor.increase(macro_def_id);
-
-        if !self.macro_stack_monitor.is_poison(macro_def_id) {
-            let file_id: HirFileId = macro_call_id.as_file();
-            let raw_items = self.db.raw_items(file_id);
-            let mod_dir = self.mod_dirs[&module_id].clone();
-            ModCollector {
-                def_collector: &mut *self,
-                file_id,
-                module_id,
-                raw_items: &raw_items,
-                mod_dir,
-            }
-            .collect(raw_items.items());
-        } else {
-            log::error!("Too deep macro expansion: {:?}", macro_call_id);
-            self.poison_macros.insert(macro_def_id);
+    fn collect_macro_expansion(&mut self, module_id: LocalModuleId, macro_call_id: MacroCallId) {
+        let file_id: HirFileId = macro_call_id.as_file();
+        let raw_items = self.db.raw_items(file_id);
+        let mod_dir = self.mod_dirs[&module_id].clone();
+        ModCollector {
+            def_collector: &mut *self,
+            file_id,
+            module_id,
+            raw_items: &raw_items,
+            mod_dir,
         }
-
-        self.macro_stack_monitor.decrease(macro_def_id);
+        .collect(raw_items.items());
     }
 
     fn finish(self) -> CrateDefMap {
@@ -908,15 +858,20 @@ where
             return;
         }
 
-        // Case 2: try to resolve in legacy scope and expand macro_rules, triggering
-        // recursive item collection.
+        // Case 2: try to resolve in legacy scope and expand macro_rules
         if let Some(macro_def) = mac.path.as_ident().and_then(|name| {
             self.def_collector.def_map[self.module_id].scope.get_legacy_macro(&name)
         }) {
             let macro_call_id =
                 macro_def.as_call_id(self.def_collector.db, MacroCallKind::FnLike(ast_id));
 
-            self.def_collector.collect_macro_expansion(self.module_id, macro_call_id, macro_def);
+            self.def_collector.unexpanded_macros.push(MacroDirective {
+                module_id: self.module_id,
+                path: mac.path.clone(),
+                ast_id,
+                legacy: Some(macro_call_id),
+            });
+
             return;
         }
 
@@ -926,7 +881,13 @@ where
         if path.is_ident() {
             path.kind = PathKind::Self_;
         }
-        self.def_collector.unexpanded_macros.push((self.module_id, ast_id, path));
+
+        self.def_collector.unexpanded_macros.push(MacroDirective {
+            module_id: self.module_id,
+            path,
+            ast_id,
+            legacy: None,
+        });
     }
 
     fn import_all_legacy_macros(&mut self, module_id: LocalModuleId) {
@@ -951,19 +912,13 @@ fn is_macro_rules(path: &Path) -> bool {
 
 #[cfg(test)]
 mod tests {
+    use crate::{db::DefDatabase, test_db::TestDB};
     use ra_arena::Arena;
     use ra_db::{fixture::WithFixture, SourceDatabase};
-    use rustc_hash::FxHashSet;
-
-    use crate::{db::DefDatabase, test_db::TestDB};
 
     use super::*;
 
-    fn do_collect_defs(
-        db: &impl DefDatabase,
-        def_map: CrateDefMap,
-        monitor: MacroStackMonitor,
-    ) -> (CrateDefMap, FxHashSet<MacroDefId>) {
+    fn do_collect_defs(db: &impl DefDatabase, def_map: CrateDefMap) -> CrateDefMap {
         let mut collector = DefCollector {
             db,
             def_map,
@@ -973,19 +928,13 @@ mod tests {
             unexpanded_macros: Vec::new(),
             unexpanded_attribute_macros: Vec::new(),
             mod_dirs: FxHashMap::default(),
-            macro_stack_monitor: monitor,
-            poison_macros: FxHashSet::default(),
             cfg_options: &CfgOptions::default(),
         };
         collector.collect();
-        (collector.def_map, collector.poison_macros)
+        collector.def_map
     }
 
-    fn do_limited_resolve(
-        code: &str,
-        limit: u32,
-        poison_limit: u32,
-    ) -> (CrateDefMap, FxHashSet<MacroDefId>) {
+    fn do_resolve(code: &str) -> CrateDefMap {
         let (db, _file_id) = TestDB::with_single_file(&code);
         let krate = db.test_crate();
 
@@ -1003,59 +952,18 @@ mod tests {
                 diagnostics: Vec::new(),
             }
         };
-
-        let mut monitor = MacroStackMonitor::default();
-        monitor.validator = Some(Box::new(move |count| {
-            assert!(count < limit);
-            count >= poison_limit
-        }));
-
-        do_collect_defs(&db, def_map, monitor)
+        do_collect_defs(&db, def_map)
     }
 
     #[test]
-    fn test_macro_expand_limit_width() {
-        do_limited_resolve(
+    fn test_macro_expand_will_stop() {
+        do_resolve(
             r#"
         macro_rules! foo {
             ($($ty:ty)*) => { foo!($($ty)*, $($ty)*); }
         }
 foo!(KABOOM);
         "#,
-            16,
-            1000,
         );
     }
-
-    #[test]
-    fn test_macro_expand_poisoned() {
-        let (_, poison_macros) = do_limited_resolve(
-            r#"
-        macro_rules! foo {
-            ($ty:ty) => { foo!($ty); }
-        }
-foo!(KABOOM);
-        "#,
-            100,
-            16,
-        );
-
-        assert_eq!(poison_macros.len(), 1);
-    }
-
-    #[test]
-    fn test_macro_expand_normal() {
-        let (_, poison_macros) = do_limited_resolve(
-            r#"
-        macro_rules! foo {
-            ($ident:ident) => { struct $ident {} }
-        }
-foo!(Bar);
-        "#,
-            16,
-            16,
-        );
-
-        assert_eq!(poison_macros.len(), 0);
-    }
 }
diff --git a/crates/ra_hir_def/src/resolver.rs b/crates/ra_hir_def/src/resolver.rs
index 4c859e497..9484a61d5 100644
--- a/crates/ra_hir_def/src/resolver.rs
+++ b/crates/ra_hir_def/src/resolver.rs
@@ -19,7 +19,7 @@ use crate::{
     per_ns::PerNs,
     AdtId, AstItemDef, ConstId, ContainerId, DefWithBodyId, EnumId, EnumVariantId, FunctionId,
     GenericDefId, HasModule, ImplId, LocalModuleId, Lookup, ModuleDefId, ModuleId, StaticId,
-    StructId, TraitId, TypeAliasId, TypeParamId,
+    StructId, TraitId, TypeAliasId, TypeParamId, VariantId,
 };
 
 #[derive(Debug, Clone, Default)]
@@ -544,16 +544,6 @@ impl HasResolver for FunctionId {
     }
 }
 
-impl HasResolver for DefWithBodyId {
-    fn resolver(self, db: &impl DefDatabase) -> Resolver {
-        match self {
-            DefWithBodyId::ConstId(c) => c.resolver(db),
-            DefWithBodyId::FunctionId(f) => f.resolver(db),
-            DefWithBodyId::StaticId(s) => s.resolver(db),
-        }
-    }
-}
-
 impl HasResolver for ConstId {
     fn resolver(self, db: &impl DefDatabase) -> Resolver {
         self.lookup(db).container.resolver(db)
@@ -572,6 +562,25 @@ impl HasResolver for TypeAliasId {
     }
 }
 
+impl HasResolver for ImplId {
+    fn resolver(self, db: &impl DefDatabase) -> Resolver {
+        self.module(db)
+            .resolver(db)
+            .push_generic_params_scope(db, self.into())
+            .push_impl_block_scope(self)
+    }
+}
+
+impl HasResolver for DefWithBodyId {
+    fn resolver(self, db: &impl DefDatabase) -> Resolver {
+        match self {
+            DefWithBodyId::ConstId(c) => c.resolver(db),
+            DefWithBodyId::FunctionId(f) => f.resolver(db),
+            DefWithBodyId::StaticId(s) => s.resolver(db),
+        }
+    }
+}
+
 impl HasResolver for ContainerId {
     fn resolver(self, db: &impl DefDatabase) -> Resolver {
         match self {
@@ -596,11 +605,12 @@ impl HasResolver for GenericDefId {
     }
 }
 
-impl HasResolver for ImplId {
+impl HasResolver for VariantId {
     fn resolver(self, db: &impl DefDatabase) -> Resolver {
-        self.module(db)
-            .resolver(db)
-            .push_generic_params_scope(db, self.into())
-            .push_impl_block_scope(self)
+        match self {
+            VariantId::EnumVariantId(it) => it.parent.resolver(db),
+            VariantId::StructId(it) => it.resolver(db),
+            VariantId::UnionId(it) => it.resolver(db),
+        }
     }
 }
diff --git a/crates/ra_hir_ty/src/infer/coerce.rs b/crates/ra_hir_ty/src/infer/coerce.rs
index 9daa77cfa..0f4dac45e 100644
--- a/crates/ra_hir_ty/src/infer/coerce.rs
+++ b/crates/ra_hir_ty/src/infer/coerce.rs
@@ -332,7 +332,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                     // It will not recurse to `coerce`.
                     return self.table.unify_substs(st1, st2, 0);
                 }
-                _ => {}
+                _ => {
+                    if self.table.unify_inner_trivial(&derefed_ty, &to_ty) {
+                        return true;
+                    }
+                }
             }
         }
 
diff --git a/crates/ra_hir_ty/src/tests/coercion.rs b/crates/ra_hir_ty/src/tests/coercion.rs
index 58b22396f..ac9e3872a 100644
--- a/crates/ra_hir_ty/src/tests/coercion.rs
+++ b/crates/ra_hir_ty/src/tests/coercion.rs
@@ -403,3 +403,40 @@ fn test() {
     "###
     );
 }
+
+#[test]
+fn coerce_autoderef_generic() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+struct Foo;
+fn takes_ref<T>(x: &T) -> T { *x }
+fn test() {
+    takes_ref(&Foo);
+    takes_ref(&&Foo);
+    takes_ref(&&&Foo);
+}
+"#, true),
+        @r###"
+    [29; 30) 'x': &T
+    [41; 47) '{ *x }': T
+    [43; 45) '*x': T
+    [44; 45) 'x': &T
+    [58; 127) '{     ...oo); }': ()
+    [64; 73) 'takes_ref': fn takes_ref<Foo>(&T) -> T
+    [64; 79) 'takes_ref(&Foo)': Foo
+    [74; 78) '&Foo': &Foo
+    [75; 78) 'Foo': Foo
+    [85; 94) 'takes_ref': fn takes_ref<&Foo>(&T) -> T
+    [85; 101) 'takes_...&&Foo)': &Foo
+    [95; 100) '&&Foo': &&Foo
+    [96; 100) '&Foo': &Foo
+    [97; 100) 'Foo': Foo
+    [107; 116) 'takes_ref': fn takes_ref<&&Foo>(&T) -> T
+    [107; 124) 'takes_...&&Foo)': &&Foo
+    [117; 123) '&&&Foo': &&&Foo
+    [118; 123) '&&Foo': &&Foo
+    [119; 123) '&Foo': &Foo
+    [120; 123) 'Foo': Foo
+    "###
+    );
+}
diff --git a/crates/ra_ide/src/parent_module.rs b/crates/ra_ide/src/parent_module.rs
index aef3fa3df..f5a788c07 100644
--- a/crates/ra_ide/src/parent_module.rs
+++ b/crates/ra_ide/src/parent_module.rs
@@ -30,7 +30,7 @@ pub(crate) fn crate_for(db: &RootDatabase, file_id: FileId) -> Vec<CrateId> {
             None => return Vec::new(),
         };
     let krate = module.krate();
-    vec![krate.crate_id()]
+    vec![krate.into()]
 }
 
 #[cfg(test)]
diff --git a/crates/ra_ide/src/references/search_scope.rs b/crates/ra_ide/src/references/search_scope.rs
index f5c9589f4..241dd358f 100644
--- a/crates/ra_ide/src/references/search_scope.rs
+++ b/crates/ra_ide/src/references/search_scope.rs
@@ -5,7 +5,7 @@
 use std::mem;
 
 use hir::{DefWithBody, HasSource, ModuleSource};
-use ra_db::{FileId, SourceDatabase, SourceDatabaseExt};
+use ra_db::{FileId, SourceDatabaseExt};
 use ra_prof::profile;
 use ra_syntax::{AstNode, TextRange};
 use rustc_hash::FxHashMap;
@@ -120,15 +120,11 @@ impl NameDefinition {
             }
             if vis.as_str() == "pub" {
                 let krate = self.container.krate();
-                let crate_graph = db.crate_graph();
-                for crate_id in crate_graph.iter() {
-                    let mut crate_deps = crate_graph.dependencies(crate_id);
-                    if crate_deps.any(|dep| dep.crate_id() == krate.crate_id()) {
-                        let root_file = crate_graph.crate_root(crate_id);
-                        let source_root_id = db.file_source_root(root_file);
-                        let source_root = db.source_root(source_root_id);
-                        res.extend(source_root.walk().map(|id| (id, None)));
-                    }
+                for rev_dep in krate.reverse_dependencies(db) {
+                    let root_file = rev_dep.root_file(db);
+                    let source_root_id = db.file_source_root(root_file);
+                    let source_root = db.source_root(source_root_id);
+                    res.extend(source_root.walk().map(|id| (id, None)));
                 }
                 return SearchScope::new(res);
             }
diff --git a/xtask/src/lib.rs b/xtask/src/lib.rs
index 7332a4072..190baeddf 100644
--- a/xtask/src/lib.rs
+++ b/xtask/src/lib.rs
@@ -79,7 +79,7 @@ pub fn run_rustfmt(mode: Mode) -> Result<()> {
 }
 
 pub fn install_rustfmt() -> Result<()> {
-    run(&format!("rustup install {}", TOOLCHAIN), ".")?;
+    run(&format!("rustup toolchain install {}", TOOLCHAIN), ".")?;
     run(&format!("rustup component add rustfmt --toolchain {}", TOOLCHAIN), ".")
 }
 
@@ -125,7 +125,7 @@ pub fn run_clippy() -> Result<()> {
 }
 
 pub fn install_clippy() -> Result<()> {
-    run(&format!("rustup install {}", TOOLCHAIN), ".")?;
+    run(&format!("rustup toolchain install {}", TOOLCHAIN), ".")?;
     run(&format!("rustup component add clippy --toolchain {}", TOOLCHAIN), ".")
 }