62 files changed, 920 insertions, 345 deletions

diff --git a/crates/ra_assists/src/ast_transform.rs b/crates/ra_assists/src/ast_transform.rs
index 42856f0ca..45558c448 100644
--- a/crates/ra_assists/src/ast_transform.rs
+++ b/crates/ra_assists/src/ast_transform.rs
@@ -37,7 +37,6 @@ pub struct SubstituteTypeParams<'a> {
 impl<'a> SubstituteTypeParams<'a> {
     pub fn for_trait_impl(
         source_scope: &'a SemanticsScope<'a, RootDatabase>,
-        db: &'a RootDatabase,
         // FIXME: there's implicit invariant that `trait_` and  `source_scope` match...
         trait_: hir::Trait,
         impl_def: ast::ImplDef,
@@ -45,7 +44,7 @@ impl<'a> SubstituteTypeParams<'a> {
         let substs = get_syntactic_substs(impl_def).unwrap_or_default();
         let generic_def: hir::GenericDef = trait_.into();
         let substs_by_param: FxHashMap<_, _> = generic_def
-            .params(db)
+            .params(source_scope.db)
             .into_iter()
             // this is a trait impl, so we need to skip the first type parameter -- this is a bit hacky
             .skip(1)
@@ -104,7 +103,6 @@ impl<'a> AstTransform<'a> for SubstituteTypeParams<'a> {
 pub struct QualifyPaths<'a> {
     target_scope: &'a SemanticsScope<'a, RootDatabase>,
     source_scope: &'a SemanticsScope<'a, RootDatabase>,
-    db: &'a RootDatabase,
     previous: Box<dyn AstTransform<'a> + 'a>,
 }
 
@@ -112,9 +110,8 @@ impl<'a> QualifyPaths<'a> {
     pub fn new(
         target_scope: &'a SemanticsScope<'a, RootDatabase>,
         source_scope: &'a SemanticsScope<'a, RootDatabase>,
-        db: &'a RootDatabase,
     ) -> Self {
-        Self { target_scope, source_scope, db, previous: Box::new(NullTransformer) }
+        Self { target_scope, source_scope, previous: Box::new(NullTransformer) }
     }
 
     fn get_substitution_inner(
@@ -132,7 +129,7 @@ impl<'a> QualifyPaths<'a> {
         let resolution = self.source_scope.resolve_hir_path(&hir_path?)?;
         match resolution {
             PathResolution::Def(def) => {
-                let found_path = from.find_use_path(self.db, def)?;
+                let found_path = from.find_use_path(self.source_scope.db, def)?;
                 let mut path = path_to_ast(found_path);
 
                 let type_args = p
diff --git a/crates/ra_assists/src/handlers/add_missing_impl_members.rs b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
index 639180d37..e5920b6f6 100644
--- a/crates/ra_assists/src/handlers/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
@@ -142,8 +142,8 @@ fn add_missing_impl_members_inner(
         let n_existing_items = impl_item_list.impl_items().count();
         let source_scope = sema.scope_for_def(trait_);
         let target_scope = sema.scope(impl_item_list.syntax());
-        let ast_transform = QualifyPaths::new(&target_scope, &source_scope, sema.db)
-            .or(SubstituteTypeParams::for_trait_impl(&source_scope, sema.db, trait_, impl_node));
+        let ast_transform = QualifyPaths::new(&target_scope, &source_scope)
+            .or(SubstituteTypeParams::for_trait_impl(&source_scope, trait_, impl_node));
         let items = missing_items
             .into_iter()
             .map(|it| ast_transform::apply(&*ast_transform, it))
diff --git a/crates/ra_assists/src/handlers/fill_match_arms.rs b/crates/ra_assists/src/handlers/fill_match_arms.rs
index e5d8c639d..97cf90ae4 100644
--- a/crates/ra_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ra_assists/src/handlers/fill_match_arms.rs
@@ -2,7 +2,7 @@
 
 use std::iter;
 
-use hir::{db::HirDatabase, Adt, HasSource, Semantics};
+use hir::{Adt, HasSource, Semantics};
 use ra_syntax::ast::{self, edit::IndentLevel, make, AstNode, NameOwner};
 
 use crate::{Assist, AssistCtx, AssistId};
@@ -88,11 +88,7 @@ fn resolve_enum_def(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<
     })
 }
 
-fn build_pat(
-    db: &impl HirDatabase,
-    module: hir::Module,
-    var: hir::EnumVariant,
-) -> Option<ast::Pat> {
+fn build_pat(db: &RootDatabase, module: hir::Module, var: hir::EnumVariant) -> Option<ast::Pat> {
     let path = crate::ast_transform::path_to_ast(module.find_use_path(db, var.into())?);
 
     // FIXME: use HIR for this; it doesn't currently expose struct vs. tuple vs. unit variants though
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index 50a15f978..62fadcddd 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -235,7 +235,7 @@ mod helpers {
             (Some(assist), ExpectedResult::Target(target)) => {
                 let action = assist.0[0].action.clone().unwrap();
                 let range = action.target.expect("expected target on action");
-                assert_eq_text!(&before[range.start().to_usize()..range.end().to_usize()], target);
+                assert_eq_text!(&before[range], target);
             }
             (Some(_), ExpectedResult::NotApplicable) => panic!("assist should not be applicable!"),
             (None, ExpectedResult::After(_)) | (None, ExpectedResult::Target(_)) => {
diff --git a/crates/ra_db/src/fixture.rs b/crates/ra_db/src/fixture.rs
index 3dc86ca2d..3464f43df 100644
--- a/crates/ra_db/src/fixture.rs
+++ b/crates/ra_db/src/fixture.rs
@@ -64,7 +64,9 @@ fn with_single_file(db: &mut dyn SourceDatabaseExt, ra_fixture: &str) -> FileId
         crate_graph.add_crate_root(
             file_id,
             meta.edition,
-            meta.krate,
+            meta.krate.map(|name| {
+                CrateName::new(&name).expect("Fixture crate name should not contain dashes")
+            }),
             meta.cfg,
             meta.env,
             Default::default(),
@@ -124,7 +126,7 @@ fn with_files(db: &mut dyn SourceDatabaseExt, fixture: &str) -> Option<FilePosit
             let crate_id = crate_graph.add_crate_root(
                 file_id,
                 meta.edition,
-                Some(krate.clone()),
+                Some(CrateName::new(&krate).unwrap()),
                 meta.cfg,
                 meta.env,
                 Default::default(),
diff --git a/crates/ra_db/src/input.rs b/crates/ra_db/src/input.rs
index 06d40db96..bde843001 100644
--- a/crates/ra_db/src/input.rs
+++ b/crates/ra_db/src/input.rs
@@ -14,6 +14,7 @@ use rustc_hash::FxHashMap;
 use rustc_hash::FxHashSet;
 
 use crate::{RelativePath, RelativePathBuf};
+use fmt::Display;
 
 /// `FileId` is an integer which uniquely identifies a file. File paths are
 /// messy and system-dependent, so most of the code should work directly with
@@ -83,6 +84,7 @@ pub struct CrateGraph {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct CrateId(pub u32);
 
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct CrateName(SmolStr);
 
 impl CrateName {
@@ -103,6 +105,12 @@ impl CrateName {
     }
 }
 
+impl Display for CrateName {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct CrateData {
     pub root_file_id: FileId,
@@ -110,7 +118,7 @@ pub struct CrateData {
     /// The name to display to the end user.
     /// This actual crate name can be different in a particular dependent crate
     /// or may even be missing for some cases, such as a dummy crate for the code snippet.
-    pub display_name: Option<String>,
+    pub display_name: Option<CrateName>,
     pub cfg_options: CfgOptions,
     pub env: Env,
     pub extern_source: ExternSource,
@@ -150,7 +158,7 @@ impl CrateGraph {
         &mut self,
         file_id: FileId,
         edition: Edition,
-        display_name: Option<String>,
+        display_name: Option<CrateName>,
         cfg_options: CfgOptions,
         env: Env,
         extern_source: ExternSource,
diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml
index 266c4cff3..42193b492 100644
--- a/crates/ra_hir/Cargo.toml
+++ b/crates/ra_hir/Cargo.toml
@@ -11,6 +11,7 @@ doctest = false
 log = "0.4.8"
 rustc-hash = "1.1.0"
 either = "1.5.3"
+arrayvec = "0.5.1"
 
 itertools = "0.8.2"
 
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 41d4e2ed3..ff041150b 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -1,6 +1,7 @@
 //! FIXME: write short doc here
 use std::sync::Arc;
 
+use arrayvec::ArrayVec;
 use either::Either;
 use hir_def::{
     adt::StructKind,
@@ -226,7 +227,9 @@ impl Module {
                     Some((name, def))
                 }
             })
-            .map(|(name, def)| (name.clone(), def.into()))
+            .flat_map(|(name, def)| {
+                ScopeDef::all_items(def).into_iter().map(move |item| (name.clone(), item))
+            })
             .collect()
     }
 
@@ -308,7 +311,11 @@ impl StructField {
         self.parent.variant_data(db).fields()[self.id].name.clone()
     }
 
-    pub fn ty(&self, db: &impl HirDatabase) -> Type {
+    /// Returns the type as in the signature of the struct (i.e., with
+    /// placeholder types for type parameters). This is good for showing
+    /// signature help, but not so good to actually get the type of the field
+    /// when you actually have a variable of the struct.
+    pub fn signature_ty(&self, db: &impl HirDatabase) -> Type {
         let var_id = self.parent.into();
         let generic_def_id: GenericDefId = match self.parent {
             VariantDef::Struct(it) => it.id.into(),
@@ -482,6 +489,10 @@ impl Adt {
         let subst = db.generic_defaults(self.into());
         subst.iter().any(|ty| ty == &Ty::Unknown)
     }
+
+    /// Turns this ADT into a type. Any type parameters of the ADT will be
+    /// turned into unknown types, which is good for e.g. finding the most
+    /// general set of completions, but will not look very nice when printed.
     pub fn ty(self, db: &impl HirDatabase) -> Type {
         let id = AdtId::from(self);
         Type::from_def(db, id.module(db).krate, id)
@@ -1028,7 +1039,7 @@ impl Type {
         krate: CrateId,
         def: impl HasResolver + Into<TyDefId> + Into<GenericDefId>,
     ) -> Type {
-        let substs = Substs::type_params(db, def);
+        let substs = Substs::build_for_def(db, def).fill_with_unknown().build();
         let ty = db.ty(def.into()).subst(&substs);
         Type::new(db, krate, def, ty)
     }
@@ -1288,15 +1299,36 @@ pub enum ScopeDef {
     Unknown,
 }
 
-impl From<PerNs> for ScopeDef {
-    fn from(def: PerNs) -> Self {
-        def.take_types()
-            .or_else(|| def.take_values())
-            .map(|module_def_id| ScopeDef::ModuleDef(module_def_id.into()))
-            .or_else(|| {
-                def.take_macros().map(|macro_def_id| ScopeDef::MacroDef(macro_def_id.into()))
-            })
-            .unwrap_or(ScopeDef::Unknown)
+impl ScopeDef {
+    pub fn all_items(def: PerNs) -> ArrayVec<[Self; 3]> {
+        let mut items = ArrayVec::new();
+
+        match (def.take_types(), def.take_values()) {
+            (Some(m1), None) => items.push(ScopeDef::ModuleDef(m1.into())),
+            (None, Some(m2)) => items.push(ScopeDef::ModuleDef(m2.into())),
+            (Some(m1), Some(m2)) => {
+                // Some items, like unit structs and enum variants, are
+                // returned as both a type and a value. Here we want
+                // to de-duplicate them.
+                if m1 != m2 {
+                    items.push(ScopeDef::ModuleDef(m1.into()));
+                    items.push(ScopeDef::ModuleDef(m2.into()));
+                } else {
+                    items.push(ScopeDef::ModuleDef(m1.into()));
+                }
+            }
+            (None, None) => {}
+        };
+
+        if let Some(macro_def_id) = def.take_macros() {
+            items.push(ScopeDef::MacroDef(macro_def_id.into()));
+        }
+
+        if items.is_empty() {
+            items.push(ScopeDef::Unknown);
+        }
+
+        items
     }
 }
 
diff --git a/crates/ra_hir/src/semantics.rs b/crates/ra_hir/src/semantics.rs
index 3782a9984..788bb3eb7 100644
--- a/crates/ra_hir/src/semantics.rs
+++ b/crates/ra_hir/src/semantics.rs
@@ -344,7 +344,13 @@ impl<'a, DB: HirDatabase> SemanticsScope<'a, DB> {
 
         resolver.process_all_names(self.db, &mut |name, def| {
             let def = match def {
-                resolver::ScopeDef::PerNs(it) => it.into(),
+                resolver::ScopeDef::PerNs(it) => {
+                    let items = ScopeDef::all_items(it);
+                    for item in items {
+                        f(name.clone(), item);
+                    }
+                    return;
+                }
                 resolver::ScopeDef::ImplSelfType(it) => ScopeDef::ImplSelfType(it.into()),
                 resolver::ScopeDef::AdtSelfType(it) => ScopeDef::AdtSelfType(it.into()),
                 resolver::ScopeDef::GenericParam(id) => ScopeDef::GenericParam(TypeParam { id }),
diff --git a/crates/ra_hir_def/src/body.rs b/crates/ra_hir_def/src/body.rs
index 57ba45b45..2bc405a59 100644
--- a/crates/ra_hir_def/src/body.rs
+++ b/crates/ra_hir_def/src/body.rs
@@ -47,13 +47,19 @@ impl Expander {
     pub(crate) fn enter_expand<T: ast::AstNode, DB: DefDatabase>(
         &mut self,
         db: &DB,
+        local_scope: Option<&ItemScope>,
         macro_call: ast::MacroCall,
     ) -> Option<(Mark, T)> {
         let macro_call = InFile::new(self.current_file_id, &macro_call);
 
-        if let Some(call_id) =
-            macro_call.as_call_id(db, |path| self.resolve_path_as_macro(db, &path))
-        {
+        if let Some(call_id) = macro_call.as_call_id(db, |path| {
+            if let Some(local_scope) = local_scope {
+                if let Some(def) = path.as_ident().and_then(|n| local_scope.get_legacy_macro(n)) {
+                    return Some(def);
+                }
+            }
+            self.resolve_path_as_macro(db, &path)
+        }) {
             let file_id = call_id.as_file();
             if let Some(node) = db.parse_or_expand(file_id) {
                 if let Some(expr) = T::cast(node) {
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index ec1b0c2e7..54b5591d3 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -3,7 +3,10 @@
 
 use either::Either;
 
-use hir_expand::name::{name, AsName, Name};
+use hir_expand::{
+    name::{name, AsName, Name},
+    MacroDefId, MacroDefKind,
+};
 use ra_arena::Arena;
 use ra_syntax::{
     ast::{
@@ -452,19 +455,30 @@ where
                     None => self.alloc_expr(Expr::Missing, syntax_ptr),
                 }
             }
-            // FIXME expand to statements in statement position
             ast::Expr::MacroCall(e) => {
-                let macro_call = self.expander.to_source(AstPtr::new(&e));
-                match self.expander.enter_expand(self.db, e) {
-                    Some((mark, expansion)) => {
-                        self.source_map
-                            .expansions
-                            .insert(macro_call, self.expander.current_file_id);
-                        let id = self.collect_expr(expansion);
-                        self.expander.exit(self.db, mark);
-                        id
+                if let Some(name) = is_macro_rules(&e) {
+                    let mac = MacroDefId {
+                        krate: Some(self.expander.module.krate),
+                        ast_id: Some(self.expander.ast_id(&e)),
+                        kind: MacroDefKind::Declarative,
+                    };
+                    self.body.item_scope.define_legacy_macro(name, mac);
+
+                    // FIXME: do we still need to allocate this as missing ?
+                    self.alloc_expr(Expr::Missing, syntax_ptr)
+                } else {
+                    let macro_call = self.expander.to_source(AstPtr::new(&e));
+                    match self.expander.enter_expand(self.db, Some(&self.body.item_scope), e) {
+                        Some((mark, expansion)) => {
+                            self.source_map
+                                .expansions
+                                .insert(macro_call, self.expander.current_file_id);
+                            let id = self.collect_expr(expansion);
+                            self.expander.exit(self.db, mark);
+                            id
+                        }
+                        None => self.alloc_expr(Expr::Missing, syntax_ptr),
                     }
-                    None => self.alloc_expr(Expr::Missing, syntax_ptr),
                 }
             }
 
@@ -686,6 +700,16 @@ where
     }
 }
 
+fn is_macro_rules(m: &ast::MacroCall) -> Option<Name> {
+    let name = m.path()?.segment()?.name_ref()?.as_name();
+
+    if name == name![macro_rules] {
+        Some(m.name()?.as_name())
+    } else {
+        None
+    }
+}
+
 impl From<ast::BinOp> for BinaryOp {
     fn from(ast_op: ast::BinOp) -> Self {
         match ast_op {
diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs
index a72eb5369..c0b16b7fa 100644
--- a/crates/ra_hir_def/src/data.rs
+++ b/crates/ra_hir_def/src/data.rs
@@ -34,7 +34,8 @@ pub struct FunctionData {
 
 impl FunctionData {
     pub(crate) fn fn_data_query(db: &impl DefDatabase, func: FunctionId) -> Arc<FunctionData> {
-        let src = func.lookup(db).source(db);
+        let loc = func.lookup(db);
+        let src = loc.source(db);
         let name = src.value.name().map(|n| n.as_name()).unwrap_or_else(Name::missing);
         let mut params = Vec::new();
         let mut has_self_param = false;
@@ -76,7 +77,9 @@ impl FunctionData {
             ret_type
         };
 
-        let visibility = RawVisibility::from_ast(db, src.map(|s| s.visibility()));
+        let vis_default = RawVisibility::default_for_container(loc.container);
+        let visibility =
+            RawVisibility::from_ast_with_default(db, vis_default, src.map(|s| s.visibility()));
 
         let sig = FunctionData { name, params, ret_type, has_self_param, visibility };
         Arc::new(sig)
@@ -105,10 +108,13 @@ impl TypeAliasData {
         db: &impl DefDatabase,
         typ: TypeAliasId,
     ) -> Arc<TypeAliasData> {
-        let node = typ.lookup(db).source(db);
+        let loc = typ.lookup(db);
+        let node = loc.source(db);
         let name = node.value.name().map_or_else(Name::missing, |n| n.as_name());
         let type_ref = node.value.type_ref().map(TypeRef::from_ast);
-        let visibility = RawVisibility::from_ast(db, node.map(|n| n.visibility()));
+        let vis_default = RawVisibility::default_for_container(loc.container);
+        let visibility =
+            RawVisibility::from_ast_with_default(db, vis_default, node.map(|n| n.visibility()));
         Arc::new(TypeAliasData { name, type_ref, visibility })
     }
 }
@@ -230,22 +236,26 @@ pub struct ConstData {
 
 impl ConstData {
     pub(crate) fn const_data_query(db: &impl DefDatabase, konst: ConstId) -> Arc<ConstData> {
-        let node = konst.lookup(db).source(db);
-        Arc::new(ConstData::new(db, node))
+        let loc = konst.lookup(db);
+        let node = loc.source(db);
+        let vis_default = RawVisibility::default_for_container(loc.container);
+        Arc::new(ConstData::new(db, vis_default, node))
     }
 
     pub(crate) fn static_data_query(db: &impl DefDatabase, konst: StaticId) -> Arc<ConstData> {
         let node = konst.lookup(db).source(db);
-        Arc::new(ConstData::new(db, node))
+        Arc::new(ConstData::new(db, RawVisibility::private(), node))
     }
 
     fn new<N: NameOwner + TypeAscriptionOwner + VisibilityOwner>(
         db: &impl DefDatabase,
+        vis_default: RawVisibility,
         node: InFile<N>,
     ) -> ConstData {
         let name = node.value.name().map(|n| n.as_name());
         let type_ref = TypeRef::from_ast_opt(node.value.ascribed_type());
-        let visibility = RawVisibility::from_ast(db, node.map(|n| n.visibility()));
+        let visibility =
+            RawVisibility::from_ast_with_default(db, vis_default, node.map(|n| n.visibility()));
         ConstData { name, type_ref, visibility }
     }
 }
@@ -280,7 +290,7 @@ fn collect_impl_items_in_macro(
         return Vec::new();
     }
 
-    if let Some((mark, items)) = expander.enter_expand(db, m) {
+    if let Some((mark, items)) = expander.enter_expand(db, None, m) {
         let items: InFile<ast::MacroItems> = expander.to_source(items);
         let mut res = collect_impl_items(
             db,
diff --git a/crates/ra_hir_def/src/nameres.rs b/crates/ra_hir_def/src/nameres.rs
index 81eac52ad..03515309e 100644
--- a/crates/ra_hir_def/src/nameres.rs
+++ b/crates/ra_hir_def/src/nameres.rs
@@ -177,8 +177,13 @@ pub struct ModuleData {
 
 impl CrateDefMap {
     pub(crate) fn crate_def_map_query(db: &impl DefDatabase, krate: CrateId) -> Arc<CrateDefMap> {
-        let _p = profile("crate_def_map_query")
-            .detail(|| db.crate_graph()[krate].display_name.clone().unwrap_or_default());
+        let _p = profile("crate_def_map_query").detail(|| {
+            db.crate_graph()[krate]
+                .display_name
+                .as_ref()
+                .map(ToString::to_string)
+                .unwrap_or_default()
+        });
         let def_map = {
             let edition = db.crate_graph()[krate].edition;
             let mut modules: Arena<LocalModuleId, ModuleData> = Arena::default();
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index d0459d9b0..db9838cb5 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -102,6 +102,7 @@ struct MacroDirective {
     module_id: LocalModuleId,
     ast_id: AstIdWithPath<ast::MacroCall>,
     legacy: Option<MacroCallId>,
+    depth: usize,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -134,6 +135,7 @@ where
         self.def_map.modules[module_id].origin = ModuleOrigin::CrateRoot { definition: file_id };
         ModCollector {
             def_collector: &mut *self,
+            macro_depth: 0,
             module_id,
             file_id: file_id.into(),
             raw_items: &raw_items,
@@ -516,7 +518,7 @@ where
         macros.retain(|directive| {
             if let Some(call_id) = directive.legacy {
                 res = ReachedFixedPoint::No;
-                resolved.push((directive.module_id, call_id));
+                resolved.push((directive.module_id, call_id, directive.depth));
                 return false;
             }
 
@@ -530,7 +532,7 @@ where
                 );
                 resolved_res.resolved_def.take_macros()
             }) {
-                resolved.push((directive.module_id, call_id));
+                resolved.push((directive.module_id, call_id, directive.depth));
                 res = ReachedFixedPoint::No;
                 return false;
             }
@@ -541,7 +543,7 @@ where
             if let Some(call_id) =
                 directive.ast_id.as_call_id(self.db, |path| self.resolve_attribute_macro(&path))
             {
-                resolved.push((directive.module_id, call_id));
+                resolved.push((directive.module_id, call_id, 0));
                 res = ReachedFixedPoint::No;
                 return false;
             }
@@ -552,8 +554,12 @@ where
         self.unexpanded_macros = macros;
         self.unexpanded_attribute_macros = attribute_macros;
 
-        for (module_id, macro_call_id) in resolved {
-            self.collect_macro_expansion(module_id, macro_call_id);
+        for (module_id, macro_call_id, depth) in resolved {
+            if depth > 1024 {
+                log::debug!("Max macro expansion depth reached");
+                continue;
+            }
+            self.collect_macro_expansion(module_id, macro_call_id, depth);
         }
 
         res
@@ -573,12 +579,18 @@ where
         None
     }
 
-    fn collect_macro_expansion(&mut self, module_id: LocalModuleId, macro_call_id: MacroCallId) {
+    fn collect_macro_expansion(
+        &mut self,
+        module_id: LocalModuleId,
+        macro_call_id: MacroCallId,
+        depth: usize,
+    ) {
         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,
+            macro_depth: depth,
             file_id,
             module_id,
             raw_items: &raw_items,
@@ -595,6 +607,7 @@ where
 /// Walks a single module, populating defs, imports and macros
 struct ModCollector<'a, D> {
     def_collector: D,
+    macro_depth: usize,
     module_id: LocalModuleId,
     file_id: HirFileId,
     raw_items: &'a raw::RawItems,
@@ -684,6 +697,7 @@ where
 
                 ModCollector {
                     def_collector: &mut *self.def_collector,
+                    macro_depth: self.macro_depth,
                     module_id,
                     file_id: self.file_id,
                     raw_items: self.raw_items,
@@ -713,6 +727,7 @@ where
                         let raw_items = self.def_collector.db.raw_items(file_id.into());
                         ModCollector {
                             def_collector: &mut *self.def_collector,
+                            macro_depth: self.macro_depth,
                             module_id,
                             file_id: file_id.into(),
                             raw_items: &raw_items,
@@ -887,6 +902,7 @@ where
                 module_id: self.module_id,
                 ast_id,
                 legacy: Some(macro_call_id),
+                depth: self.macro_depth + 1,
             });
 
             return;
@@ -902,6 +918,7 @@ where
             module_id: self.module_id,
             ast_id,
             legacy: None,
+            depth: self.macro_depth + 1,
         });
     }
 
@@ -971,13 +988,26 @@ mod tests {
     }
 
     #[test]
-    fn test_macro_expand_will_stop() {
+    fn test_macro_expand_will_stop_1() {
+        do_resolve(
+            r#"
+        macro_rules! foo {
+            ($($ty:ty)*) => { foo!($($ty)*); }
+        }
+        foo!(KABOOM);
+        "#,
+        );
+    }
+
+    #[ignore] // this test does succeed, but takes quite a while :/
+    #[test]
+    fn test_macro_expand_will_stop_2() {
         do_resolve(
             r#"
         macro_rules! foo {
-            ($($ty:ty)*) => { foo!($($ty)*, $($ty)*); }
+            ($($ty:ty)*) => { foo!($($ty)* $($ty)*); }
         }
-foo!(KABOOM);
+        foo!(KABOOM);
         "#,
         );
     }
diff --git a/crates/ra_hir_def/src/nameres/tests.rs b/crates/ra_hir_def/src/nameres/tests.rs
index dda5ed699..3f33a75b9 100644
--- a/crates/ra_hir_def/src/nameres/tests.rs
+++ b/crates/ra_hir_def/src/nameres/tests.rs
@@ -102,6 +102,28 @@ fn crate_def_map_super_super() {
 }
 
 #[test]
+fn crate_def_map_fn_mod_same_name() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        mod m {
+            pub mod z {}
+            pub fn z() {}
+        }
+        ",
+    );
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮m: t
+        ⋮
+        ⋮crate::m
+        ⋮z: t v
+        ⋮
+        ⋮crate::m::z
+    "###)
+}
+
+#[test]
 fn bogus_paths() {
     covers!(bogus_paths);
     let map = def_map(
diff --git a/crates/ra_hir_def/src/resolver.rs b/crates/ra_hir_def/src/resolver.rs
index 2734d51a0..123fae72a 100644
--- a/crates/ra_hir_def/src/resolver.rs
+++ b/crates/ra_hir_def/src/resolver.rs
@@ -381,6 +381,11 @@ impl Resolver {
         db: &impl DefDatabase,
         path: &ModPath,
     ) -> Option<MacroDefId> {
+        // Search item scope legacy macro first
+        if let Some(def) = self.resolve_local_macro_def(path) {
+            return Some(def);
+        }
+
         let (item_map, module) = self.module_scope()?;
         item_map.resolve_path(db, module, &path, BuiltinShadowMode::Other).0.take_macros()
     }
@@ -413,6 +418,16 @@ impl Resolver {
         })
     }
 
+    fn resolve_local_macro_def(&self, path: &ModPath) -> Option<MacroDefId> {
+        let name = path.as_ident()?;
+        self.scopes.iter().rev().find_map(|scope| {
+            if let Scope::LocalItemsScope(body) = scope {
+                return body.item_scope.get_legacy_macro(name);
+            }
+            None
+        })
+    }
+
     pub fn module(&self) -> Option<ModuleId> {
         let (def_map, local_id) = self.module_scope()?;
         Some(ModuleId { krate: def_map.krate, local_id })
diff --git a/crates/ra_hir_def/src/visibility.rs b/crates/ra_hir_def/src/visibility.rs
index d8296da4b..e0c59e905 100644
--- a/crates/ra_hir_def/src/visibility.rs
+++ b/crates/ra_hir_def/src/visibility.rs
@@ -6,7 +6,7 @@ use ra_syntax::ast;
 use crate::{
     db::DefDatabase,
     path::{ModPath, PathKind},
-    ModuleId,
+    AssocContainerId, ModuleId,
 };
 
 /// Visibility of an item, not yet resolved.
@@ -20,11 +20,30 @@ pub enum RawVisibility {
 }
 
 impl RawVisibility {
-    const fn private() -> RawVisibility {
+    pub(crate) const fn private() -> RawVisibility {
         let path = ModPath { kind: PathKind::Super(0), segments: Vec::new() };
         RawVisibility::Module(path)
     }
 
+    pub(crate) fn default_for_container(container_id: AssocContainerId) -> Self {
+        match container_id {
+            AssocContainerId::TraitId(_) => RawVisibility::Public,
+            _ => RawVisibility::private(),
+        }
+    }
+
+    pub(crate) fn from_ast_with_default(
+        db: &impl DefDatabase,
+        default: RawVisibility,
+        node: InFile<Option<ast::Visibility>>,
+    ) -> RawVisibility {
+        Self::from_ast_with_hygiene_and_default(
+            node.value,
+            default,
+            &Hygiene::new(db, node.file_id),
+        )
+    }
+
     pub(crate) fn from_ast(
         db: &impl DefDatabase,
         node: InFile<Option<ast::Visibility>>,
@@ -36,8 +55,16 @@ impl RawVisibility {
         node: Option<ast::Visibility>,
         hygiene: &Hygiene,
     ) -> RawVisibility {
+        Self::from_ast_with_hygiene_and_default(node, RawVisibility::private(), hygiene)
+    }
+
+    pub(crate) fn from_ast_with_hygiene_and_default(
+        node: Option<ast::Visibility>,
+        default: RawVisibility,
+        hygiene: &Hygiene,
+    ) -> RawVisibility {
         let node = match node {
-            None => return RawVisibility::private(),
+            None => return default,
             Some(node) => node,
         };
         match node.kind() {
diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs
index 3fce73e8a..7b72eb7a0 100644
--- a/crates/ra_hir_expand/src/lib.rs
+++ b/crates/ra_hir_expand/src/lib.rs
@@ -17,7 +17,7 @@ pub mod eager;
 use std::hash::Hash;
 use std::sync::Arc;
 
-use ra_db::{salsa, CrateId, FileId};
+use ra_db::{impl_intern_key, salsa, CrateId, FileId};
 use ra_syntax::{
     algo,
     ast::{self, AstNode},
@@ -174,25 +174,11 @@ pub enum MacroCallId {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct LazyMacroId(salsa::InternId);
-impl salsa::InternKey for LazyMacroId {
-    fn from_intern_id(v: salsa::InternId) -> Self {
-        LazyMacroId(v)
-    }
-    fn as_intern_id(&self) -> salsa::InternId {
-        self.0
-    }
-}
+impl_intern_key!(LazyMacroId);
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct EagerMacroId(salsa::InternId);
-impl salsa::InternKey for EagerMacroId {
-    fn from_intern_id(v: salsa::InternId) -> Self {
-        EagerMacroId(v)
-    }
-    fn as_intern_id(&self) -> salsa::InternId {
-        self.0
-    }
-}
+impl_intern_key!(EagerMacroId);
 
 impl From<LazyMacroId> for MacroCallId {
     fn from(it: LazyMacroId) -> Self {
diff --git a/crates/ra_hir_ty/src/tests/macros.rs b/crates/ra_hir_ty/src/tests/macros.rs
index 32457bbf7..3b7022ad5 100644
--- a/crates/ra_hir_ty/src/tests/macros.rs
+++ b/crates/ra_hir_ty/src/tests/macros.rs
@@ -363,6 +363,26 @@ fn main() {
 }
 
 #[test]
+fn infer_local_macro() {
+    assert_snapshot!(
+        infer(r#"
+fn main() {
+    macro_rules! foo {
+        () => { 1usize }
+    }
+    let _a  = foo!();
+}
+"#),
+        @r###"
+        ![0; 6) '1usize': usize
+        [11; 90) '{     ...!(); }': ()
+        [17; 66) 'macro_...     }': {unknown}
+        [75; 77) '_a': usize
+    "###
+    );
+}
+
+#[test]
 fn infer_builtin_macros_line() {
     assert_snapshot!(
         infer(r#"
diff --git a/crates/ra_ide/src/call_info.rs b/crates/ra_ide/src/call_info.rs
index 2b35a3803..39d09a07f 100644
--- a/crates/ra_ide/src/call_info.rs
+++ b/crates/ra_ide/src/call_info.rs
@@ -544,6 +544,20 @@ fn main() {
     }
 
     #[test]
+    fn generic_struct() {
+        let info = call_info(
+            r#"
+struct TS<T>(T);
+fn main() {
+    let s = TS(<|>);
+}"#,
+        );
+
+        assert_eq!(info.label(), "struct TS<T>(T) -> TS");
+        assert_eq!(info.active_parameter, Some(0));
+    }
+
+    #[test]
     #[should_panic]
     fn cant_call_named_structs() {
         let _ = call_info(
diff --git a/crates/ra_ide/src/completion/complete_dot.rs b/crates/ra_ide/src/completion/complete_dot.rs
index 81e5037aa..f07611d88 100644
--- a/crates/ra_ide/src/completion/complete_dot.rs
+++ b/crates/ra_ide/src/completion/complete_dot.rs
@@ -402,6 +402,38 @@ mod tests {
     }
 
     #[test]
+    fn completes_trait_method_from_other_module() {
+        assert_debug_snapshot!(
+            do_ref_completion(
+                r"
+            struct A {}
+            mod m {
+                pub trait Trait { fn the_method(&self); }
+            }
+            use m::Trait;
+            impl Trait for A {}
+            fn foo(a: A) {
+               a.<|>
+            }
+            ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "the_method()",
+                source_range: [219; 219),
+                delete: [219; 219),
+                insert: "the_method()$0",
+                kind: Method,
+                lookup: "the_method",
+                detail: "fn the_method(&self)",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
     fn test_no_non_self_method() {
         assert_debug_snapshot!(
         do_ref_completion(
diff --git a/crates/ra_ide/src/completion/complete_path.rs b/crates/ra_ide/src/completion/complete_path.rs
index d588ee364..3db17f15f 100644
--- a/crates/ra_ide/src/completion/complete_path.rs
+++ b/crates/ra_ide/src/completion/complete_path.rs
@@ -967,4 +967,74 @@ mod tests {
         ]
         "###);
     }
+
+    #[test]
+    fn function_mod_share_name() {
+        assert_debug_snapshot!(
+        do_reference_completion(
+                r"
+                fn foo() {
+                    self::m::<|>
+                }
+
+                mod m {
+                    pub mod z {}
+                    pub fn z() {}
+                }
+                ",
+        ),
+            @r###"
+        [
+            CompletionItem {
+                label: "z",
+                source_range: [57; 57),
+                delete: [57; 57),
+                insert: "z",
+                kind: Module,
+            },
+            CompletionItem {
+                label: "z()",
+                source_range: [57; 57),
+                delete: [57; 57),
+                insert: "z()$0",
+                kind: Function,
+                lookup: "z",
+                detail: "pub fn z()",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_hashmap_new() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                struct RandomState;
+                struct HashMap<K, V, S = RandomState> {}
+
+                impl<K, V> HashMap<K, V, RandomState> {
+                    pub fn new() -> HashMap<K, V, RandomState> { }
+                }
+                fn foo() {
+                    HashMap::<|>
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "new()",
+                source_range: [292; 292),
+                delete: [292; 292),
+                insert: "new()$0",
+                kind: Function,
+                lookup: "new",
+                detail: "pub fn new() -> HashMap<K, V, RandomState>",
+            },
+        ]
+        "###
+        );
+    }
 }
diff --git a/crates/ra_ide/src/completion/complete_scope.rs b/crates/ra_ide/src/completion/complete_scope.rs
index ed55baa64..5ffff5a1c 100644
--- a/crates/ra_ide/src/completion/complete_scope.rs
+++ b/crates/ra_ide/src/completion/complete_scope.rs
@@ -867,4 +867,38 @@ mod tests {
         "###
         );
     }
+
+    #[test]
+    fn completes_unresolved_uses() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                use spam::Quux;
+
+                fn main() {
+                    <|>
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Quux",
+                source_range: [82; 82),
+                delete: [82; 82),
+                insert: "Quux",
+            },
+            CompletionItem {
+                label: "main()",
+                source_range: [82; 82),
+                delete: [82; 82),
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",
+                detail: "fn main()",
+            },
+        ]
+        "###
+        );
+    }
 }
diff --git a/crates/ra_ide/src/completion/presentation.rs b/crates/ra_ide/src/completion/presentation.rs
index a4e9aefe2..253848602 100644
--- a/crates/ra_ide/src/completion/presentation.rs
+++ b/crates/ra_ide/src/completion/presentation.rs
@@ -1,6 +1,6 @@
 //! This modules takes care of rendering various definitions as completion items.
 
-use hir::{db::HirDatabase, Docs, HasAttrs, HasSource, HirDisplay, ScopeDef, StructKind, Type};
+use hir::{Docs, HasAttrs, HasSource, HirDisplay, ScopeDef, StructKind, Type};
 use join_to_string::join;
 use ra_syntax::ast::NameOwner;
 use test_utils::tested_by;
@@ -9,7 +9,10 @@ use crate::completion::{
     CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions,
 };
 
-use crate::display::{const_label, macro_label, type_label, FunctionSignature};
+use crate::{
+    display::{const_label, macro_label, type_label, FunctionSignature},
+    RootDatabase,
+};
 
 impl Completions {
     pub(crate) fn add_field(
@@ -273,8 +276,10 @@ impl Completions {
     pub(crate) fn add_enum_variant(&mut self, ctx: &CompletionContext, variant: hir::EnumVariant) {
         let is_deprecated = is_deprecated(variant, ctx.db);
         let name = variant.name(ctx.db);
-        let detail_types =
-            variant.fields(ctx.db).into_iter().map(|field| (field.name(ctx.db), field.ty(ctx.db)));
+        let detail_types = variant
+            .fields(ctx.db)
+            .into_iter()
+            .map(|field| (field.name(ctx.db), field.signature_ty(ctx.db)));
         let detail = match variant.kind(ctx.db) {
             StructKind::Tuple | StructKind::Unit => {
                 join(detail_types.map(|(_, t)| t.display(ctx.db).to_string()))
@@ -298,7 +303,7 @@ impl Completions {
     }
 }
 
-fn is_deprecated(node: impl HasAttrs, db: &impl HirDatabase) -> bool {
+fn is_deprecated(node: impl HasAttrs, db: &RootDatabase) -> bool {
     node.attrs(db).by_key("deprecated").exists()
 }
 
diff --git a/crates/ra_ide/src/display.rs b/crates/ra_ide/src/display.rs
index eaeaaa2b4..c395057a7 100644
--- a/crates/ra_ide/src/display.rs
+++ b/crates/ra_ide/src/display.rs
@@ -6,6 +6,8 @@ mod navigation_target;
 mod structure;
 mod short_label;
 
+use std::fmt::{Display, Write};
+
 use ra_syntax::{
     ast::{self, AstNode, AttrsOwner, NameOwner, TypeParamsOwner},
     SyntaxKind::{ATTR, COMMENT},
@@ -67,24 +69,27 @@ pub(crate) fn macro_label(node: &ast::MacroCall) -> String {
     format!("{}macro_rules! {}", vis, name)
 }
 
-pub(crate) fn rust_code_markup<CODE: AsRef<str>>(val: CODE) -> String {
-    rust_code_markup_with_doc::<_, &str>(val, None, None)
+pub(crate) fn rust_code_markup(code: &impl Display) -> String {
+    rust_code_markup_with_doc(code, None, None)
 }
 
-pub(crate) fn rust_code_markup_with_doc<CODE, DOC>(
-    val: CODE,
-    doc: Option<DOC>,
-    mod_path: Option<String>,
-) -> String
-where
-    CODE: AsRef<str>,
-    DOC: AsRef<str>,
-{
-    let mod_path =
-        mod_path.filter(|path| !path.is_empty()).map(|path| path + "\n").unwrap_or_default();
+pub(crate) fn rust_code_markup_with_doc(
+    code: &impl Display,
+    doc: Option<&str>,
+    mod_path: Option<&str>,
+) -> String {
+    let mut markup = "```rust\n".to_owned();
+
+    if let Some(mod_path) = mod_path {
+        if !mod_path.is_empty() {
+            write!(markup, "{}\n", mod_path).unwrap();
+        }
+    }
+    write!(markup, "{}\n```", code).unwrap();
+
     if let Some(doc) = doc {
-        format!("```rust\n{}{}\n```\n\n{}", mod_path, val.as_ref(), doc.as_ref())
-    } else {
-        format!("```rust\n{}{}\n```", mod_path, val.as_ref())
+        write!(markup, "\n\n{}", doc).unwrap();
     }
+
+    markup
 }
diff --git a/crates/ra_ide/src/display/function_signature.rs b/crates/ra_ide/src/display/function_signature.rs
index 2c4c932de..ec1bbd5a0 100644
--- a/crates/ra_ide/src/display/function_signature.rs
+++ b/crates/ra_ide/src/display/function_signature.rs
@@ -64,7 +64,7 @@ impl FunctionSignature {
             .fields(db)
             .into_iter()
             .map(|field: hir::StructField| {
-                let ty = field.ty(db);
+                let ty = field.signature_ty(db);
                 format!("{}", ty.display(db))
             })
             .collect();
@@ -102,7 +102,7 @@ impl FunctionSignature {
             .into_iter()
             .map(|field: hir::StructField| {
                 let name = field.name(db);
-                let ty = field.ty(db);
+                let ty = field.signature_ty(db);
                 format!("{}: {}", name, ty.display(db))
             })
             .collect();
diff --git a/crates/ra_ide/src/goto_definition.rs b/crates/ra_ide/src/goto_definition.rs
index a55a13ffc..a7be92ce3 100644
--- a/crates/ra_ide/src/goto_definition.rs
+++ b/crates/ra_ide/src/goto_definition.rs
@@ -788,6 +788,21 @@ mod tests {
     }
 
     #[test]
+    fn goto_def_in_local_macro() {
+        check_goto(
+            "
+            //- /lib.rs            
+            fn bar() {
+                macro_rules! foo { () => { () } }
+                <|>foo!();
+            }
+            ",
+            "foo MACRO_CALL FileId(1) [15; 48) [28; 31)",
+            "macro_rules! foo { () => { () } }|foo",
+        );
+    }
+
+    #[test]
     fn goto_def_for_field_init_shorthand() {
         covers!(ra_ide_db::goto_def_for_field_init_shorthand);
         check_goto(
diff --git a/crates/ra_ide/src/hover.rs b/crates/ra_ide/src/hover.rs
index 0bbba4855..5b3760c18 100644
--- a/crates/ra_ide/src/hover.rs
+++ b/crates/ra_ide/src/hover.rs
@@ -1,4 +1,5 @@
-//! FIXME: write short doc here
+//! Logic for computing info that is displayed when the user hovers over any
+//! source code items (e.g. function call, struct field, variable symbol...)
 
 use hir::{
     Adt, AsAssocItem, AssocItemContainer, FieldSource, HasSource, HirDisplay, ModuleDef,
@@ -24,35 +25,20 @@ use itertools::Itertools;
 use std::iter::once;
 
 /// Contains the results when hovering over an item
-#[derive(Debug, Clone)]
+#[derive(Debug, Default)]
 pub struct HoverResult {
     results: Vec<String>,
-    exact: bool,
-}
-
-impl Default for HoverResult {
-    fn default() -> Self {
-        HoverResult::new()
-    }
 }
 
 impl HoverResult {
     pub fn new() -> HoverResult {
-        HoverResult {
-            results: Vec::new(),
-            // We assume exact by default
-            exact: true,
-        }
+        Self::default()
     }
 
     pub fn extend(&mut self, item: Option<String>) {
         self.results.extend(item);
     }
 
-    pub fn is_exact(&self) -> bool {
-        self.exact
-    }
-
     pub fn is_empty(&self) -> bool {
         self.results.is_empty()
     }
@@ -72,20 +58,7 @@ impl HoverResult {
     /// Returns the results converted into markup
     /// for displaying in a UI
     pub fn to_markup(&self) -> String {
-        let mut markup = if !self.exact {
-            let mut msg = String::from("Failed to exactly resolve the symbol. This is probably because rust_analyzer does not yet support traits.");
-            if !self.results.is_empty() {
-                msg.push_str("  \nThese items were found instead:");
-            }
-            msg.push_str("\n\n---\n");
-            msg
-        } else {
-            String::new()
-        };
-
-        markup.push_str(&self.results.join("\n\n---\n"));
-
-        markup
+        self.results.join("\n\n---\n")
     }
 }
 
@@ -94,10 +67,10 @@ fn hover_text(
     desc: Option<String>,
     mod_path: Option<String>,
 ) -> Option<String> {
-    match (desc, docs, mod_path) {
-        (Some(desc), docs, mod_path) => Some(rust_code_markup_with_doc(desc, docs, mod_path)),
-        (None, Some(docs), _) => Some(docs),
-        _ => None,
+    if let Some(desc) = desc {
+        Some(rust_code_markup_with_doc(&desc, docs.as_deref(), mod_path.as_deref()))
+    } else {
+        docs
     }
 }
 
@@ -121,7 +94,7 @@ fn definition_owner_name(db: &RootDatabase, def: &Definition) -> Option<String>
 
 fn determine_mod_path(db: &RootDatabase, def: &Definition) -> Option<String> {
     let mod_path = def.module(db).map(|module| {
-        once(db.crate_graph()[module.krate().into()].display_name.clone())
+        once(db.crate_graph()[module.krate().into()].display_name.as_ref().map(ToString::to_string))
             .chain(
                 module
                     .path_to_root(db)
@@ -133,7 +106,7 @@ fn determine_mod_path(db: &RootDatabase, def: &Definition) -> Option<String> {
             .flatten()
             .join("::")
     });
-    mod_path
+    mod_path // FIXME: replace dashes with underscores in crate display name
 }
 
 fn hover_text_from_name_kind(db: &RootDatabase, def: Definition) -> Option<String> {
@@ -170,9 +143,7 @@ fn hover_text_from_name_kind(db: &RootDatabase, def: Definition) -> Option<Strin
             ModuleDef::TypeAlias(it) => from_def_source(db, it, mod_path),
             ModuleDef::BuiltinType(it) => Some(it.to_string()),
         },
-        Definition::Local(it) => {
-            Some(rust_code_markup(it.ty(db).display_truncated(db, None).to_string()))
-        }
+        Definition::Local(it) => Some(rust_code_markup(&it.ty(db).display_truncated(db, None))),
         Definition::TypeParam(_) | Definition::SelfType(_) => {
             // FIXME: Hover for generic param
             None
@@ -237,7 +208,7 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
         }
     }?;
 
-    res.extend(Some(rust_code_markup(ty.display_truncated(db, None).to_string())));
+    res.extend(Some(rust_code_markup(&ty.display_truncated(db, None))));
     let range = sema.original_range(&node).range;
     Some(RangeInfo::new(range, res))
 }
@@ -595,7 +566,6 @@ fn func(foo: i32) { if true { <|>foo; }; }
         );
         let hover = analysis.hover(position).unwrap().unwrap();
         assert_eq!(trim_markup_opt(hover.info.first()), Some("wrapper::Thing\nfn new() -> Thing"));
-        assert_eq!(hover.info.is_exact(), true);
     }
 
     #[test]
@@ -618,7 +588,6 @@ fn func(foo: i32) { if true { <|>foo; }; }
         );
         let hover = analysis.hover(position).unwrap().unwrap();
         assert_eq!(trim_markup_opt(hover.info.first()), Some("const C: u32"));
-        assert_eq!(hover.info.is_exact(), true);
     }
 
     #[test]
@@ -635,7 +604,6 @@ fn func(foo: i32) { if true { <|>foo; }; }
         );
         let hover = analysis.hover(position).unwrap().unwrap();
         assert_eq!(trim_markup_opt(hover.info.first()), Some("Thing"));
-        assert_eq!(hover.info.is_exact(), true);
 
         /* FIXME: revive these tests
                 let (analysis, position) = single_file_with_position(
@@ -651,7 +619,6 @@ fn func(foo: i32) { if true { <|>foo; }; }
 
                 let hover = analysis.hover(position).unwrap().unwrap();
                 assert_eq!(trim_markup_opt(hover.info.first()), Some("Thing"));
-                assert_eq!(hover.info.is_exact(), true);
 
                 let (analysis, position) = single_file_with_position(
                     "
@@ -665,7 +632,6 @@ fn func(foo: i32) { if true { <|>foo; }; }
                 );
                 let hover = analysis.hover(position).unwrap().unwrap();
                 assert_eq!(trim_markup_opt(hover.info.first()), Some("enum Thing"));
-                assert_eq!(hover.info.is_exact(), true);
 
                 let (analysis, position) = single_file_with_position(
                     "
@@ -678,7 +644,6 @@ fn func(foo: i32) { if true { <|>foo; }; }
                 );
                 let hover = analysis.hover(position).unwrap().unwrap();
                 assert_eq!(trim_markup_opt(hover.info.first()), Some("enum Thing"));
-                assert_eq!(hover.info.is_exact(), true);
         */
     }
 
@@ -696,7 +661,6 @@ fn func(foo: i32) { if true { <|>foo; }; }
         );
         let hover = analysis.hover(position).unwrap().unwrap();
         assert_eq!(trim_markup_opt(hover.info.first()), Some("i32"));
-        assert_eq!(hover.info.is_exact(), true);
     }
 
     #[test]
@@ -714,7 +678,6 @@ fn func(foo: i32) { if true { <|>foo; }; }
         );
         let hover = analysis.hover(position).unwrap().unwrap();
         assert_eq!(trim_markup_opt(hover.info.first()), Some("macro_rules! foo"));
-        assert_eq!(hover.info.is_exact(), true);
     }
 
     #[test]
@@ -726,7 +689,6 @@ fn func(foo: i32) { if true { <|>foo; }; }
         );
         let hover = analysis.hover(position).unwrap().unwrap();
         assert_eq!(trim_markup_opt(hover.info.first()), Some("i32"));
-        assert_eq!(hover.info.is_exact(), true);
     }
 
     #[test]
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index e9af80b6c..5ab06c6cf 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -473,9 +473,10 @@ impl Analysis {
     pub fn structural_search_replace(
         &self,
         query: &str,
+        parse_only: bool,
     ) -> Cancelable<Result<SourceChange, SsrError>> {
         self.with_db(|db| {
-            let edits = ssr::parse_search_replace(query, db)?;
+            let edits = ssr::parse_search_replace(query, parse_only, db)?;
             Ok(SourceChange::source_file_edits("ssr", edits))
         })
     }
diff --git a/crates/ra_ide/src/mock_analysis.rs b/crates/ra_ide/src/mock_analysis.rs
index 25816cf6f..2cf77a31f 100644
--- a/crates/ra_ide/src/mock_analysis.rs
+++ b/crates/ra_ide/src/mock_analysis.rs
@@ -109,7 +109,7 @@ impl MockAnalysis {
                 let other_crate = crate_graph.add_crate_root(
                     file_id,
                     Edition2018,
-                    Some(crate_name.to_owned()),
+                    Some(CrateName::new(crate_name).unwrap()),
                     cfg_options,
                     Env::default(),
                     Default::default(),
diff --git a/crates/ra_ide/src/ssr.rs b/crates/ra_ide/src/ssr.rs
index c011a2e74..1c9710a5d 100644
--- a/crates/ra_ide/src/ssr.rs
+++ b/crates/ra_ide/src/ssr.rs
@@ -1,8 +1,10 @@
 //!  structural search replace
 
 use crate::source_change::SourceFileEdit;
+use ra_db::{SourceDatabase, SourceDatabaseExt};
+use ra_ide_db::symbol_index::SymbolsDatabase;
 use ra_ide_db::RootDatabase;
-use ra_syntax::ast::make::expr_from_text;
+use ra_syntax::ast::make::try_expr_from_text;
 use ra_syntax::ast::{AstToken, Comment};
 use ra_syntax::{AstNode, SyntaxElement, SyntaxNode};
 use ra_text_edit::{TextEdit, TextEditBuilder};
@@ -10,9 +12,6 @@ use rustc_hash::FxHashMap;
 use std::collections::HashMap;
 use std::str::FromStr;
 
-pub use ra_db::{SourceDatabase, SourceDatabaseExt};
-use ra_ide_db::symbol_index::SymbolsDatabase;
-
 #[derive(Debug, PartialEq)]
 pub struct SsrError(String);
 
@@ -26,14 +25,17 @@ impl std::error::Error for SsrError {}
 
 pub fn parse_search_replace(
     query: &str,
+    parse_only: bool,
     db: &RootDatabase,
 ) -> Result<Vec<SourceFileEdit>, SsrError> {
     let mut edits = vec![];
     let query: SsrQuery = query.parse()?;
+    if parse_only {
+        return Ok(edits);
+    }
     for &root in db.local_roots().iter() {
         let sr = db.source_root(root);
         for file_id in sr.walk() {
-            dbg!(db.file_relative_path(file_id));
             let matches = find(&query.pattern, db.parse(file_id).tree().syntax());
             if !matches.matches.is_empty() {
                 edits.push(SourceFileEdit { file_id, edit: replace(&matches, &query.template) });
@@ -106,7 +108,10 @@ impl FromStr for SsrQuery {
             template = replace_in_template(template, var, new_var);
         }
 
-        let template = expr_from_text(&template).syntax().clone();
+        let template = try_expr_from_text(&template)
+            .ok_or(SsrError("Template is not an expression".into()))?
+            .syntax()
+            .clone();
         let mut placeholders = FxHashMap::default();
 
         traverse(&template, &mut |n| {
@@ -118,7 +123,13 @@ impl FromStr for SsrQuery {
             }
         });
 
-        let pattern = SsrPattern { pattern: expr_from_text(&pattern).syntax().clone(), vars };
+        let pattern = SsrPattern {
+            pattern: try_expr_from_text(&pattern)
+                .ok_or(SsrError("Pattern is not an expression".into()))?
+                .syntax()
+                .clone(),
+            vars,
+        };
         let template = SsrTemplate { template, placeholders };
         Ok(SsrQuery { pattern, template })
     }
@@ -284,7 +295,6 @@ mod tests {
         assert_eq!(result.pattern.vars[0].0, "__search_pattern_a");
         assert_eq!(result.pattern.vars[1].0, "__search_pattern_b");
         assert_eq!(&result.template.template.text(), "bar(__search_pattern_b, __search_pattern_a)");
-        dbg!(result.template.placeholders);
     }
 
     #[test]
@@ -335,6 +345,16 @@ mod tests {
     }
 
     #[test]
+    fn parser_invlid_pattern() {
+        assert_eq!(parse_error_text(" ==>> ()"), "Parse error: Pattern is not an expression");
+    }
+
+    #[test]
+    fn parser_invlid_template() {
+        assert_eq!(parse_error_text("() ==>> )"), "Parse error: Template is not an expression");
+    }
+
+    #[test]
     fn parse_match_replace() {
         let query: SsrQuery = "foo($x:expr) ==>> bar($x)".parse().unwrap();
         let input = "fn main() { foo(1+2); }";
diff --git a/crates/ra_ide/src/syntax_tree.rs b/crates/ra_ide/src/syntax_tree.rs
index 55966daf3..f58e436d1 100644
--- a/crates/ra_ide/src/syntax_tree.rs
+++ b/crates/ra_ide/src/syntax_tree.rs
@@ -5,7 +5,7 @@ use ra_ide_db::RootDatabase;
 use ra_syntax::{
     algo, AstNode, NodeOrToken, SourceFile,
     SyntaxKind::{RAW_STRING, STRING},
-    SyntaxToken, TextRange,
+    SyntaxToken, TextRange, TextUnit,
 };
 
 pub use ra_db::FileId;
@@ -56,19 +56,23 @@ fn syntax_tree_for_token(node: &SyntaxToken, text_range: TextRange) -> Option<St
     let start = text_range.start() - node_range.start();
 
     // how many characters we have selected
-    let len = text_range.len().to_usize();
+    let len = text_range.len();
 
-    let node_len = node_range.len().to_usize();
+    let node_len = node_range.len();
 
-    let start = start.to_usize();
+    let start = start;
 
     // We want to cap our length
     let len = len.min(node_len);
 
     // Ensure our slice is inside the actual string
-    let end = if start + len < text.len() { start + len } else { text.len() - start };
+    let end = if start + len < TextUnit::of_str(&text) {
+        start + len
+    } else {
+        TextUnit::of_str(&text) - start
+    };
 
-    let text = &text[start..end];
+    let text = &text[TextRange::from_to(start, end)];
 
     // Remove possible extra string quotes from the start
     // and the end of the string
diff --git a/crates/ra_ide/src/typing.rs b/crates/ra_ide/src/typing.rs
index 53c65f8bc..cb2cd2479 100644
--- a/crates/ra_ide/src/typing.rs
+++ b/crates/ra_ide/src/typing.rs
@@ -213,14 +213,14 @@ fn foo() {
         type_char(
             '.',
             r"
-            pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
-                self.child_impl(db, name)
+            fn main() {
+                xs.foo()
                 <|>
             }
             ",
             r"
-            pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
-                self.child_impl(db, name)
+            fn main() {
+                xs.foo()
                     .
             }
             ",
@@ -228,8 +228,8 @@ fn foo() {
         type_char_noop(
             '.',
             r"
-            pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
-                self.child_impl(db, name)
+            fn main() {
+                xs.foo()
                     <|>
             }
             ",
@@ -241,14 +241,14 @@ fn foo() {
         type_char(
             '.',
             r"
-            pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
-                self.child_impl(db, name)
+            fn main() {
+                xs.foo()
                 <|>;
             }
             ",
             r"
-            pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
-                self.child_impl(db, name)
+            fn main() {
+                xs.foo()
                     .;
             }
             ",
@@ -256,8 +256,8 @@ fn foo() {
         type_char_noop(
             '.',
             r"
-            pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
-                self.child_impl(db, name)
+            fn main() {
+                xs.foo()
                     <|>;
             }
             ",
@@ -269,15 +269,15 @@ fn foo() {
         type_char(
             '.',
             r"
-            pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
-                self.child_impl(db, name)
+            fn main() {
+                xs.foo()
                     .first()
                 <|>
             }
             ",
             r"
-            pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
-                self.child_impl(db, name)
+            fn main() {
+                xs.foo()
                     .first()
                     .
             }
@@ -286,8 +286,8 @@ fn foo() {
         type_char_noop(
             '.',
             r"
-            pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
-                self.child_impl(db, name)
+            fn main() {
+                xs.foo()
                     .first()
                     <|>
             }
@@ -334,7 +334,7 @@ fn foo() {
         type_char_noop(
             '.',
             r"
-            pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+            fn main() {
                 <|>
             }
             ",
@@ -342,7 +342,7 @@ fn foo() {
         type_char_noop(
             '.',
             r"
-            pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+            fn main() {
             <|>
             }
             ",
diff --git a/crates/ra_ide_db/src/line_index.rs b/crates/ra_ide_db/src/line_index.rs
index b9db5c276..8ae745ff2 100644
--- a/crates/ra_ide_db/src/line_index.rs
+++ b/crates/ra_ide_db/src/line_index.rs
@@ -59,7 +59,7 @@ impl LineIndex {
             }
 
             let char_len = TextUnit::of_char(c);
-            if char_len.to_usize() > 1 {
+            if char_len > TextUnit::from_usize(1) {
                 utf16_chars.push(Utf16Char { start: curr_col, end: curr_col + char_len });
             }
 
@@ -101,12 +101,12 @@ impl LineIndex {
             .filter(|it| !it.is_empty())
     }
 
-    fn utf8_to_utf16_col(&self, line: u32, mut col: TextUnit) -> usize {
+    fn utf8_to_utf16_col(&self, line: u32, col: TextUnit) -> usize {
         if let Some(utf16_chars) = self.utf16_lines.get(&line) {
-            let mut correction = TextUnit::from_usize(0);
+            let mut correction = 0;
             for c in utf16_chars {
                 if col >= c.end {
-                    correction += c.len() - TextUnit::from_usize(1);
+                    correction += c.len().to_usize() - 1;
                 } else {
                     // From here on, all utf16 characters come *after* the character we are mapping,
                     // so we don't need to take them into account
@@ -114,10 +114,10 @@ impl LineIndex {
                 }
             }
 
-            col -= correction;
+            col.to_usize() - correction
+        } else {
+            col.to_usize()
         }
-
-        col.to_usize()
     }
 
     fn utf16_to_utf8_col(&self, line: u32, col: u32) -> TextUnit {
diff --git a/crates/ra_ide_db/src/line_index_utils.rs b/crates/ra_ide_db/src/line_index_utils.rs
index 75a498151..2ebbabdc6 100644
--- a/crates/ra_ide_db/src/line_index_utils.rs
+++ b/crates/ra_ide_db/src/line_index_utils.rs
@@ -145,7 +145,7 @@ impl Iterator for OffsetStepIter<'_> {
                     Some((next, next_offset))
                 } else {
                     let char_len = TextUnit::of_char(c);
-                    if char_len.to_usize() > 1 {
+                    if char_len > TextUnit::from_usize(1) {
                         let start = self.offset + TextUnit::from_usize(i);
                         let end = start + char_len;
                         let next = Step::Utf16Char(TextRange::from_to(start, end));
diff --git a/crates/ra_parser/src/grammar/params.rs b/crates/ra_parser/src/grammar/params.rs
index 272661b1d..f0da173cc 100644
--- a/crates/ra_parser/src/grammar/params.rs
+++ b/crates/ra_parser/src/grammar/params.rs
@@ -56,21 +56,17 @@ fn list_(p: &mut Parser, flavor: Flavor) {
         // fn f(#[attr1] pat: Type) {}
         attributes::outer_attributes(p);
 
-        // test param_list_vararg
-        // extern "C" { fn printf(format: *const i8, ...) -> i32; }
-        match flavor {
-            FnDef | FnPointer if p.eat(T![...]) => break,
-            _ => (),
-        }
-
         if !p.at_ts(VALUE_PARAMETER_FIRST) {
             p.error("expected value parameter");
             break;
         }
-        value_parameter(p, flavor);
+        let param = value_parameter(p, flavor);
         if !p.at(ket) {
             p.expect(T![,]);
         }
+        if let Variadic(true) = param {
+            break;
+        }
     }
 
     p.expect(ket);
@@ -79,32 +75,25 @@ fn list_(p: &mut Parser, flavor: Flavor) {
 
 const VALUE_PARAMETER_FIRST: TokenSet = patterns::PATTERN_FIRST.union(types::TYPE_FIRST);
 
-fn value_parameter(p: &mut Parser, flavor: Flavor) {
+struct Variadic(bool);
+
+fn value_parameter(p: &mut Parser, flavor: Flavor) -> Variadic {
+    let mut res = Variadic(false);
     let m = p.start();
     match flavor {
-        // test trait_fn_placeholder_parameter
-        // trait Foo {
-        //     fn bar(_: u64, mut x: i32);
-        // }
-
-        // test trait_fn_patterns
-        // trait T {
-        //     fn f1((a, b): (usize, usize)) {}
-        //     fn f2(S { a, b }: S) {}
-        //     fn f3(NewType(a): NewType) {}
-        //     fn f4(&&a: &&usize) {}
-        // }
+        // test param_list_vararg
+        // extern "C" { fn printf(format: *const i8, ...) -> i32; }
+        Flavor::FnDef | Flavor::FnPointer if p.eat(T![...]) => res = Variadic(true),
 
-        // test fn_patterns
-        // impl U {
-        //     fn f1((a, b): (usize, usize)) {}
-        //     fn f2(S { a, b }: S) {}
-        //     fn f3(NewType(a): NewType) {}
-        //     fn f4(&&a: &&usize) {}
-        // }
+        // test fn_def_param
+        // fn foo((x, y): (i32, i32)) {}
         Flavor::FnDef => {
             patterns::pattern(p);
-            types::ascription(p);
+            if variadic_param(p) {
+                res = Variadic(true)
+            } else {
+                types::ascription(p);
+            }
         }
         // test value_parameters_no_patterns
         // type F = Box<Fn(i32, &i32, &i32, ())>;
@@ -120,7 +109,11 @@ fn value_parameter(p: &mut Parser, flavor: Flavor) {
         Flavor::FnPointer => {
             if (p.at(IDENT) || p.at(UNDERSCORE)) && p.nth(1) == T![:] && !p.nth_at(1, T![::]) {
                 patterns::pattern_single(p);
-                types::ascription(p);
+                if variadic_param(p) {
+                    res = Variadic(true)
+                } else {
+                    types::ascription(p);
+                }
             } else {
                 types::type_(p);
             }
@@ -137,6 +130,17 @@ fn value_parameter(p: &mut Parser, flavor: Flavor) {
         }
     }
     m.complete(p, PARAM);
+    res
+}
+
+fn variadic_param(p: &mut Parser) -> bool {
+    if p.at(T![:]) && p.nth_at(1, T![...]) {
+        p.bump(T![:]);
+        p.bump(T![...]);
+        true
+    } else {
+        false
+    }
 }
 
 // test self_param
diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs
index a6274709d..897874813 100644
--- a/crates/ra_project_model/src/lib.rs
+++ b/crates/ra_project_model/src/lib.rs
@@ -245,7 +245,10 @@ impl ProjectWorkspace {
                         let crate_id = crate_graph.add_crate_root(
                             file_id,
                             Edition::Edition2018,
-                            Some(krate.name(&sysroot).to_string()),
+                            Some(
+                                CrateName::new(krate.name(&sysroot))
+                                    .expect("Sysroot crate names should not contain dashes"),
+                            ),
                             cfg_options,
                             env,
                             extern_source,
@@ -296,7 +299,7 @@ impl ProjectWorkspace {
                             let crate_id = crate_graph.add_crate_root(
                                 file_id,
                                 edition,
-                                Some(pkg.name(&cargo).to_string()),
+                                Some(CrateName::normalize_dashes(pkg.name(&cargo))),
                                 cfg_options,
                                 env,
                                 extern_source,
diff --git a/crates/ra_syntax/src/ast/make.rs b/crates/ra_syntax/src/ast/make.rs
index ae8829807..9f6f1cc53 100644
--- a/crates/ra_syntax/src/ast/make.rs
+++ b/crates/ra_syntax/src/ast/make.rs
@@ -112,10 +112,14 @@ pub fn expr_prefix(op: SyntaxKind, expr: ast::Expr) -> ast::Expr {
     let token = token(op);
     expr_from_text(&format!("{}{}", token, expr.syntax()))
 }
-pub fn expr_from_text(text: &str) -> ast::Expr {
+fn expr_from_text(text: &str) -> ast::Expr {
     ast_from_text(&format!("const C: () = {};", text))
 }
 
+pub fn try_expr_from_text(text: &str) -> Option<ast::Expr> {
+    try_ast_from_text(&format!("const C: () = {};", text))
+}
+
 pub fn bind_pat(name: ast::Name) -> ast::BindPat {
     return from_text(name.text());
 
@@ -239,6 +243,16 @@ fn ast_from_text<N: AstNode>(text: &str) -> N {
     node
 }
 
+fn try_ast_from_text<N: AstNode>(text: &str) -> Option<N> {
+    let parse = SourceFile::parse(text);
+    let node = parse.tree().syntax().descendants().find_map(N::cast)?;
+    let node = node.syntax().clone();
+    let node = unroot(node);
+    let node = N::cast(node).unwrap();
+    assert_eq!(node.syntax().text_range().start(), 0.into());
+    Some(node)
+}
+
 fn unroot(n: SyntaxNode) -> SyntaxNode {
     SyntaxNode::new_root(n.green().clone())
 }
diff --git a/crates/ra_syntax/src/parsing/lexer.rs b/crates/ra_syntax/src/parsing/lexer.rs
index f2684c852..d1baaa607 100644
--- a/crates/ra_syntax/src/parsing/lexer.rs
+++ b/crates/ra_syntax/src/parsing/lexer.rs
@@ -65,7 +65,7 @@ pub fn tokenize(text: &str) -> (Vec<Token>, Vec<SyntaxError>) {
 /// Beware that unescape errors are not checked at tokenization time.
 pub fn lex_single_syntax_kind(text: &str) -> Option<(SyntaxKind, Option<SyntaxError>)> {
     lex_first_token(text)
-        .filter(|(token, _)| token.len.to_usize() == text.len())
+        .filter(|(token, _)| token.len == TextUnit::of_str(text))
         .map(|(token, error)| (token.kind, error))
 }
 
@@ -75,7 +75,7 @@ pub fn lex_single_syntax_kind(text: &str) -> Option<(SyntaxKind, Option<SyntaxEr
 /// Beware that unescape errors are not checked at tokenization time.
 pub fn lex_single_valid_syntax_kind(text: &str) -> Option<SyntaxKind> {
     lex_first_token(text)
-        .filter(|(token, error)| !error.is_some() && token.len.to_usize() == text.len())
+        .filter(|(token, error)| !error.is_some() && token.len == TextUnit::of_str(text))
         .map(|(token, _error)| token.kind)
 }
 
diff --git a/crates/ra_syntax/src/tests.rs b/crates/ra_syntax/src/tests.rs
index 912e6aec0..6a8cb6bb5 100644
--- a/crates/ra_syntax/src/tests.rs
+++ b/crates/ra_syntax/src/tests.rs
@@ -5,7 +5,7 @@ use std::{
 
 use test_utils::{collect_tests, dir_tests, project_dir, read_text};
 
-use crate::{fuzz, tokenize, SourceFile, SyntaxError, Token};
+use crate::{fuzz, tokenize, SourceFile, SyntaxError, TextRange, TextUnit, Token};
 
 #[test]
 fn lexer_tests() {
@@ -34,6 +34,7 @@ fn main() {
     "##;
 
     let parse = SourceFile::parse(code);
+    // eprintln!("{:#?}", parse.syntax_node());
     assert!(parse.ok().is_ok());
 }
 
@@ -120,11 +121,11 @@ fn assert_errors_are_absent(errors: &[SyntaxError], path: &Path) {
 
 fn dump_tokens_and_errors(tokens: &[Token], errors: &[SyntaxError], text: &str) -> String {
     let mut acc = String::new();
-    let mut offset = 0;
+    let mut offset = TextUnit::from_usize(0);
     for token in tokens {
-        let token_len = token.len.to_usize();
-        let token_text = &text[offset..offset + token_len];
-        offset += token_len;
+        let token_len = token.len;
+        let token_text = &text[TextRange::offset_len(offset, token.len)];
+        offset += token.len;
         writeln!(acc, "{:?} {} {:?}", token.kind, token_len, token_text).unwrap();
     }
     for err in errors {
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0032_fn_pointer_type.txt b/crates/ra_syntax/test_data/parser/inline/ok/0032_fn_pointer_type.txt
index a0a8aea76..4c17f0db8 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0032_fn_pointer_type.txt
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0032_fn_pointer_type.txt
@@ -81,7 +81,8 @@ SOURCE_FILE@[0; 113)
         WHITESPACE@[97; 98) " "
         COMMA@[98; 99) ","
         WHITESPACE@[99; 100) " "
-        DOTDOTDOT@[100; 103) "..."
+        PARAM@[100; 103)
+          DOTDOTDOT@[100; 103) "..."
         WHITESPACE@[103; 104) " "
         R_PAREN@[104; 105) ")"
       WHITESPACE@[105; 106) " "
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0116_trait_fn_placeholder_parameter.rs b/crates/ra_syntax/test_data/parser/inline/ok/0116_trait_fn_placeholder_parameter.rs
deleted file mode 100644
index 472cb8803..000000000
--- a/crates/ra_syntax/test_data/parser/inline/ok/0116_trait_fn_placeholder_parameter.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-trait Foo {
-    fn bar(_: u64, mut x: i32);
-}
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0116_trait_fn_placeholder_parameter.txt b/crates/ra_syntax/test_data/parser/inline/ok/0116_trait_fn_placeholder_parameter.txt
deleted file mode 100644
index 158236c5a..000000000
--- a/crates/ra_syntax/test_data/parser/inline/ok/0116_trait_fn_placeholder_parameter.txt
+++ /dev/null
@@ -1,47 +0,0 @@
-SOURCE_FILE@[0; 46)
-  TRAIT_DEF@[0; 45)
-    TRAIT_KW@[0; 5) "trait"
-    WHITESPACE@[5; 6) " "
-    NAME@[6; 9)
-      IDENT@[6; 9) "Foo"
-    WHITESPACE@[9; 10) " "
-    ITEM_LIST@[10; 45)
-      L_CURLY@[10; 11) "{"
-      WHITESPACE@[11; 16) "\n    "
-      FN_DEF@[16; 43)
-        FN_KW@[16; 18) "fn"
-        WHITESPACE@[18; 19) " "
-        NAME@[19; 22)
-          IDENT@[19; 22) "bar"
-        PARAM_LIST@[22; 42)
-          L_PAREN@[22; 23) "("
-          PARAM@[23; 29)
-            PLACEHOLDER_PAT@[23; 24)
-              UNDERSCORE@[23; 24) "_"
-            COLON@[24; 25) ":"
-            WHITESPACE@[25; 26) " "
-            PATH_TYPE@[26; 29)
-              PATH@[26; 29)
-                PATH_SEGMENT@[26; 29)
-                  NAME_REF@[26; 29)
-                    IDENT@[26; 29) "u64"
-          COMMA@[29; 30) ","
-          WHITESPACE@[30; 31) " "
-          PARAM@[31; 41)
-            BIND_PAT@[31; 36)
-              MUT_KW@[31; 34) "mut"
-              WHITESPACE@[34; 35) " "
-              NAME@[35; 36)
-                IDENT@[35; 36) "x"
-            COLON@[36; 37) ":"
-            WHITESPACE@[37; 38) " "
-            PATH_TYPE@[38; 41)
-              PATH@[38; 41)
-                PATH_SEGMENT@[38; 41)
-                  NAME_REF@[38; 41)
-                    IDENT@[38; 41) "i32"
-          R_PAREN@[41; 42) ")"
-        SEMI@[42; 43) ";"
-      WHITESPACE@[43; 44) "\n"
-      R_CURLY@[44; 45) "}"
-  WHITESPACE@[45; 46) "\n"
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0123_param_list_vararg.txt b/crates/ra_syntax/test_data/parser/inline/ok/0123_param_list_vararg.txt
index 836e8e55b..6c3b17868 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0123_param_list_vararg.txt
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0123_param_list_vararg.txt
@@ -32,7 +32,8 @@ SOURCE_FILE@[0; 57)
                       IDENT@[38; 40) "i8"
           COMMA@[40; 41) ","
           WHITESPACE@[41; 42) " "
-          DOTDOTDOT@[42; 45) "..."
+          PARAM@[42; 45)
+            DOTDOTDOT@[42; 45) "..."
           R_PAREN@[45; 46) ")"
         WHITESPACE@[46; 47) " "
         RET_TYPE@[47; 53)
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0156_fn_def_param.rs b/crates/ra_syntax/test_data/parser/inline/ok/0156_fn_def_param.rs
new file mode 100644
index 000000000..7b277c16b
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0156_fn_def_param.rs
@@ -0,0 +1 @@
+fn foo((x, y): (i32, i32)) {}
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0156_fn_def_param.txt b/crates/ra_syntax/test_data/parser/inline/ok/0156_fn_def_param.txt
new file mode 100644
index 000000000..103e254a6
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0156_fn_def_param.txt
@@ -0,0 +1,44 @@
+SOURCE_FILE@[0; 30)
+  FN_DEF@[0; 29)
+    FN_KW@[0; 2) "fn"
+    WHITESPACE@[2; 3) " "
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 26)
+      L_PAREN@[6; 7) "("
+      PARAM@[7; 25)
+        TUPLE_PAT@[7; 13)
+          L_PAREN@[7; 8) "("
+          BIND_PAT@[8; 9)
+            NAME@[8; 9)
+              IDENT@[8; 9) "x"
+          COMMA@[9; 10) ","
+          WHITESPACE@[10; 11) " "
+          BIND_PAT@[11; 12)
+            NAME@[11; 12)
+              IDENT@[11; 12) "y"
+          R_PAREN@[12; 13) ")"
+        COLON@[13; 14) ":"
+        WHITESPACE@[14; 15) " "
+        TUPLE_TYPE@[15; 25)
+          L_PAREN@[15; 16) "("
+          PATH_TYPE@[16; 19)
+            PATH@[16; 19)
+              PATH_SEGMENT@[16; 19)
+                NAME_REF@[16; 19)
+                  IDENT@[16; 19) "i32"
+          COMMA@[19; 20) ","
+          WHITESPACE@[20; 21) " "
+          PATH_TYPE@[21; 24)
+            PATH@[21; 24)
+              PATH_SEGMENT@[21; 24)
+                NAME_REF@[21; 24)
+                  IDENT@[21; 24) "i32"
+          R_PAREN@[24; 25) ")"
+      R_PAREN@[25; 26) ")"
+    WHITESPACE@[26; 27) " "
+    BLOCK_EXPR@[27; 29)
+      BLOCK@[27; 29)
+        L_CURLY@[27; 28) "{"
+        R_CURLY@[28; 29) "}"
+  WHITESPACE@[29; 30) "\n"
diff --git a/crates/ra_syntax/test_data/parser/ok/0051_parameter_attrs.txt b/crates/ra_syntax/test_data/parser/ok/0051_parameter_attrs.txt
index 719c99c17..254eafc36 100644
--- a/crates/ra_syntax/test_data/parser/ok/0051_parameter_attrs.txt
+++ b/crates/ra_syntax/test_data/parser/ok/0051_parameter_attrs.txt
@@ -118,7 +118,8 @@ SOURCE_FILE@[0; 519)
                   IDENT@[108; 112) "attr"
             R_BRACK@[112; 113) "]"
           WHITESPACE@[113; 114) " "
-          DOTDOTDOT@[114; 117) "..."
+          PARAM@[114; 117)
+            DOTDOTDOT@[114; 117) "..."
           R_PAREN@[117; 118) ")"
         WHITESPACE@[118; 119) " "
         RET_TYPE@[119; 125)
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0153_trait_fn_patterns.rs b/crates/ra_syntax/test_data/parser/ok/0063_trait_fn_patterns.rs
index a94bf378a..3b666af8e 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0153_trait_fn_patterns.rs
+++ b/crates/ra_syntax/test_data/parser/ok/0063_trait_fn_patterns.rs
@@ -3,4 +3,5 @@ trait T {
     fn f2(S { a, b }: S) {}
     fn f3(NewType(a): NewType) {}
     fn f4(&&a: &&usize) {}
+    fn bar(_: u64, mut x: i32);
 }
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0153_trait_fn_patterns.txt b/crates/ra_syntax/test_data/parser/ok/0063_trait_fn_patterns.txt
index b22df8dbe..eb2e3a503 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0153_trait_fn_patterns.txt
+++ b/crates/ra_syntax/test_data/parser/ok/0063_trait_fn_patterns.txt
@@ -1,11 +1,11 @@
-SOURCE_FILE@[0; 138)
-  TRAIT_DEF@[0; 137)
+SOURCE_FILE@[0; 170)
+  TRAIT_DEF@[0; 169)
     TRAIT_KW@[0; 5) "trait"
     WHITESPACE@[5; 6) " "
     NAME@[6; 7)
       IDENT@[6; 7) "T"
     WHITESPACE@[7; 8) " "
-    ITEM_LIST@[8; 137)
+    ITEM_LIST@[8; 169)
       L_CURLY@[8; 9) "{"
       WHITESPACE@[9; 14) "\n    "
       FN_DEF@[14; 46)
@@ -156,6 +156,41 @@ SOURCE_FILE@[0; 138)
           BLOCK@[133; 135)
             L_CURLY@[133; 134) "{"
             R_CURLY@[134; 135) "}"
-      WHITESPACE@[135; 136) "\n"
-      R_CURLY@[136; 137) "}"
-  WHITESPACE@[137; 138) "\n"
+      WHITESPACE@[135; 140) "\n    "
+      FN_DEF@[140; 167)
+        FN_KW@[140; 142) "fn"
+        WHITESPACE@[142; 143) " "
+        NAME@[143; 146)
+          IDENT@[143; 146) "bar"
+        PARAM_LIST@[146; 166)
+          L_PAREN@[146; 147) "("
+          PARAM@[147; 153)
+            PLACEHOLDER_PAT@[147; 148)
+              UNDERSCORE@[147; 148) "_"
+            COLON@[148; 149) ":"
+            WHITESPACE@[149; 150) " "
+            PATH_TYPE@[150; 153)
+              PATH@[150; 153)
+                PATH_SEGMENT@[150; 153)
+                  NAME_REF@[150; 153)
+                    IDENT@[150; 153) "u64"
+          COMMA@[153; 154) ","
+          WHITESPACE@[154; 155) " "
+          PARAM@[155; 165)
+            BIND_PAT@[155; 160)
+              MUT_KW@[155; 158) "mut"
+              WHITESPACE@[158; 159) " "
+              NAME@[159; 160)
+                IDENT@[159; 160) "x"
+            COLON@[160; 161) ":"
+            WHITESPACE@[161; 162) " "
+            PATH_TYPE@[162; 165)
+              PATH@[162; 165)
+                PATH_SEGMENT@[162; 165)
+                  NAME_REF@[162; 165)
+                    IDENT@[162; 165) "i32"
+          R_PAREN@[165; 166) ")"
+        SEMI@[166; 167) ";"
+      WHITESPACE@[167; 168) "\n"
+      R_CURLY@[168; 169) "}"
+  WHITESPACE@[169; 170) "\n"
diff --git a/crates/ra_syntax/test_data/parser/ok/0063_variadic_fun.rs b/crates/ra_syntax/test_data/parser/ok/0063_variadic_fun.rs
new file mode 100644
index 000000000..a16afbaf3
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/ok/0063_variadic_fun.rs
@@ -0,0 +1,5 @@
+extern "C" {
+    fn a(_: *mut u8, ...,);
+    fn b(_: *mut u8, _: ...);
+    fn c(_: *mut u8, #[cfg(never)] [w, t, f]: ...,);
+}
diff --git a/crates/ra_syntax/test_data/parser/ok/0063_variadic_fun.txt b/crates/ra_syntax/test_data/parser/ok/0063_variadic_fun.txt
new file mode 100644
index 000000000..186f03626
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/ok/0063_variadic_fun.txt
@@ -0,0 +1,133 @@
+SOURCE_FILE@[0; 126)
+  EXTERN_BLOCK@[0; 125)
+    ABI@[0; 10)
+      EXTERN_KW@[0; 6) "extern"
+      WHITESPACE@[6; 7) " "
+      STRING@[7; 10) "\"C\""
+    WHITESPACE@[10; 11) " "
+    EXTERN_ITEM_LIST@[11; 125)
+      L_CURLY@[11; 12) "{"
+      WHITESPACE@[12; 17) "\n    "
+      FN_DEF@[17; 40)
+        FN_KW@[17; 19) "fn"
+        WHITESPACE@[19; 20) " "
+        NAME@[20; 21)
+          IDENT@[20; 21) "a"
+        PARAM_LIST@[21; 39)
+          L_PAREN@[21; 22) "("
+          PARAM@[22; 32)
+            PLACEHOLDER_PAT@[22; 23)
+              UNDERSCORE@[22; 23) "_"
+            COLON@[23; 24) ":"
+            WHITESPACE@[24; 25) " "
+            POINTER_TYPE@[25; 32)
+              STAR@[25; 26) "*"
+              MUT_KW@[26; 29) "mut"
+              WHITESPACE@[29; 30) " "
+              PATH_TYPE@[30; 32)
+                PATH@[30; 32)
+                  PATH_SEGMENT@[30; 32)
+                    NAME_REF@[30; 32)
+                      IDENT@[30; 32) "u8"
+          COMMA@[32; 33) ","
+          WHITESPACE@[33; 34) " "
+          PARAM@[34; 37)
+            DOTDOTDOT@[34; 37) "..."
+          COMMA@[37; 38) ","
+          R_PAREN@[38; 39) ")"
+        SEMI@[39; 40) ";"
+      WHITESPACE@[40; 45) "\n    "
+      FN_DEF@[45; 70)
+        FN_KW@[45; 47) "fn"
+        WHITESPACE@[47; 48) " "
+        NAME@[48; 49)
+          IDENT@[48; 49) "b"
+        PARAM_LIST@[49; 69)
+          L_PAREN@[49; 50) "("
+          PARAM@[50; 60)
+            PLACEHOLDER_PAT@[50; 51)
+              UNDERSCORE@[50; 51) "_"
+            COLON@[51; 52) ":"
+            WHITESPACE@[52; 53) " "
+            POINTER_TYPE@[53; 60)
+              STAR@[53; 54) "*"
+              MUT_KW@[54; 57) "mut"
+              WHITESPACE@[57; 58) " "
+              PATH_TYPE@[58; 60)
+                PATH@[58; 60)
+                  PATH_SEGMENT@[58; 60)
+                    NAME_REF@[58; 60)
+                      IDENT@[58; 60) "u8"
+          COMMA@[60; 61) ","
+          WHITESPACE@[61; 62) " "
+          PARAM@[62; 68)
+            PLACEHOLDER_PAT@[62; 63)
+              UNDERSCORE@[62; 63) "_"
+            COLON@[63; 64) ":"
+            WHITESPACE@[64; 65) " "
+            DOTDOTDOT@[65; 68) "..."
+          R_PAREN@[68; 69) ")"
+        SEMI@[69; 70) ";"
+      WHITESPACE@[70; 75) "\n    "
+      FN_DEF@[75; 123)
+        FN_KW@[75; 77) "fn"
+        WHITESPACE@[77; 78) " "
+        NAME@[78; 79)
+          IDENT@[78; 79) "c"
+        PARAM_LIST@[79; 122)
+          L_PAREN@[79; 80) "("
+          PARAM@[80; 90)
+            PLACEHOLDER_PAT@[80; 81)
+              UNDERSCORE@[80; 81) "_"
+            COLON@[81; 82) ":"
+            WHITESPACE@[82; 83) " "
+            POINTER_TYPE@[83; 90)
+              STAR@[83; 84) "*"
+              MUT_KW@[84; 87) "mut"
+              WHITESPACE@[87; 88) " "
+              PATH_TYPE@[88; 90)
+                PATH@[88; 90)
+                  PATH_SEGMENT@[88; 90)
+                    NAME_REF@[88; 90)
+                      IDENT@[88; 90) "u8"
+          COMMA@[90; 91) ","
+          WHITESPACE@[91; 92) " "
+          ATTR@[92; 105)
+            POUND@[92; 93) "#"
+            L_BRACK@[93; 94) "["
+            PATH@[94; 97)
+              PATH_SEGMENT@[94; 97)
+                NAME_REF@[94; 97)
+                  IDENT@[94; 97) "cfg"
+            TOKEN_TREE@[97; 104)
+              L_PAREN@[97; 98) "("
+              IDENT@[98; 103) "never"
+              R_PAREN@[103; 104) ")"
+            R_BRACK@[104; 105) "]"
+          WHITESPACE@[105; 106) " "
+          PARAM@[106; 120)
+            SLICE_PAT@[106; 115)
+              L_BRACK@[106; 107) "["
+              BIND_PAT@[107; 108)
+                NAME@[107; 108)
+                  IDENT@[107; 108) "w"
+              COMMA@[108; 109) ","
+              WHITESPACE@[109; 110) " "
+              BIND_PAT@[110; 111)
+                NAME@[110; 111)
+                  IDENT@[110; 111) "t"
+              COMMA@[111; 112) ","
+              WHITESPACE@[112; 113) " "
+              BIND_PAT@[113; 114)
+                NAME@[113; 114)
+                  IDENT@[113; 114) "f"
+              R_BRACK@[114; 115) "]"
+            COLON@[115; 116) ":"
+            WHITESPACE@[116; 117) " "
+            DOTDOTDOT@[117; 120) "..."
+          COMMA@[120; 121) ","
+          R_PAREN@[121; 122) ")"
+        SEMI@[122; 123) ";"
+      WHITESPACE@[123; 124) "\n"
+      R_CURLY@[124; 125) "}"
+  WHITESPACE@[125; 126) "\n"
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0152_fn_patterns.rs b/crates/ra_syntax/test_data/parser/ok/0064_impl_fn_params.rs
index b49e872d7..b49e872d7 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0152_fn_patterns.rs
+++ b/crates/ra_syntax/test_data/parser/ok/0064_impl_fn_params.rs
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0152_fn_patterns.txt b/crates/ra_syntax/test_data/parser/ok/0064_impl_fn_params.txt
index b30030de3..b30030de3 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0152_fn_patterns.txt
+++ b/crates/ra_syntax/test_data/parser/ok/0064_impl_fn_params.txt
diff --git a/crates/ra_text_edit/src/text_edit.rs b/crates/ra_text_edit/src/text_edit.rs
index 3291ada42..5c37a08a8 100644
--- a/crates/ra_text_edit/src/text_edit.rs
+++ b/crates/ra_text_edit/src/text_edit.rs
@@ -63,12 +63,12 @@ impl TextEdit {
     }
 
     pub fn apply(&self, text: &str) -> String {
-        let mut total_len = text.len();
+        let mut total_len = TextUnit::of_str(text);
         for atom in self.atoms.iter() {
-            total_len += atom.insert.len();
-            total_len -= (atom.delete.end() - atom.delete.start()).to_usize();
+            total_len += TextUnit::of_str(&atom.insert);
+            total_len -= atom.delete.end() - atom.delete.start();
         }
-        let mut buf = String::with_capacity(total_len);
+        let mut buf = String::with_capacity(total_len.to_usize());
         let mut prev = 0;
         for atom in self.atoms.iter() {
             let start = atom.delete.start().to_usize();
@@ -80,7 +80,7 @@ impl TextEdit {
             prev = end;
         }
         buf.push_str(&text[prev..text.len()]);
-        assert_eq!(buf.len(), total_len);
+        assert_eq!(TextUnit::of_str(&buf), total_len);
         buf
     }
 
diff --git a/crates/rust-analyzer/src/cargo_target_spec.rs b/crates/rust-analyzer/src/cargo_target_spec.rs
index 53751aafb..321861b16 100644
--- a/crates/rust-analyzer/src/cargo_target_spec.rs
+++ b/crates/rust-analyzer/src/cargo_target_spec.rs
@@ -19,50 +19,48 @@ impl CargoTargetSpec {
     pub(crate) fn runnable_args(
         spec: Option<CargoTargetSpec>,
         kind: &RunnableKind,
-    ) -> Result<Vec<String>> {
-        let mut res = Vec::new();
+    ) -> Result<(Vec<String>, Vec<String>)> {
+        let mut args = Vec::new();
+        let mut extra_args = Vec::new();
         match kind {
             RunnableKind::Test { test_id } => {
-                res.push("test".to_string());
+                args.push("test".to_string());
                 if let Some(spec) = spec {
-                    spec.push_to(&mut res);
+                    spec.push_to(&mut args);
                 }
-                res.push("--".to_string());
-                res.push(test_id.to_string());
+                extra_args.push(test_id.to_string());
                 if let TestId::Path(_) = test_id {
-                    res.push("--exact".to_string());
+                    extra_args.push("--exact".to_string());
                 }
-                res.push("--nocapture".to_string());
+                extra_args.push("--nocapture".to_string());
             }
             RunnableKind::TestMod { path } => {
-                res.push("test".to_string());
+                args.push("test".to_string());
                 if let Some(spec) = spec {
-                    spec.push_to(&mut res);
+                    spec.push_to(&mut args);
                 }
-                res.push("--".to_string());
-                res.push(path.to_string());
-                res.push("--nocapture".to_string());
+                extra_args.push(path.to_string());
+                extra_args.push("--nocapture".to_string());
             }
             RunnableKind::Bench { test_id } => {
-                res.push("bench".to_string());
+                args.push("bench".to_string());
                 if let Some(spec) = spec {
-                    spec.push_to(&mut res);
+                    spec.push_to(&mut args);
                 }
-                res.push("--".to_string());
-                res.push(test_id.to_string());
+                extra_args.push(test_id.to_string());
                 if let TestId::Path(_) = test_id {
-                    res.push("--exact".to_string());
+                    extra_args.push("--exact".to_string());
                 }
-                res.push("--nocapture".to_string());
+                extra_args.push("--nocapture".to_string());
             }
             RunnableKind::Bin => {
-                res.push("run".to_string());
+                args.push("run".to_string());
                 if let Some(spec) = spec {
-                    spec.push_to(&mut res);
+                    spec.push_to(&mut args);
                 }
             }
         }
-        Ok(res)
+        Ok((args, extra_args))
     }
 
     pub(crate) fn for_file(
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 084e17b04..6b9a11a87 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -55,6 +55,9 @@ pub struct ServerConfig {
 
     /// Cargo feature configurations.
     pub cargo_features: CargoFeatures,
+
+    /// Enabled if the vscode_lldb extension is available.
+    pub vscode_lldb: bool,
 }
 
 impl Default for ServerConfig {
@@ -76,6 +79,7 @@ impl Default for ServerConfig {
             additional_out_dirs: FxHashMap::default(),
             cargo_features: Default::default(),
             rustfmt_args: Vec::new(),
+            vscode_lldb: false,
         }
     }
 }
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index b410d3927..1fefc66aa 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -192,6 +192,7 @@ pub fn main_loop(
                     all_targets: config.cargo_watch_all_targets,
                 },
                 rustfmt_args: config.rustfmt_args,
+                vscode_lldb: config.vscode_lldb,
             }
         };
 
diff --git a/crates/rust-analyzer/src/main_loop/handlers.rs b/crates/rust-analyzer/src/main_loop/handlers.rs
index 6482f3b77..1cc2f6571 100644
--- a/crates/rust-analyzer/src/main_loop/handlers.rs
+++ b/crates/rust-analyzer/src/main_loop/handlers.rs
@@ -381,6 +381,7 @@ pub fn handle_runnables(
         label,
         bin: "cargo".to_string(),
         args: check_args,
+        extra_args: Vec::new(),
         env: FxHashMap::default(),
         cwd: workspace_root.map(|root| root.to_string_lossy().to_string()),
     });
@@ -794,18 +795,35 @@ pub fn handle_code_lens(
             RunnableKind::Bin => "Run",
         }
         .to_string();
-        let r = to_lsp_runnable(&world, file_id, runnable)?;
+        let mut r = to_lsp_runnable(&world, file_id, runnable)?;
         let lens = CodeLens {
             range: r.range,
             command: Some(Command {
                 title,
                 command: "rust-analyzer.runSingle".into(),
-                arguments: Some(vec![to_value(r).unwrap()]),
+                arguments: Some(vec![to_value(&r).unwrap()]),
             }),
             data: None,
         };
-
         lenses.push(lens);
+
+        if world.options.vscode_lldb {
+            if r.args[0] == "run" {
+                r.args[0] = "build".into();
+            } else {
+                r.args.push("--no-run".into());
+            }
+            let debug_lens = CodeLens {
+                range: r.range,
+                command: Some(Command {
+                    title: "Debug".into(),
+                    command: "rust-analyzer.debugSingle".into(),
+                    arguments: Some(vec![to_value(r).unwrap()]),
+                }),
+                data: None,
+            };
+            lenses.push(debug_lens);
+        }
     }
 
     // Handle impls
@@ -914,7 +932,10 @@ pub fn handle_document_highlight(
 
 pub fn handle_ssr(world: WorldSnapshot, params: req::SsrParams) -> Result<req::SourceChange> {
     let _p = profile("handle_ssr");
-    world.analysis().structural_search_replace(&params.arg)??.try_conv_with(&world)
+    world
+        .analysis()
+        .structural_search_replace(&params.query, params.parse_only)??
+        .try_conv_with(&world)
 }
 
 pub fn publish_diagnostics(world: &WorldSnapshot, file_id: FileId) -> Result<DiagnosticTask> {
@@ -952,7 +973,7 @@ fn to_lsp_runnable(
     runnable: Runnable,
 ) -> Result<req::Runnable> {
     let spec = CargoTargetSpec::for_file(world, file_id)?;
-    let args = CargoTargetSpec::runnable_args(spec, &runnable.kind)?;
+    let (args, extra_args) = CargoTargetSpec::runnable_args(spec, &runnable.kind)?;
     let line_index = world.analysis().file_line_index(file_id)?;
     let label = match &runnable.kind {
         RunnableKind::Test { test_id } => format!("test {}", test_id),
@@ -965,6 +986,7 @@ fn to_lsp_runnable(
         label,
         bin: "cargo".to_string(),
         args,
+        extra_args,
         env: {
             let mut m = FxHashMap::default();
             m.insert("RUST_BACKTRACE".to_string(), "short".to_string());
@@ -973,6 +995,7 @@ fn to_lsp_runnable(
         cwd: world.workspace_root_for(file_id).map(|root| root.to_string_lossy().to_string()),
     })
 }
+
 fn highlight(world: &WorldSnapshot, file_id: FileId) -> Result<Vec<Decoration>> {
     let line_index = world.analysis().file_line_index(file_id)?;
     let res = world
diff --git a/crates/rust-analyzer/src/req.rs b/crates/rust-analyzer/src/req.rs
index a3efe3b9f..9e27d3f1c 100644
--- a/crates/rust-analyzer/src/req.rs
+++ b/crates/rust-analyzer/src/req.rs
@@ -169,6 +169,7 @@ pub struct Runnable {
     pub label: String,
     pub bin: String,
     pub args: Vec<String>,
+    pub extra_args: Vec<String>,
     pub env: FxHashMap<String, String>,
     pub cwd: Option<String>,
 }
@@ -217,6 +218,8 @@ impl Request for Ssr {
 }
 
 #[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
 pub struct SsrParams {
-    pub arg: String,
+    pub query: String,
+    pub parse_only: bool,
 }
diff --git a/crates/rust-analyzer/src/world.rs b/crates/rust-analyzer/src/world.rs
index 058ce2af8..5743471bf 100644
--- a/crates/rust-analyzer/src/world.rs
+++ b/crates/rust-analyzer/src/world.rs
@@ -38,6 +38,7 @@ pub struct Options {
     pub inlay_hints: InlayHintsOptions,
     pub rustfmt_args: Vec<String>,
     pub cargo_watch: CheckOptions,
+    pub vscode_lldb: bool,
 }
 
 /// `WorldState` is the primary mutable state of the language server
diff --git a/crates/rust-analyzer/tests/heavy_tests/main.rs b/crates/rust-analyzer/tests/heavy_tests/main.rs
index 970185dec..145429571 100644
--- a/crates/rust-analyzer/tests/heavy_tests/main.rs
+++ b/crates/rust-analyzer/tests/heavy_tests/main.rs
@@ -75,7 +75,8 @@ fn foo() {
         RunnablesParams { text_document: server.doc_id("lib.rs"), position: None },
         json!([
           {
-            "args": [ "test", "--", "foo", "--nocapture" ],
+            "args": [ "test" ],
+            "extraArgs": [ "foo", "--nocapture" ],
             "bin": "cargo",
             "env": { "RUST_BACKTRACE": "short" },
             "cwd": null,
@@ -90,6 +91,7 @@ fn foo() {
               "check",
               "--all"
             ],
+            "extraArgs": [],
             "bin": "cargo",
             "env": {},
             "cwd": null,
@@ -141,13 +143,11 @@ fn main() {}
 
     server.wait_until_workspace_is_loaded();
     server.request::<Runnables>(
-        RunnablesParams {
-            text_document: server.doc_id("foo/tests/spam.rs"),
-            position: None,
-        },
+        RunnablesParams { text_document: server.doc_id("foo/tests/spam.rs"), position: None },
         json!([
           {
-            "args": [ "test", "--package", "foo", "--test", "spam", "--", "test_eggs", "--exact", "--nocapture" ],
+            "args": [ "test", "--package", "foo", "--test", "spam" ],
+            "extraArgs": [ "test_eggs", "--exact", "--nocapture" ],
             "bin": "cargo",
             "env": { "RUST_BACKTRACE": "short" },
             "label": "test test_eggs",
@@ -165,6 +165,7 @@ fn main() {}
               "--test",
               "spam"
             ],
+            "extraArgs": [],
             "bin": "cargo",
             "env": {},
             "cwd": server.path().join("foo"),
@@ -180,7 +181,7 @@ fn main() {}
               }
             }
           }
-        ])
+        ]),
     );
 }
 
diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index a0d8f4d37..db03df1c4 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -397,6 +397,8 @@ pub fn skip_slow_tests() -> bool {
     should_skip
 }
 
+const REWRITE: bool = false;
+
 /// Asserts that `expected` and `actual` strings are equal. If they differ only
 /// in trailing or leading whitespace the test won't fail and
 /// the contents of `actual` will be written to the file located at `path`.
@@ -412,7 +414,6 @@ fn assert_equal_text(expected: &str, actual: &str, path: &Path) {
         fs::write(path, actual).unwrap();
         return;
     }
-    const REWRITE: bool = false;
     if REWRITE {
         println!("rewriting {}", pretty_path.display());
         fs::write(path, actual).unwrap();