17 files changed, 412 insertions, 207 deletions

diff --git a/crates/ra_ide/src/assists.rs b/crates/ra_ide/src/assists.rs
index e00589733..a936900da 100644
--- a/crates/ra_ide/src/assists.rs
+++ b/crates/ra_ide/src/assists.rs
@@ -2,27 +2,53 @@
 
 use ra_db::{FilePosition, FileRange};
 
-use crate::{db::RootDatabase, SourceChange, SourceFileEdit};
+use crate::{db::RootDatabase, FileId, SourceChange, SourceFileEdit};
 
+use either::Either;
 pub use ra_assists::AssistId;
+use ra_assists::{AssistAction, AssistLabel};
 
 #[derive(Debug)]
 pub struct Assist {
     pub id: AssistId,
-    pub change: SourceChange,
+    pub label: String,
+    pub change_data: Either<SourceChange, Vec<SourceChange>>,
 }
 
 pub(crate) fn assists(db: &RootDatabase, frange: FileRange) -> Vec<Assist> {
     ra_assists::assists(db, frange)
         .into_iter()
-        .map(|(label, action)| {
+        .map(|assist| {
             let file_id = frange.file_id;
-            let file_edit = SourceFileEdit { file_id, edit: action.edit };
-            let id = label.id;
-            let change = SourceChange::source_file_edit(label.label, file_edit).with_cursor_opt(
-                action.cursor_position.map(|offset| FilePosition { offset, file_id }),
-            );
-            Assist { id, change }
+            let assist_label = &assist.label;
+            Assist {
+                id: assist_label.id,
+                label: assist_label.label.clone(),
+                change_data: match assist.action_data {
+                    Either::Left(action) => {
+                        Either::Left(action_to_edit(action, file_id, assist_label))
+                    }
+                    Either::Right(actions) => Either::Right(
+                        actions
+                            .into_iter()
+                            .map(|action| action_to_edit(action, file_id, assist_label))
+                            .collect(),
+                    ),
+                },
+            }
         })
         .collect()
 }
+
+fn action_to_edit(
+    action: AssistAction,
+    file_id: FileId,
+    assist_label: &AssistLabel,
+) -> SourceChange {
+    let file_edit = SourceFileEdit { file_id, edit: action.edit };
+    SourceChange::source_file_edit(
+        action.label.unwrap_or_else(|| assist_label.label.clone()),
+        file_edit,
+    )
+    .with_cursor_opt(action.cursor_position.map(|offset| FilePosition { offset, file_id }))
+}
diff --git a/crates/ra_ide/src/completion/complete_dot.rs b/crates/ra_ide/src/completion/complete_dot.rs
index 210a685e4..2ca78c927 100644
--- a/crates/ra_ide/src/completion/complete_dot.rs
+++ b/crates/ra_ide/src/completion/complete_dot.rs
@@ -27,7 +27,7 @@ pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
     complete_methods(acc, ctx, &receiver_ty);
 
     // Suggest .await syntax for types that implement Future trait
-    if ctx.analyzer.impls_future(ctx.db, receiver_ty) {
+    if receiver_ty.impls_future(ctx.db) {
         CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), "await")
             .detail("expr.await")
             .insert_text("await")
@@ -53,13 +53,16 @@ fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: &Ty
 }
 
 fn complete_methods(acc: &mut Completions, ctx: &CompletionContext, receiver: &Type) {
-    let mut seen_methods = FxHashSet::default();
-    ctx.analyzer.iterate_method_candidates(ctx.db, receiver, None, |_ty, func| {
-        if func.has_self_param(ctx.db) && seen_methods.insert(func.name(ctx.db)) {
-            acc.add_function(ctx, func);
-        }
-        None::<()>
-    });
+    if let Some(krate) = ctx.module.map(|it| it.krate()) {
+        let mut seen_methods = FxHashSet::default();
+        let traits_in_scope = ctx.analyzer.traits_in_scope(ctx.db);
+        receiver.iterate_method_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, func| {
+            if func.has_self_param(ctx.db) && seen_methods.insert(func.name(ctx.db)) {
+                acc.add_function(ctx, func);
+            }
+            None::<()>
+        });
+    }
 }
 
 #[cfg(test)]
@@ -525,6 +528,7 @@ mod tests {
 
             //- /std/lib.rs
             pub mod future {
+                #[lang = "future_trait"]
                 pub trait Future {}
             }
             "###, CompletionKind::Keyword),
diff --git a/crates/ra_ide/src/completion/complete_path.rs b/crates/ra_ide/src/completion/complete_path.rs
index 0dce9dc2d..af24e9f48 100644
--- a/crates/ra_ide/src/completion/complete_path.rs
+++ b/crates/ra_ide/src/completion/complete_path.rs
@@ -49,22 +49,24 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
                 hir::ModuleDef::TypeAlias(a) => a.ty(ctx.db),
                 _ => unreachable!(),
             };
-            ctx.analyzer.iterate_path_candidates(ctx.db, &ty, None, |_ty, item| {
-                match item {
-                    hir::AssocItem::Function(func) => {
-                        if !func.has_self_param(ctx.db) {
-                            acc.add_function(ctx, func);
-                        }
-                    }
-                    hir::AssocItem::Const(ct) => acc.add_const(ctx, ct),
-                    hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
-                }
-                None::<()>
-            });
             // Iterate assoc types separately
             // FIXME: complete T::AssocType
             let krate = ctx.module.map(|m| m.krate());
             if let Some(krate) = krate {
+                let traits_in_scope = ctx.analyzer.traits_in_scope(ctx.db);
+                ty.iterate_path_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, item| {
+                    match item {
+                        hir::AssocItem::Function(func) => {
+                            if !func.has_self_param(ctx.db) {
+                                acc.add_function(ctx, func);
+                            }
+                        }
+                        hir::AssocItem::Const(ct) => acc.add_const(ctx, ct),
+                        hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
+                    }
+                    None::<()>
+                });
+
                 ty.iterate_impl_items(ctx.db, krate, |item| {
                     match item {
                         hir::AssocItem::Function(_) | hir::AssocItem::Const(_) => {}
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index 48d69f7e5..deaacda6c 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -52,15 +52,11 @@ impl<'a> CompletionContext<'a> {
         original_parse: &'a Parse<ast::SourceFile>,
         position: FilePosition,
     ) -> Option<CompletionContext<'a>> {
-        let src = hir::ModuleSource::from_position(db, position);
-        let module = hir::Module::from_definition(
-            db,
-            hir::InFile { file_id: position.file_id.into(), value: src },
-        );
+        let mut sb = hir::SourceBinder::new(db);
+        let module = sb.to_module_def(position.file_id);
         let token =
             original_parse.tree().syntax().token_at_offset(position.offset).left_biased()?;
-        let analyzer = hir::SourceAnalyzer::new(
-            db,
+        let analyzer = sb.analyze(
             hir::InFile::new(position.file_id.into(), &token.parent()),
             Some(position.offset),
         );
diff --git a/crates/ra_ide/src/diagnostics.rs b/crates/ra_ide/src/diagnostics.rs
index 478368529..f403b3bcf 100644
--- a/crates/ra_ide/src/diagnostics.rs
+++ b/crates/ra_ide/src/diagnostics.rs
@@ -23,6 +23,7 @@ pub enum Severity {
 
 pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic> {
     let _p = profile("diagnostics");
+    let mut sb = hir::SourceBinder::new(db);
     let parse = db.parse(file_id);
     let mut res = Vec::new();
 
@@ -108,10 +109,7 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
             fix: Some(fix),
         })
     });
-    let source_file = db.parse(file_id).tree();
-    let src =
-        hir::InFile { file_id: file_id.into(), value: hir::ModuleSource::SourceFile(source_file) };
-    if let Some(m) = hir::Module::from_definition(db, src) {
+    if let Some(m) = sb.to_module_def(file_id) {
         m.diagnostics(db, &mut sink);
     };
     drop(sink);
diff --git a/crates/ra_ide/src/display/function_signature.rs b/crates/ra_ide/src/display/function_signature.rs
index 324ad9552..ddc53a52b 100644
--- a/crates/ra_ide/src/display/function_signature.rs
+++ b/crates/ra_ide/src/display/function_signature.rs
@@ -34,6 +34,8 @@ pub struct FunctionSignature {
     pub generic_parameters: Vec<String>,
     /// Parameters of the function
     pub parameters: Vec<String>,
+    /// Parameter names of the function
+    pub parameter_names: Vec<String>,
     /// Optional return type
     pub ret_type: Option<String>,
     /// Where predicates
@@ -75,6 +77,7 @@ impl FunctionSignature {
                 name: node.name().map(|n| n.text().to_string()),
                 ret_type: node.name().map(|n| n.text().to_string()),
                 parameters: params,
+                parameter_names: vec![],
                 generic_parameters: generic_parameters(&node),
                 where_predicates: where_predicates(&node),
                 doc: None,
@@ -114,6 +117,7 @@ impl FunctionSignature {
                 name: Some(name),
                 ret_type: None,
                 parameters: params,
+                parameter_names: vec![],
                 generic_parameters: vec![],
                 where_predicates: vec![],
                 doc: None,
@@ -134,6 +138,7 @@ impl FunctionSignature {
                 name: node.name().map(|n| n.text().to_string()),
                 ret_type: None,
                 parameters: params,
+                parameter_names: vec![],
                 generic_parameters: vec![],
                 where_predicates: vec![],
                 doc: None,
@@ -157,6 +162,20 @@ impl From<&'_ ast::FnDef> for FunctionSignature {
             res
         }
 
+        fn param_name_list(node: &ast::FnDef) -> Vec<String> {
+            let mut res = vec![];
+            if let Some(param_list) = node.param_list() {
+                if let Some(self_param) = param_list.self_param() {
+                    res.push(self_param.syntax().text().to_string())
+                }
+
+                res.extend(param_list.params().map(|param| {
+                    param.pat().map(|pat| pat.syntax().text().to_string()).unwrap_or_default()
+                }));
+            }
+            res
+        }
+
         FunctionSignature {
             kind: CallableKind::Function,
             visibility: node.visibility().map(|n| n.syntax().text().to_string()),
@@ -166,6 +185,7 @@ impl From<&'_ ast::FnDef> for FunctionSignature {
                 .and_then(|r| r.type_ref())
                 .map(|n| n.syntax().text().to_string()),
             parameters: param_list(node),
+            parameter_names: param_name_list(node),
             generic_parameters: generic_parameters(node),
             where_predicates: where_predicates(node),
             // docs are processed separately
diff --git a/crates/ra_ide/src/goto_definition.rs b/crates/ra_ide/src/goto_definition.rs
index 79d332e8c..5a12a619c 100644
--- a/crates/ra_ide/src/goto_definition.rs
+++ b/crates/ra_ide/src/goto_definition.rs
@@ -1,6 +1,6 @@
 //! FIXME: write short doc here
 
-use hir::{db::AstDatabase, InFile};
+use hir::{db::AstDatabase, InFile, SourceBinder};
 use ra_syntax::{
     ast::{self, DocCommentsOwner},
     match_ast, AstNode,
@@ -24,13 +24,14 @@ pub(crate) fn goto_definition(
     let original_token = pick_best(file.token_at_offset(position.offset))?;
     let token = descend_into_macros(db, position.file_id, original_token.clone());
 
+    let mut sb = SourceBinder::new(db);
     let nav_targets = match_ast! {
         match (token.value.parent()) {
             ast::NameRef(name_ref) => {
-                reference_definition(db, token.with_value(&name_ref)).to_vec()
+                reference_definition(&mut sb, token.with_value(&name_ref)).to_vec()
             },
             ast::Name(name) => {
-                name_definition(db, token.with_value(&name))?
+                name_definition(&mut sb, token.with_value(&name))?
             },
             _ => return None,
         }
@@ -67,19 +68,19 @@ impl ReferenceResult {
 }
 
 pub(crate) fn reference_definition(
-    db: &RootDatabase,
+    sb: &mut SourceBinder<RootDatabase>,
     name_ref: InFile<&ast::NameRef>,
 ) -> ReferenceResult {
     use self::ReferenceResult::*;
 
-    let name_kind = classify_name_ref(db, name_ref).map(|d| d.kind);
+    let name_kind = classify_name_ref(sb, name_ref).map(|d| d.kind);
     match name_kind {
-        Some(Macro(it)) => return Exact(it.to_nav(db)),
-        Some(Field(it)) => return Exact(it.to_nav(db)),
-        Some(TypeParam(it)) => return Exact(it.to_nav(db)),
-        Some(AssocItem(it)) => return Exact(it.to_nav(db)),
-        Some(Local(it)) => return Exact(it.to_nav(db)),
-        Some(Def(def)) => match NavigationTarget::from_def(db, def) {
+        Some(Macro(it)) => return Exact(it.to_nav(sb.db)),
+        Some(Field(it)) => return Exact(it.to_nav(sb.db)),
+        Some(TypeParam(it)) => return Exact(it.to_nav(sb.db)),
+        Some(AssocItem(it)) => return Exact(it.to_nav(sb.db)),
+        Some(Local(it)) => return Exact(it.to_nav(sb.db)),
+        Some(Def(def)) => match NavigationTarget::from_def(sb.db, def) {
             Some(nav) => return Exact(nav),
             None => return Approximate(vec![]),
         },
@@ -87,21 +88,21 @@ pub(crate) fn reference_definition(
             // FIXME: ideally, this should point to the type in the impl, and
             // not at the whole impl. And goto **type** definition should bring
             // us to the actual type
-            return Exact(imp.to_nav(db));
+            return Exact(imp.to_nav(sb.db));
         }
         None => {}
     };
 
     // Fallback index based approach:
-    let navs = crate::symbol_index::index_resolve(db, name_ref.value)
+    let navs = crate::symbol_index::index_resolve(sb.db, name_ref.value)
         .into_iter()
-        .map(|s| s.to_nav(db))
+        .map(|s| s.to_nav(sb.db))
         .collect();
     Approximate(navs)
 }
 
-pub(crate) fn name_definition(
-    db: &RootDatabase,
+fn name_definition(
+    sb: &mut SourceBinder<RootDatabase>,
     name: InFile<&ast::Name>,
 ) -> Option<Vec<NavigationTarget>> {
     let parent = name.value.syntax().parent()?;
@@ -109,14 +110,14 @@ pub(crate) fn name_definition(
     if let Some(module) = ast::Module::cast(parent.clone()) {
         if module.has_semi() {
             let src = name.with_value(module);
-            if let Some(child_module) = hir::Module::from_declaration(db, src) {
-                let nav = child_module.to_nav(db);
+            if let Some(child_module) = sb.to_def(src) {
+                let nav = child_module.to_nav(sb.db);
                 return Some(vec![nav]);
             }
         }
     }
 
-    if let Some(nav) = named_target(db, name.with_value(&parent)) {
+    if let Some(nav) = named_target(sb.db, name.with_value(&parent)) {
         return Some(vec![nav]);
     }
 
diff --git a/crates/ra_ide/src/hover.rs b/crates/ra_ide/src/hover.rs
index 5548681f1..6661e5cb2 100644
--- a/crates/ra_ide/src/hover.rs
+++ b/crates/ra_ide/src/hover.rs
@@ -1,6 +1,6 @@
 //! FIXME: write short doc here
 
-use hir::{db::AstDatabase, Adt, HasSource, HirDisplay};
+use hir::{db::AstDatabase, Adt, HasSource, HirDisplay, SourceBinder};
 use ra_db::SourceDatabase;
 use ra_syntax::{
     algo::find_covering_element,
@@ -152,13 +152,14 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
 
     let mut res = HoverResult::new();
 
+    let mut sb = SourceBinder::new(db);
     if let Some((range, name_kind)) = match_ast! {
         match (token.value.parent()) {
             ast::NameRef(name_ref) => {
-                classify_name_ref(db, token.with_value(&name_ref)).map(|d| (name_ref.syntax().text_range(), d.kind))
+                classify_name_ref(&mut sb, token.with_value(&name_ref)).map(|d| (name_ref.syntax().text_range(), d.kind))
             },
             ast::Name(name) => {
-                classify_name(db, token.with_value(&name)).map(|d| (name.syntax().text_range(), d.kind))
+                classify_name(&mut sb, token.with_value(&name)).map(|d| (name.syntax().text_range(), d.kind))
             },
             _ => None,
         }
@@ -742,7 +743,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
             }
             fn foo(bar:u32) {
                 let a = id!(ba<|>r);
-            }            
+            }
             ",
             &["u32"],
         );
diff --git a/crates/ra_ide/src/impls.rs b/crates/ra_ide/src/impls.rs
index 31195036e..9834025d3 100644
--- a/crates/ra_ide/src/impls.rs
+++ b/crates/ra_ide/src/impls.rs
@@ -1,6 +1,6 @@
 //! FIXME: write short doc here
 
-use hir::{FromSource, ImplBlock};
+use hir::{Crate, ImplBlock, SourceBinder};
 use ra_db::SourceDatabase;
 use ra_syntax::{algo::find_node_at_offset, ast, AstNode};
 
@@ -12,22 +12,19 @@ pub(crate) fn goto_implementation(
 ) -> Option<RangeInfo<Vec<NavigationTarget>>> {
     let parse = db.parse(position.file_id);
     let syntax = parse.tree().syntax().clone();
+    let mut sb = SourceBinder::new(db);
 
-    let src = hir::ModuleSource::from_position(db, position);
-    let module = hir::Module::from_definition(
-        db,
-        hir::InFile { file_id: position.file_id.into(), value: src },
-    )?;
+    let krate = sb.to_module_def(position.file_id)?.krate();
 
     if let Some(nominal_def) = find_node_at_offset::<ast::NominalDef>(&syntax, position.offset) {
         return Some(RangeInfo::new(
             nominal_def.syntax().text_range(),
-            impls_for_def(db, position, &nominal_def, module)?,
+            impls_for_def(&mut sb, position, &nominal_def, krate)?,
         ));
     } else if let Some(trait_def) = find_node_at_offset::<ast::TraitDef>(&syntax, position.offset) {
         return Some(RangeInfo::new(
             trait_def.syntax().text_range(),
-            impls_for_trait(db, position, &trait_def, module)?,
+            impls_for_trait(&mut sb, position, &trait_def, krate)?,
         ));
     }
 
@@ -35,51 +32,49 @@ pub(crate) fn goto_implementation(
 }
 
 fn impls_for_def(
-    db: &RootDatabase,
+    sb: &mut SourceBinder<RootDatabase>,
     position: FilePosition,
     node: &ast::NominalDef,
-    module: hir::Module,
+    krate: Crate,
 ) -> Option<Vec<NavigationTarget>> {
     let ty = match node {
         ast::NominalDef::StructDef(def) => {
             let src = hir::InFile { file_id: position.file_id.into(), value: def.clone() };
-            hir::Struct::from_source(db, src)?.ty(db)
+            sb.to_def(src)?.ty(sb.db)
         }
         ast::NominalDef::EnumDef(def) => {
             let src = hir::InFile { file_id: position.file_id.into(), value: def.clone() };
-            hir::Enum::from_source(db, src)?.ty(db)
+            sb.to_def(src)?.ty(sb.db)
         }
         ast::NominalDef::UnionDef(def) => {
             let src = hir::InFile { file_id: position.file_id.into(), value: def.clone() };
-            hir::Union::from_source(db, src)?.ty(db)
+            sb.to_def(src)?.ty(sb.db)
         }
     };
 
-    let krate = module.krate();
-    let impls = ImplBlock::all_in_crate(db, krate);
+    let impls = ImplBlock::all_in_crate(sb.db, krate);
 
     Some(
         impls
             .into_iter()
-            .filter(|impl_block| ty.is_equal_for_find_impls(&impl_block.target_ty(db)))
-            .map(|imp| imp.to_nav(db))
+            .filter(|impl_block| ty.is_equal_for_find_impls(&impl_block.target_ty(sb.db)))
+            .map(|imp| imp.to_nav(sb.db))
             .collect(),
     )
 }
 
 fn impls_for_trait(
-    db: &RootDatabase,
+    sb: &mut SourceBinder<RootDatabase>,
     position: FilePosition,
     node: &ast::TraitDef,
-    module: hir::Module,
+    krate: Crate,
 ) -> Option<Vec<NavigationTarget>> {
     let src = hir::InFile { file_id: position.file_id.into(), value: node.clone() };
-    let tr = hir::Trait::from_source(db, src)?;
+    let tr = sb.to_def(src)?;
 
-    let krate = module.krate();
-    let impls = ImplBlock::for_trait(db, krate, tr);
+    let impls = ImplBlock::for_trait(sb.db, krate, tr);
 
-    Some(impls.into_iter().map(|imp| imp.to_nav(db)).collect())
+    Some(impls.into_iter().map(|imp| imp.to_nav(sb.db)).collect())
 }
 
 #[cfg(test)]
@@ -210,7 +205,7 @@ mod tests {
             "
             //- /lib.rs
             #[derive(Copy)]
-            struct Foo<|>;            
+            struct Foo<|>;
             ",
             &["impl IMPL_BLOCK FileId(1) [0; 15)"],
         );
diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index 977aafc51..1b631c7cd 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -1,18 +1,19 @@
 //! FIXME: write short doc here
 
-use hir::{HirDisplay, SourceAnalyzer};
+use hir::{HirDisplay, SourceAnalyzer, SourceBinder};
 use once_cell::unsync::Lazy;
 use ra_prof::profile;
 use ra_syntax::{
-    ast::{self, AstNode, TypeAscriptionOwner},
+    ast::{self, ArgListOwner, AstNode, TypeAscriptionOwner},
     match_ast, SmolStr, SourceFile, SyntaxKind, SyntaxNode, TextRange,
 };
 
-use crate::{db::RootDatabase, FileId};
+use crate::{db::RootDatabase, FileId, FunctionSignature};
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum InlayKind {
     TypeHint,
+    ParameterHint,
 }
 
 #[derive(Debug)]
@@ -28,22 +29,24 @@ pub(crate) fn inlay_hints(
     file: &SourceFile,
     max_inlay_hint_length: Option<usize>,
 ) -> Vec<InlayHint> {
-    file.syntax()
-        .descendants()
-        .flat_map(|node| get_inlay_hints(db, file_id, &node, max_inlay_hint_length))
-        .flatten()
-        .collect()
+    let mut sb = SourceBinder::new(db);
+    let mut res = Vec::new();
+    for node in file.syntax().descendants() {
+        get_inlay_hints(&mut res, &mut sb, file_id, &node, max_inlay_hint_length);
+    }
+    res
 }
 
 fn get_inlay_hints(
-    db: &RootDatabase,
+    acc: &mut Vec<InlayHint>,
+    sb: &mut SourceBinder<RootDatabase>,
     file_id: FileId,
     node: &SyntaxNode,
     max_inlay_hint_length: Option<usize>,
-) -> Option<Vec<InlayHint>> {
+) -> Option<()> {
     let _p = profile("get_inlay_hints");
-    let analyzer =
-        Lazy::new(|| SourceAnalyzer::new(db, hir::InFile::new(file_id.into(), node), None));
+    let db = sb.db;
+    let analyzer = Lazy::new(move || sb.analyze(hir::InFile::new(file_id.into(), node), None));
     match_ast! {
         match node {
             ast::LetStmt(it) => {
@@ -51,7 +54,7 @@ fn get_inlay_hints(
                     return None;
                 }
                 let pat = it.pat()?;
-                Some(get_pat_type_hints(db, &analyzer, pat, false, max_inlay_hint_length))
+                get_pat_type_hints(acc, db, &analyzer, pat, false, max_inlay_hint_length);
             },
             ast::LambdaExpr(it) => {
                 it.param_list().map(|param_list| {
@@ -59,49 +62,115 @@ fn get_inlay_hints(
                         .params()
                         .filter(|closure_param| closure_param.ascribed_type().is_none())
                         .filter_map(|closure_param| closure_param.pat())
-                        .map(|root_pat| get_pat_type_hints(db, &analyzer, root_pat, false, max_inlay_hint_length))
-                        .flatten()
-                        .collect()
-                })
+                        .for_each(|root_pat| get_pat_type_hints(acc, db, &analyzer, root_pat, false, max_inlay_hint_length))
+                });
             },
             ast::ForExpr(it) => {
                 let pat = it.pat()?;
-                Some(get_pat_type_hints(db, &analyzer, pat, false, max_inlay_hint_length))
+                get_pat_type_hints(acc, db, &analyzer, pat, false, max_inlay_hint_length);
             },
             ast::IfExpr(it) => {
                 let pat = it.condition()?.pat()?;
-                Some(get_pat_type_hints(db, &analyzer, pat, true, max_inlay_hint_length))
+                get_pat_type_hints(acc, db, &analyzer, pat, true, max_inlay_hint_length);
             },
             ast::WhileExpr(it) => {
                 let pat = it.condition()?.pat()?;
-                Some(get_pat_type_hints(db, &analyzer, pat, true, max_inlay_hint_length))
+                get_pat_type_hints(acc, db, &analyzer, pat, true, max_inlay_hint_length);
             },
             ast::MatchArmList(it) => {
-                Some(
-                    it
-                        .arms()
-                        .map(|match_arm| match_arm.pats())
-                        .flatten()
-                        .map(|root_pat| get_pat_type_hints(db, &analyzer, root_pat, true, max_inlay_hint_length))
-                        .flatten()
-                        .collect(),
-                )
-            },
-            _ => None,
+                it.arms()
+                    .map(|match_arm| match_arm.pats())
+                    .flatten()
+                    .for_each(|root_pat| get_pat_type_hints(acc, db, &analyzer, root_pat, true, max_inlay_hint_length));
+            },
+            ast::CallExpr(it) => {
+                get_param_name_hints(acc, db, &analyzer, ast::Expr::from(it));
+            },
+            ast::MethodCallExpr(it) => {
+                get_param_name_hints(acc, db, &analyzer, ast::Expr::from(it));
+            },
+            _ => (),
         }
+    };
+    Some(())
+}
+
+fn get_param_name_hints(
+    acc: &mut Vec<InlayHint>,
+    db: &RootDatabase,
+    analyzer: &SourceAnalyzer,
+    expr: ast::Expr,
+) -> Option<()> {
+    let args = match &expr {
+        ast::Expr::CallExpr(expr) => expr.arg_list()?.args(),
+        ast::Expr::MethodCallExpr(expr) => expr.arg_list()?.args(),
+        _ => return None,
+    };
+
+    let mut parameters = get_fn_signature(db, analyzer, &expr)?.parameter_names.into_iter();
+
+    if let ast::Expr::MethodCallExpr(_) = &expr {
+        parameters.next();
+    };
+
+    let hints = parameters
+        .zip(args)
+        .filter_map(|(param, arg)| {
+            if arg.syntax().kind() == SyntaxKind::LITERAL {
+                Some((arg.syntax().text_range(), param))
+            } else {
+                None
+            }
+        })
+        .map(|(range, param_name)| InlayHint {
+            range,
+            kind: InlayKind::ParameterHint,
+            label: param_name.into(),
+        });
+
+    acc.extend(hints);
+    Some(())
+}
+
+fn get_fn_signature(
+    db: &RootDatabase,
+    analyzer: &SourceAnalyzer,
+    expr: &ast::Expr,
+) -> Option<FunctionSignature> {
+    match expr {
+        ast::Expr::CallExpr(expr) => {
+            // FIXME: Type::as_callable is broken for closures
+            let callable_def = analyzer.type_of(db, &expr.expr()?)?.as_callable()?;
+            match callable_def {
+                hir::CallableDef::FunctionId(it) => {
+                    let fn_def = it.into();
+                    Some(FunctionSignature::from_hir(db, fn_def))
+                }
+                hir::CallableDef::StructId(it) => FunctionSignature::from_struct(db, it.into()),
+                hir::CallableDef::EnumVariantId(it) => {
+                    FunctionSignature::from_enum_variant(db, it.into())
+                }
+            }
+        }
+        ast::Expr::MethodCallExpr(expr) => {
+            let fn_def = analyzer.resolve_method_call(&expr)?;
+            Some(FunctionSignature::from_hir(db, fn_def))
+        }
+        _ => None,
     }
 }
 
 fn get_pat_type_hints(
+    acc: &mut Vec<InlayHint>,
     db: &RootDatabase,
     analyzer: &SourceAnalyzer,
     root_pat: ast::Pat,
     skip_root_pat_hint: bool,
     max_inlay_hint_length: Option<usize>,
-) -> Vec<InlayHint> {
+) {
     let original_pat = &root_pat.clone();
 
-    get_leaf_pats(root_pat)
+    let hints = get_leaf_pats(root_pat)
         .into_iter()
         .filter(|pat| !skip_root_pat_hint || pat != original_pat)
         .filter_map(|pat| {
@@ -115,8 +184,9 @@ fn get_pat_type_hints(
             range,
             kind: InlayKind::TypeHint,
             label: pat_type.display_truncated(db, max_inlay_hint_length).to_string().into(),
-        })
-        .collect()
+        });
+
+    acc.extend(hints);
 }
 
 fn get_leaf_pats(root_pat: ast::Pat) -> Vec<ast::Pat> {
@@ -605,4 +675,71 @@ fn main() {
         "###
         );
     }
+
+    #[test]
+    fn function_call_parameter_hint() {
+        let (analysis, file_id) = single_file(
+            r#"
+struct Test {}
+
+impl Test {
+    fn method(&self, param: i32) -> i32 {
+        param * 2
+    }
+}
+
+fn test_func(foo: i32, bar: i32, msg: &str, _: i32, last: i32) -> i32 {
+    foo + bar
+}
+
+fn main() {
+    let not_literal = 1;
+    let _: i32 = test_func(1, 2, "hello", 3, not_literal);
+    let t: Test = Test {};
+    t.method(123);
+    Test::method(&t, 3456);
+}"#,
+        );
+
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, None).unwrap(), @r###"
+        [
+            InlayHint {
+                range: [207; 218),
+                kind: TypeHint,
+                label: "i32",
+            },
+            InlayHint {
+                range: [251; 252),
+                kind: ParameterHint,
+                label: "foo",
+            },
+            InlayHint {
+                range: [254; 255),
+                kind: ParameterHint,
+                label: "bar",
+            },
+            InlayHint {
+                range: [257; 264),
+                kind: ParameterHint,
+                label: "msg",
+            },
+            InlayHint {
+                range: [266; 267),
+                kind: ParameterHint,
+                label: "_",
+            },
+            InlayHint {
+                range: [323; 326),
+                kind: ParameterHint,
+                label: "param",
+            },
+            InlayHint {
+                range: [350; 354),
+                kind: ParameterHint,
+                label: "param",
+            },
+        ]
+        "###
+        );
+    }
 }
diff --git a/crates/ra_ide/src/parent_module.rs b/crates/ra_ide/src/parent_module.rs
index f5a788c07..2dbccfc3b 100644
--- a/crates/ra_ide/src/parent_module.rs
+++ b/crates/ra_ide/src/parent_module.rs
@@ -1,17 +1,23 @@
 //! FIXME: write short doc here
 
 use ra_db::{CrateId, FileId, FilePosition, SourceDatabase};
+use ra_syntax::{
+    algo::find_node_at_offset,
+    ast::{self, AstNode},
+};
 
 use crate::{db::RootDatabase, NavigationTarget};
 
 /// This returns `Vec` because a module may be included from several places. We
 /// don't handle this case yet though, so the Vec has length at most one.
 pub(crate) fn parent_module(db: &RootDatabase, position: FilePosition) -> Vec<NavigationTarget> {
-    let src = hir::ModuleSource::from_position(db, position);
-    let module = match hir::Module::from_definition(
-        db,
-        hir::InFile { file_id: position.file_id.into(), value: src },
-    ) {
+    let mut sb = hir::SourceBinder::new(db);
+    let parse = db.parse(position.file_id);
+    let module = match find_node_at_offset::<ast::Module>(parse.tree().syntax(), position.offset) {
+        Some(module) => sb.to_def(hir::InFile::new(position.file_id.into(), module)),
+        None => sb.to_module_def(position.file_id),
+    };
+    let module = match module {
         None => return Vec::new(),
         Some(it) => it,
     };
@@ -21,14 +27,11 @@ pub(crate) fn parent_module(db: &RootDatabase, position: FilePosition) -> Vec<Na
 
 /// Returns `Vec` for the same reason as `parent_module`
 pub(crate) fn crate_for(db: &RootDatabase, file_id: FileId) -> Vec<CrateId> {
-    let source_file = db.parse(file_id).tree();
-    let src = hir::ModuleSource::SourceFile(source_file);
-    let module =
-        match hir::Module::from_definition(db, hir::InFile { file_id: file_id.into(), value: src })
-        {
-            Some(it) => it,
-            None => return Vec::new(),
-        };
+    let mut sb = hir::SourceBinder::new(db);
+    let module = match sb.to_module_def(file_id) {
+        Some(it) => it,
+        None => return Vec::new(),
+    };
     let krate = module.krate();
     vec![krate.into()]
 }
diff --git a/crates/ra_ide/src/references.rs b/crates/ra_ide/src/references.rs
index 2c753dade..5e2fe1905 100644
--- a/crates/ra_ide/src/references.rs
+++ b/crates/ra_ide/src/references.rs
@@ -14,7 +14,7 @@ mod name_definition;
 mod rename;
 mod search_scope;
 
-use hir::InFile;
+use hir::{InFile, SourceBinder};
 use once_cell::unsync::Lazy;
 use ra_db::{SourceDatabase, SourceDatabaseExt};
 use ra_prof::profile;
@@ -171,13 +171,14 @@ fn find_name(
     syntax: &SyntaxNode,
     position: FilePosition,
 ) -> Option<RangeInfo<(String, NameDefinition)>> {
+    let mut sb = SourceBinder::new(db);
     if let Some(name) = find_node_at_offset::<ast::Name>(&syntax, position.offset) {
-        let def = classify_name(db, InFile::new(position.file_id.into(), &name))?;
+        let def = classify_name(&mut sb, InFile::new(position.file_id.into(), &name))?;
         let range = name.syntax().text_range();
         return Some(RangeInfo::new(range, (name.text().to_string(), def)));
     }
     let name_ref = find_node_at_offset::<ast::NameRef>(&syntax, position.offset)?;
-    let def = classify_name_ref(db, InFile::new(position.file_id.into(), &name_ref))?;
+    let def = classify_name_ref(&mut sb, InFile::new(position.file_id.into(), &name_ref))?;
     let range = name_ref.syntax().text_range();
     Some(RangeInfo::new(range, (name_ref.text().to_string(), def)))
 }
@@ -195,7 +196,9 @@ fn process_definition(
 
     for (file_id, search_range) in scope {
         let text = db.file_text(file_id);
+
         let parse = Lazy::new(|| SourceFile::parse(&text));
+        let mut sb = Lazy::new(|| SourceBinder::new(db));
 
         for (idx, _) in text.match_indices(pat) {
             let offset = TextUnit::from_usize(idx);
@@ -209,7 +212,11 @@ fn process_definition(
                         continue;
                     }
                 }
-                if let Some(d) = classify_name_ref(db, InFile::new(file_id.into(), &name_ref)) {
+                // FIXME: reuse sb
+                // See https://github.com/rust-lang/rust/pull/68198#issuecomment-574269098
+
+                if let Some(d) = classify_name_ref(&mut sb, InFile::new(file_id.into(), &name_ref))
+                {
                     if d == def {
                         let kind = if name_ref
                             .syntax()
@@ -309,7 +316,7 @@ mod tests {
     }
     impl Foo {
         fn f() -> i32 { 42 }
-    }    
+    }
     fn main() {
         let f: Foo;
         f = Foo {a: Foo::f()};
@@ -319,7 +326,7 @@ mod tests {
         check_result(
             refs,
             "Foo STRUCT_DEF FileId(1) [5; 39) [12; 15) Other",
-            &["FileId(1) [142; 145) StructLiteral"],
+            &["FileId(1) [138; 141) StructLiteral"],
         );
     }
 
diff --git a/crates/ra_ide/src/references/classify.rs b/crates/ra_ide/src/references/classify.rs
index 3483a7176..46cba30a3 100644
--- a/crates/ra_ide/src/references/classify.rs
+++ b/crates/ra_ide/src/references/classify.rs
@@ -1,6 +1,6 @@
 //! Functions that are used to classify an element from its definition or reference.
 
-use hir::{FromSource, InFile, Module, ModuleSource, PathResolution, SourceAnalyzer};
+use hir::{InFile, PathResolution, SourceBinder};
 use ra_prof::profile;
 use ra_syntax::{ast, match_ast, AstNode};
 use test_utils::tested_by;
@@ -11,7 +11,10 @@ use super::{
 };
 use crate::db::RootDatabase;
 
-pub(crate) fn classify_name(db: &RootDatabase, name: InFile<&ast::Name>) -> Option<NameDefinition> {
+pub(crate) fn classify_name(
+    sb: &mut SourceBinder<RootDatabase>,
+    name: InFile<&ast::Name>,
+) -> Option<NameDefinition> {
     let _p = profile("classify_name");
     let parent = name.value.syntax().parent()?;
 
@@ -19,90 +22,79 @@ pub(crate) fn classify_name(db: &RootDatabase, name: InFile<&ast::Name>) -> Opti
         match parent {
             ast::BindPat(it) => {
                 let src = name.with_value(it);
-                let local = hir::Local::from_source(db, src)?;
+                let local = sb.to_def(src)?;
                 Some(NameDefinition {
                     visibility: None,
-                    container: local.module(db),
+                    container: local.module(sb.db),
                     kind: NameKind::Local(local),
                 })
             },
             ast::RecordFieldDef(it) => {
-                let ast = hir::FieldSource::Named(it);
-                let src = name.with_value(ast);
-                let field = hir::StructField::from_source(db, src)?;
-                Some(from_struct_field(db, field))
+                let src = name.with_value(it);
+                let field: hir::StructField = sb.to_def(src)?;
+                Some(from_struct_field(sb.db, field))
             },
             ast::Module(it) => {
-                let def = {
-                    if !it.has_semi() {
-                        let ast = hir::ModuleSource::Module(it);
-                        let src = name.with_value(ast);
-                        hir::Module::from_definition(db, src)
-                    } else {
-                        let src = name.with_value(it);
-                        hir::Module::from_declaration(db, src)
-                    }
-                }?;
-                Some(from_module_def(db, def.into(), None))
+                let def = sb.to_def(name.with_value(it))?;
+                Some(from_module_def(sb.db, def.into(), None))
             },
             ast::StructDef(it) => {
                 let src = name.with_value(it);
-                let def = hir::Struct::from_source(db, src)?;
-                Some(from_module_def(db, def.into(), None))
+                let def: hir::Struct = sb.to_def(src)?;
+                Some(from_module_def(sb.db, def.into(), None))
             },
             ast::EnumDef(it) => {
                 let src = name.with_value(it);
-                let def = hir::Enum::from_source(db, src)?;
-                Some(from_module_def(db, def.into(), None))
+                let def: hir::Enum = sb.to_def(src)?;
+                Some(from_module_def(sb.db, def.into(), None))
             },
             ast::TraitDef(it) => {
                 let src = name.with_value(it);
-                let def = hir::Trait::from_source(db, src)?;
-                Some(from_module_def(db, def.into(), None))
+                let def: hir::Trait = sb.to_def(src)?;
+                Some(from_module_def(sb.db, def.into(), None))
             },
             ast::StaticDef(it) => {
                 let src = name.with_value(it);
-                let def = hir::Static::from_source(db, src)?;
-                Some(from_module_def(db, def.into(), None))
+                let def: hir::Static = sb.to_def(src)?;
+                Some(from_module_def(sb.db, def.into(), None))
             },
             ast::EnumVariant(it) => {
                 let src = name.with_value(it);
-                let def = hir::EnumVariant::from_source(db, src)?;
-                Some(from_module_def(db, def.into(), None))
+                let def: hir::EnumVariant = sb.to_def(src)?;
+                Some(from_module_def(sb.db, def.into(), None))
             },
             ast::FnDef(it) => {
                 let src = name.with_value(it);
-                let def = hir::Function::from_source(db, src)?;
+                let def: hir::Function = sb.to_def(src)?;
                 if parent.parent().and_then(ast::ItemList::cast).is_some() {
-                    Some(from_assoc_item(db, def.into()))
+                    Some(from_assoc_item(sb.db, def.into()))
                 } else {
-                    Some(from_module_def(db, def.into(), None))
+                    Some(from_module_def(sb.db, def.into(), None))
                 }
             },
             ast::ConstDef(it) => {
                 let src = name.with_value(it);
-                let def = hir::Const::from_source(db, src)?;
+                let def: hir::Const = sb.to_def(src)?;
                 if parent.parent().and_then(ast::ItemList::cast).is_some() {
-                    Some(from_assoc_item(db, def.into()))
+                    Some(from_assoc_item(sb.db, def.into()))
                 } else {
-                    Some(from_module_def(db, def.into(), None))
+                    Some(from_module_def(sb.db, def.into(), None))
                 }
             },
             ast::TypeAliasDef(it) => {
                 let src = name.with_value(it);
-                let def = hir::TypeAlias::from_source(db, src)?;
+                let def: hir::TypeAlias = sb.to_def(src)?;
                 if parent.parent().and_then(ast::ItemList::cast).is_some() {
-                    Some(from_assoc_item(db, def.into()))
+                    Some(from_assoc_item(sb.db, def.into()))
                 } else {
-                    Some(from_module_def(db, def.into(), None))
+                    Some(from_module_def(sb.db, def.into(), None))
                 }
             },
             ast::MacroCall(it) => {
                 let src = name.with_value(it);
-                let def = hir::MacroDef::from_source(db, src.clone())?;
+                let def = sb.to_def(src.clone())?;
 
-                let module_src = ModuleSource::from_child_node(db, src.as_ref().map(|it| it.syntax()));
-                let module = Module::from_definition(db, src.with_value(module_src))?;
+                let module = sb.to_module_def(src.file_id.original_file(sb.db))?;
 
                 Some(NameDefinition {
                     visibility: None,
@@ -112,10 +104,10 @@ pub(crate) fn classify_name(db: &RootDatabase, name: InFile<&ast::Name>) -> Opti
             },
             ast::TypeParam(it) => {
                 let src = name.with_value(it);
-                let def = hir::TypeParam::from_source(db, src)?;
+                let def = sb.to_def(src)?;
                 Some(NameDefinition {
                     visibility: None,
-                    container: def.module(db),
+                    container: def.module(sb.db),
                     kind: NameKind::TypeParam(def),
                 })
             },
@@ -125,25 +117,25 @@ pub(crate) fn classify_name(db: &RootDatabase, name: InFile<&ast::Name>) -> Opti
 }
 
 pub(crate) fn classify_name_ref(
-    db: &RootDatabase,
+    sb: &mut SourceBinder<RootDatabase>,
     name_ref: InFile<&ast::NameRef>,
 ) -> Option<NameDefinition> {
     let _p = profile("classify_name_ref");
 
     let parent = name_ref.value.syntax().parent()?;
-    let analyzer = SourceAnalyzer::new(db, name_ref.map(|it| it.syntax()), None);
+    let analyzer = sb.analyze(name_ref.map(|it| it.syntax()), None);
 
     if let Some(method_call) = ast::MethodCallExpr::cast(parent.clone()) {
         tested_by!(goto_def_for_methods);
         if let Some(func) = analyzer.resolve_method_call(&method_call) {
-            return Some(from_assoc_item(db, func.into()));
+            return Some(from_assoc_item(sb.db, func.into()));
         }
     }
 
     if let Some(field_expr) = ast::FieldExpr::cast(parent.clone()) {
         tested_by!(goto_def_for_fields);
         if let Some(field) = analyzer.resolve_field(&field_expr) {
-            return Some(from_struct_field(db, field));
+            return Some(from_struct_field(sb.db, field));
         }
     }
 
@@ -151,35 +143,37 @@ pub(crate) fn classify_name_ref(
         tested_by!(goto_def_for_record_fields);
         tested_by!(goto_def_for_field_init_shorthand);
         if let Some(field_def) = analyzer.resolve_record_field(&record_field) {
-            return Some(from_struct_field(db, field_def));
+            return Some(from_struct_field(sb.db, field_def));
         }
     }
 
-    let ast = ModuleSource::from_child_node(db, name_ref.with_value(&parent));
     // FIXME: find correct container and visibility for each case
-    let container = Module::from_definition(db, name_ref.with_value(ast))?;
     let visibility = None;
+    let container = sb.to_module_def(name_ref.file_id.original_file(sb.db))?;
 
     if let Some(macro_call) = parent.ancestors().find_map(ast::MacroCall::cast) {
         tested_by!(goto_def_for_macros);
-        if let Some(macro_def) = analyzer.resolve_macro_call(db, name_ref.with_value(&macro_call)) {
+        if let Some(macro_def) =
+            analyzer.resolve_macro_call(sb.db, name_ref.with_value(&macro_call))
+        {
             let kind = NameKind::Macro(macro_def);
             return Some(NameDefinition { kind, container, visibility });
         }
     }
 
     let path = name_ref.value.syntax().ancestors().find_map(ast::Path::cast)?;
-    let resolved = analyzer.resolve_path(db, &path)?;
+    let resolved = analyzer.resolve_path(sb.db, &path)?;
     match resolved {
-        PathResolution::Def(def) => Some(from_module_def(db, def, Some(container))),
-        PathResolution::AssocItem(item) => Some(from_assoc_item(db, item)),
+        PathResolution::Def(def) => Some(from_module_def(sb.db, def, Some(container))),
+        PathResolution::AssocItem(item) => Some(from_assoc_item(sb.db, item)),
         PathResolution::Local(local) => {
-            let container = local.module(db);
             let kind = NameKind::Local(local);
+            let container = local.module(sb.db);
             Some(NameDefinition { kind, container, visibility: None })
         }
         PathResolution::TypeParam(par) => {
             let kind = NameKind::TypeParam(par);
+            let container = par.module(sb.db);
             Some(NameDefinition { kind, container, visibility })
         }
         PathResolution::Macro(def) => {
@@ -188,7 +182,7 @@ pub(crate) fn classify_name_ref(
         }
         PathResolution::SelfType(impl_block) => {
             let kind = NameKind::SelfType(impl_block);
-            let container = impl_block.module(db);
+            let container = impl_block.module(sb.db);
             Some(NameDefinition { kind, container, visibility })
         }
     }
diff --git a/crates/ra_ide/src/references/name_definition.rs b/crates/ra_ide/src/references/name_definition.rs
index 8c67c8863..1e4226ab9 100644
--- a/crates/ra_ide/src/references/name_definition.rs
+++ b/crates/ra_ide/src/references/name_definition.rs
@@ -25,6 +25,8 @@ pub enum NameKind {
 #[derive(PartialEq, Eq)]
 pub(crate) struct NameDefinition {
     pub visibility: Option<ast::Visibility>,
+    /// FIXME: this doesn't really make sense. For example, builtin types don't
+    /// really have a module.
     pub container: Module,
     pub kind: NameKind,
 }
diff --git a/crates/ra_ide/src/references/rename.rs b/crates/ra_ide/src/references/rename.rs
index e02985dcd..626efb603 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -63,7 +63,7 @@ fn rename_mod(
     let mut source_file_edits = Vec::new();
     let mut file_system_edits = Vec::new();
     let module_src = hir::InFile { file_id: position.file_id.into(), value: ast_module.clone() };
-    if let Some(module) = hir::Module::from_declaration(db, module_src) {
+    if let Some(module) = hir::SourceBinder::new(db).to_def(module_src) {
         let src = module.definition_source(db);
         let file_id = src.file_id.original_file(db);
         match src.value {
diff --git a/crates/ra_ide/src/runnables.rs b/crates/ra_ide/src/runnables.rs
index e213e1a06..7533692f6 100644
--- a/crates/ra_ide/src/runnables.rs
+++ b/crates/ra_ide/src/runnables.rs
@@ -66,8 +66,8 @@ fn runnable_mod(db: &RootDatabase, file_id: FileId, module: ast::Module) -> Opti
         return None;
     }
     let range = module.syntax().text_range();
-    let src = hir::ModuleSource::from_child_node(db, InFile::new(file_id.into(), &module.syntax()));
-    let module = hir::Module::from_definition(db, InFile::new(file_id.into(), src))?;
+    let mut sb = hir::SourceBinder::new(db);
+    let module = sb.to_def(InFile::new(file_id.into(), module))?;
 
     let path = module.path_to_root(db).into_iter().rev().filter_map(|it| it.name(db)).join("::");
     Some(Runnable { range, kind: RunnableKind::TestMod { path } })
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index 56a36f587..0411977b9 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -2,7 +2,7 @@
 
 use rustc_hash::{FxHashMap, FxHashSet};
 
-use hir::{InFile, Name};
+use hir::{InFile, Name, SourceBinder};
 use ra_db::SourceDatabase;
 use ra_prof::profile;
 use ra_syntax::{ast, AstNode, Direction, SyntaxElement, SyntaxKind, SyntaxKind::*, TextRange, T};
@@ -84,6 +84,8 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
         hash((file_id, name, shadow_count))
     }
 
+    let mut sb = SourceBinder::new(db);
+
     // Visited nodes to handle highlighting priorities
     // FIXME: retain only ranges here
     let mut highlighted: FxHashSet<SyntaxElement> = FxHashSet::default();
@@ -108,8 +110,8 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
             NAME_REF if node.ancestors().any(|it| it.kind() == ATTR) => continue,
             NAME_REF => {
                 let name_ref = node.as_node().cloned().and_then(ast::NameRef::cast).unwrap();
-                let name_kind =
-                    classify_name_ref(db, InFile::new(file_id.into(), &name_ref)).map(|d| d.kind);
+                let name_kind = classify_name_ref(&mut sb, InFile::new(file_id.into(), &name_ref))
+                    .map(|d| d.kind);
                 match name_kind {
                     Some(name_kind) => {
                         if let Local(local) = &name_kind {
@@ -129,7 +131,7 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
             NAME => {
                 let name = node.as_node().cloned().and_then(ast::Name::cast).unwrap();
                 let name_kind =
-                    classify_name(db, InFile::new(file_id.into(), &name)).map(|d| d.kind);
+                    classify_name(&mut sb, InFile::new(file_id.into(), &name)).map(|d| d.kind);
 
                 if let Some(Local(local)) = &name_kind {
                     if let Some(name) = local.name(db) {
@@ -308,9 +310,12 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 
 #[cfg(test)]
 mod tests {
-    use crate::mock_analysis::single_file;
+    use std::fs;
+
     use test_utils::{assert_eq_text, project_dir, read_text};
 
+    use crate::mock_analysis::{single_file, MockAnalysis};
+
     #[test]
     fn test_highlighting() {
         let (analysis, file_id) = single_file(
@@ -357,7 +362,7 @@ impl<X> E<X> {
         let dst_file = project_dir().join("crates/ra_ide/src/snapshots/highlighting.html");
         let actual_html = &analysis.highlight_as_html(file_id, false).unwrap();
         let expected_html = &read_text(&dst_file);
-        std::fs::write(dst_file, &actual_html).unwrap();
+        fs::write(dst_file, &actual_html).unwrap();
         assert_eq_text!(expected_html, actual_html);
     }
 
@@ -383,7 +388,21 @@ fn bar() {
         let dst_file = project_dir().join("crates/ra_ide/src/snapshots/rainbow_highlighting.html");
         let actual_html = &analysis.highlight_as_html(file_id, true).unwrap();
         let expected_html = &read_text(&dst_file);
-        std::fs::write(dst_file, &actual_html).unwrap();
+        fs::write(dst_file, &actual_html).unwrap();
         assert_eq_text!(expected_html, actual_html);
     }
+
+    #[test]
+    fn accidentally_quadratic() {
+        let file = project_dir().join("crates/ra_syntax/test_data/accidentally_quadratic");
+        let src = fs::read_to_string(file).unwrap();
+
+        let mut mock = MockAnalysis::new();
+        let file_id = mock.add_file("/main.rs", &src);
+        let host = mock.analysis_host();
+
+        // let t = std::time::Instant::now();
+        let _ = host.analysis().highlight(file_id).unwrap();
+        // eprintln!("elapsed: {:?}", t.elapsed());
+    }
 }