56 files changed, 932 insertions, 329 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)
+        let ast_transform = QualifyPaths::new(&target_scope, &source_scope)
-            .or(SubstituteTypeParams::for_trait_impl(&source_scope, sema.db, trait_, impl_node));
+            .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(
+fn build_pat(db: &RootDatabase, module: hir::Module, var: hir::EnumVariant) -> Option<ast::Pat> {
-    db: &impl HirDatabase,
-    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_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 {
+impl ScopeDef {
-    fn from(def: PerNs) -> Self {
+    pub fn all_items(def: PerNs) -> ArrayVec<[Self; 3]> {
-        def.take_types()
+        let mut items = ArrayVec::new();
-            .or_else(|| def.take_values())
-            .map(|module_def_id| ScopeDef::ModuleDef(module_def_id.into()))
+        match (def.take_types(), def.take_values()) {
-            .or_else(|| {
+            (Some(m1), None) => items.push(ScopeDef::ModuleDef(m1.into())),
-                def.take_macros().map(|macro_def_id| ScopeDef::MacroDef(macro_def_id.into()))
+            (None, Some(m2)) => items.push(ScopeDef::ModuleDef(m2.into())),
-            })
+            (Some(m1), Some(m2)) => {
-            .unwrap_or(ScopeDef::Unknown)
+                // 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) =
+        if let Some(call_id) = macro_call.as_call_id(db, |path| {
-            macro_call.as_call_id(db, |path| self.resolve_path_as_macro(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));
+                if let Some(name) = is_macro_rules(&e) {
-                match self.expander.enter_expand(self.db, e) {
+                    let mac = MacroDefId {
-                    Some((mark, expansion)) => {
+                        krate: Some(self.expander.module.krate),
-                        self.source_map
+                        ast_id: Some(self.expander.ast_id(&e)),
-                            .expansions
+                        kind: MacroDefKind::Declarative,
-                            .insert(macro_call, self.expander.current_file_id);
+                    };
-                        let id = self.collect_expr(expansion);
+                    self.body.item_scope.define_legacy_macro(name, mac);
-                        self.expander.exit(self.db, mark);
-                        id
+                    // 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);
+        let loc = konst.lookup(db);
-        Arc::new(ConstData::new(db, node))
+        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")
+        let _p = profile("crate_def_map_query").detail(|| {
-            .detail(|| db.crate_graph()[krate].display_name.clone().unwrap_or_default());
+            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 {
+        for (module_id, macro_call_id, depth) in resolved {
-            self.collect_macro_expansion(module_id, macro_call_id);
+            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 {
+impl_intern_key!(LazyMacroId);
-    fn from_intern_id(v: salsa::InternId) -> Self {
-        LazyMacroId(v)
-    }
-    fn as_intern_id(&self) -> salsa::InternId {
-        self.0
-    }
-}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct EagerMacroId(salsa::InternId);
-impl salsa::InternKey for EagerMacroId {
+impl_intern_key!(EagerMacroId);
-    fn from_intern_id(v: salsa::InternId) -> Self {
-        EagerMacroId(v)
-    }
-    fn as_intern_id(&self) -> salsa::InternId {
-        self.0
-    }
-}
 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/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 =
+        let detail_types = variant
-            variant.fields(ctx.db).into_iter().map(|field| (field.name(ctx.db), field.ty(ctx.db)));
+            .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 {
+pub(crate) fn rust_code_markup(code: &impl Display) -> String {
-    rust_code_markup_with_doc::<_, &str>(val, None, None)
+    rust_code_markup_with_doc(code, None, None)
 }
-pub(crate) fn rust_code_markup_with_doc<CODE, DOC>(
+pub(crate) fn rust_code_markup_with_doc(
-    val: CODE,
+    code: &impl Display,
-    doc: Option<DOC>,
+    doc: Option<&str>,
-    mod_path: Option<String>,
+    mod_path: Option<&str>,
-) -> String
+) -> String {
-where
+    let mut markup = "```rust\n".to_owned();
-    CODE: AsRef<str>,
-    DOC: AsRef<str>,
+    if let Some(mod_path) = mod_path {
-{
+        if !mod_path.is_empty() {
-    let mod_path =
+            write!(markup, "{}\n", mod_path).unwrap();
-        mod_path.filter(|path| !path.is_empty()).map(|path| path + "\n").unwrap_or_default();
+        }
+    }
+    write!(markup, "{}\n```", code).unwrap();
    if let Some(doc) = doc {
-        format!("```rust\n{}{}\n```\n\n{}", mod_path, val.as_ref(), doc.as_ref())
+        write!(markup, "\n\n{}", doc).unwrap();
-    } else {
-        format!("```rust\n{}{}\n```", mod_path, val.as_ref())
    }
+    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 {
+        Self::default()
-            results: Vec::new(),
-            // We assume exact by default
-            exact: true,
-        }
    }
    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 {
+        self.results.join("\n\n---\n")
-            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
    }
 }
@@ -94,10 +67,10 @@ fn hover_text(
    desc: Option<String>,
    mod_path: Option<String>,
 ) -> Option<String> {
-    match (desc, docs, mod_path) {
+    if let Some(desc) = desc {
-        (Some(desc), docs, mod_path) => Some(rust_code_markup_with_doc(desc, docs, mod_path)),
+        Some(rust_code_markup_with_doc(&desc, docs.as_deref(), mod_path.as_deref()))
-        (None, Some(docs), _) => Some(docs),
+    } else {
-        _ => None,
+        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) => {
+        Definition::Local(it) => Some(rust_code_markup(&it.ty(db).display_truncated(db, None))),
-            Some(rust_code_markup(it.ty(db).display_truncated(db, None).to_string()))
-        }
        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/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>> {
+            fn main() {
-                self.child_impl(db, name)
+                xs.foo()
                <|>
            }
            ",
            r"
-            pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+            fn main() {
-                self.child_impl(db, name)
+                xs.foo()
                    .
            }
            ",
@@ -228,8 +228,8 @@ fn foo() {
        type_char_noop(
            '.',
            r"
-            pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+            fn main() {
-                self.child_impl(db, name)
+                xs.foo()
                    <|>
            }
            ",
@@ -241,14 +241,14 @@ fn foo() {
        type_char(
            '.',
            r"
-            pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+            fn main() {
-                self.child_impl(db, name)
+                xs.foo()
                <|>;
            }
            ",
            r"
-            pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+            fn main() {
-                self.child_impl(db, name)
+                xs.foo()
                    .;
            }
            ",
@@ -256,8 +256,8 @@ fn foo() {
        type_char_noop(
            '.',
            r"
-            pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+            fn main() {
-                self.child_impl(db, name)
+                xs.foo()
                    <|>;
            }
            ",
@@ -269,15 +269,15 @@ fn foo() {
        type_char(
            '.',
            r"
-            pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+            fn main() {
-                self.child_impl(db, name)
+                xs.foo()
                    .first()
                <|>
            }
            ",
            r"
-            pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+            fn main() {
-                self.child_impl(db, name)
+                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>> {
+            fn main() {
-                self.child_impl(db, name)
+                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_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
+        // test param_list_vararg
-        // trait Foo {
+        // extern "C" { fn printf(format: *const i8, ...) -> i32; }
-        //     fn bar(_: u64, mut x: i32);
+        Flavor::FnDef | Flavor::FnPointer if p.eat(T![...]) => res = Variadic(true),
-        // }
-        // 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 fn_patterns
+        // test fn_def_param
-        // impl U {
+        // fn foo((x, y): (i32, i32)) {}
-        //     fn f1((a, b): (usize, usize)) {}
-        //     fn f2(S { a, b }: S) {}
-        //     fn f3(NewType(a): NewType) {}
-        //     fn f4(&&a: &&usize) {}
-        // }
        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/tests.rs b/crates/ra_syntax/src/tests.rs
index d331d541e..6a8cb6bb5 100644
--- a/crates/ra_syntax/src/tests.rs
+++ b/crates/ra_syntax/src/tests.rs
@@ -34,6 +34,7 @@ fn main() {
    "##;
    let parse = SourceFile::parse(code);
+    // eprintln!("{:#?}", parse.syntax_node());
    assert!(parse.ok().is_ok());
 }
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)
+SOURCE_FILE@[0; 170)
-  TRAIT_DEF@[0; 137)
+  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"
+      WHITESPACE@[135; 140) "\n    "
-      R_CURLY@[136; 137) "}"
+      FN_DEF@[140; 167)
-  WHITESPACE@[137; 138) "\n"
+        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/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>> {
+    ) -> Result<(Vec<String>, Vec<String>)> {
-        let mut res = Vec::new();
+        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());
+                extra_args.push(test_id.to_string());
-                res.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());
+                extra_args.push(path.to_string());
-                res.push(path.to_string());
+                extra_args.push("--nocapture".to_string());
-                res.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());
+                extra_args.push(test_id.to_string());
-                res.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 2b3b16d35..1fefc66aa 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -16,7 +16,10 @@ use std::{
 use crossbeam_channel::{select, unbounded, RecvError, Sender};
 use lsp_server::{Connection, ErrorCode, Message, Notification, Request, RequestId, Response};
-use lsp_types::{ClientCapabilities, NumberOrString};
+use lsp_types::{
+    ClientCapabilities, NumberOrString, WorkDoneProgress, WorkDoneProgressBegin,
+    WorkDoneProgressCreateParams, WorkDoneProgressEnd, WorkDoneProgressReport,
+};
 use ra_cargo_watch::{url_from_path_with_drive_lowercasing, CheckOptions, CheckTask};
 use ra_ide::{Canceled, FileId, InlayHintsOptions, LibraryData, SourceRootId};
 use ra_prof::profile;
@@ -189,6 +192,7 @@ pub fn main_loop(
                    all_targets: config.cargo_watch_all_targets,
                },
                rustfmt_args: config.rustfmt_args,
+                vscode_lldb: config.vscode_lldb,
            }
        };
@@ -329,6 +333,7 @@ struct LoopState {
    in_flight_libraries: usize,
    pending_libraries: Vec<(SourceRootId, Vec<(FileId, RelativePathBuf, Arc<String>)>)>,
    workspace_loaded: bool,
+    roots_scanned_progress: Option<usize>,
 }
 impl LoopState {
@@ -428,17 +433,15 @@ fn loop_turn(
        && loop_state.in_flight_libraries == 0
    {
        loop_state.workspace_loaded = true;
-        let n_packages: usize = world_state.workspaces.iter().map(|it| it.n_packages()).sum();
-        if world_state.feature_flags.get("notifications.workspace-loaded") {
-            let msg = format!("workspace loaded, {} rust packages", n_packages);
-            show_message(req::MessageType::Info, msg, &connection.sender);
-        }
        world_state.check_watcher.update();
        pool.execute({
            let subs = loop_state.subscriptions.subscriptions();
            let snap = world_state.snapshot();
            move || snap.analysis().prime_caches(subs).unwrap_or_else(|_: Canceled| ())
        });
+        send_startup_progress(&connection.sender, loop_state, world_state);
+    } else if !loop_state.workspace_loaded {
+        send_startup_progress(&connection.sender, loop_state, world_state);
    }
    if state_changed {
@@ -703,6 +706,65 @@ fn on_diagnostic_task(task: DiagnosticTask, msg_sender: &Sender<Message>, state:
    }
 }
+fn send_startup_progress(
+    sender: &Sender<Message>,
+    loop_state: &mut LoopState,
+    world_state: &WorldState,
+) {
+    if !world_state.feature_flags.get("notifications.workspace-loaded") {
+        return;
+    }
+    let total: usize = world_state.workspaces.iter().map(|it| it.n_packages()).sum();
+    let prev_progress = loop_state.roots_scanned_progress;
+    let progress = total - world_state.roots_to_scan;
+    loop_state.roots_scanned_progress = Some(progress);
+    match (prev_progress, loop_state.workspace_loaded) {
+        (None, false) => {
+            let work_done_progress_create = request_new::<req::WorkDoneProgressCreate>(
+                loop_state.next_request_id(),
+                WorkDoneProgressCreateParams {
+                    token: req::ProgressToken::String("rustAnalyzer/startup".into()),
+                },
+            );
+            sender.send(work_done_progress_create.into()).unwrap();
+            send_startup_progress_notif(
+                sender,
+                WorkDoneProgress::Begin(WorkDoneProgressBegin {
+                    title: "rust-analyzer".into(),
+                    cancellable: None,
+                    message: Some(format!("{}/{} packages", progress, total)),
+                    percentage: Some(100.0 * progress as f64 / total as f64),
+                }),
+            );
+        }
+        (Some(prev), false) if progress != prev => send_startup_progress_notif(
+            sender,
+            WorkDoneProgress::Report(WorkDoneProgressReport {
+                cancellable: None,
+                message: Some(format!("{}/{} packages", progress, total)),
+                percentage: Some(100.0 * progress as f64 / total as f64),
+            }),
+        ),
+        (_, true) => send_startup_progress_notif(
+            sender,
+            WorkDoneProgress::End(WorkDoneProgressEnd {
+                message: Some(format!("rust-analyzer loaded, {} packages", progress)),
+            }),
+        ),
+        _ => {}
+    }
+}
+fn send_startup_progress_notif(sender: &Sender<Message>, work_done_progress: WorkDoneProgress) {
+    let notif = notification_new::<req::Progress>(req::ProgressParams {
+        token: req::ProgressToken::String("rustAnalyzer/startup".into()),
+        value: req::ProgressParamsValue::WorkDone(work_done_progress),
+    });
+    sender.send(notif.into()).unwrap();
+}
 struct PoolDispatcher<'a> {
    req: Option<Request>,
    pool: &'a ThreadPool,
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 {
+        RunnablesParams { text_document: server.doc_id("foo/tests/spam.rs"), position: None },
-            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/rust-analyzer/tests/heavy_tests/support.rs b/crates/rust-analyzer/tests/heavy_tests/support.rs
index e28ae61fe..1d7062bdf 100644
--- a/crates/rust-analyzer/tests/heavy_tests/support.rs
+++ b/crates/rust-analyzer/tests/heavy_tests/support.rs
@@ -12,13 +12,14 @@ use lsp_types::{
    notification::{DidOpenTextDocument, Exit},
    request::Shutdown,
    ClientCapabilities, DidOpenTextDocumentParams, GotoCapability, TextDocumentClientCapabilities,
-    TextDocumentIdentifier, TextDocumentItem, Url,
+    TextDocumentIdentifier, TextDocumentItem, Url, WorkDoneProgress,
 };
 use serde::Serialize;
 use serde_json::{to_string_pretty, Value};
 use tempfile::TempDir;
 use test_utils::{find_mismatch, parse_fixture};
+use req::{ProgressParams, ProgressParamsValue};
 use rust_analyzer::{main_loop, req, ServerConfig};
 pub struct Project<'a> {
@@ -201,10 +202,14 @@ impl Server {
    }
    pub fn wait_until_workspace_is_loaded(&self) {
        self.wait_for_message_cond(1, &|msg: &Message| match msg {
-            Message::Notification(n) if n.method == "window/showMessage" => {
+            Message::Notification(n) if n.method == "$/progress" => {
-                let msg =
+                match n.clone().extract::<ProgressParams>("$/progress").unwrap() {
-                    n.clone().extract::<req::ShowMessageParams>("window/showMessage").unwrap();
+                    ProgressParams {
-                msg.message.starts_with("workspace loaded")
+                        token: req::ProgressToken::String(ref token),
+                        value: ProgressParamsValue::WorkDone(WorkDoneProgress::End(_)),
+                    } if token == "rustAnalyzer/startup" => true,
+                    _ => false,
+                }
            }
            _ => false,
        })
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();