19 files changed, 272 insertions, 90 deletions

diff --git a/Cargo.lock b/Cargo.lock
index eb5247b69..908319f87 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -170,7 +170,7 @@ dependencies = [
  "chalk-macros",
  "chalk-rust-ir",
  "ena",
- "itertools",
+ "itertools 0.8.2",
  "petgraph",
  "rustc-hash",
 ]
@@ -521,6 +521,15 @@ dependencies = [
 ]
 
 [[package]]
+name = "itertools"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "284f18f85651fe11e8a991b2adb42cb078325c996ed026d994719efcfca1d54b"
+dependencies = [
+ "either",
+]
+
+[[package]]
 name = "itoa"
 version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -875,8 +884,9 @@ version = "0.1.0"
 name = "ra_assists"
 version = "0.1.0"
 dependencies = [
+ "either",
  "format-buf",
- "itertools",
+ "itertools 0.9.0",
  "join_to_string",
  "ra_db",
  "ra_fmt",
@@ -928,7 +938,7 @@ dependencies = [
 name = "ra_fmt"
 version = "0.1.0"
 dependencies = [
- "itertools",
+ "itertools 0.9.0",
  "ra_syntax",
 ]
 
@@ -938,7 +948,7 @@ version = "0.1.0"
 dependencies = [
  "arrayvec",
  "either",
- "itertools",
+ "itertools 0.9.0",
  "log",
  "ra_db",
  "ra_hir_def",
@@ -1015,7 +1025,7 @@ dependencies = [
  "format-buf",
  "indexmap",
  "insta",
- "itertools",
+ "itertools 0.9.0",
  "join_to_string",
  "log",
  "ra_assists",
@@ -1036,6 +1046,7 @@ dependencies = [
 name = "ra_ide_db"
 version = "0.1.0"
 dependencies = [
+ "either",
  "fst",
  "log",
  "once_cell",
@@ -1101,7 +1112,7 @@ name = "ra_syntax"
 version = "0.1.0"
 dependencies = [
  "arrayvec",
- "itertools",
+ "itertools 0.9.0",
  "once_cell",
  "ra_parser",
  "ra_text_edit",
@@ -1278,7 +1289,7 @@ dependencies = [
  "crossbeam-channel",
  "env_logger",
  "globset",
- "itertools",
+ "itertools 0.9.0",
  "jod-thread",
  "log",
  "lsp-server",
diff --git a/crates/ra_assists/Cargo.toml b/crates/ra_assists/Cargo.toml
index 85adddb5b..a87f4052a 100644
--- a/crates/ra_assists/Cargo.toml
+++ b/crates/ra_assists/Cargo.toml
@@ -11,7 +11,8 @@ doctest = false
 format-buf = "1.0.0"
 join_to_string = "0.1.3"
 rustc-hash = "1.1.0"
-itertools = "0.8.2"
+itertools = "0.9.0"
+either = "1.5.3"
 
 ra_syntax = { path = "../ra_syntax" }
 ra_text_edit = { path = "../ra_text_edit" }
diff --git a/crates/ra_assists/src/handlers/auto_import.rs b/crates/ra_assists/src/handlers/auto_import.rs
index bb280f633..99682e023 100644
--- a/crates/ra_assists/src/handlers/auto_import.rs
+++ b/crates/ra_assists/src/handlers/auto_import.rs
@@ -17,6 +17,7 @@ use crate::{
     utils::insert_use_statement,
     AssistId,
 };
+use either::Either;
 
 // Assist: auto_import
 //
@@ -58,6 +59,7 @@ pub(crate) fn auto_import(ctx: AssistCtx) -> Option<Assist> {
     group.finish()
 }
 
+#[derive(Debug)]
 struct AutoImportAssets {
     import_candidate: ImportCandidate,
     module_with_name_to_import: Module,
@@ -127,14 +129,14 @@ impl AutoImportAssets {
         ImportsLocator::new(db)
             .find_imports(&self.get_search_query())
             .into_iter()
-            .filter_map(|module_def| match &self.import_candidate {
+            .filter_map(|candidate| match &self.import_candidate {
                 ImportCandidate::TraitAssocItem(assoc_item_type, _) => {
-                    let located_assoc_item = match module_def {
-                        ModuleDef::Function(located_function) => located_function
+                    let located_assoc_item = match candidate {
+                        Either::Left(ModuleDef::Function(located_function)) => located_function
                             .as_assoc_item(db)
                             .map(|assoc| assoc.container(db))
                             .and_then(Self::assoc_to_trait),
-                        ModuleDef::Const(located_const) => located_const
+                        Either::Left(ModuleDef::Const(located_const)) => located_const
                             .as_assoc_item(db)
                             .map(|assoc| assoc.container(db))
                             .and_then(Self::assoc_to_trait),
@@ -153,10 +155,11 @@ impl AutoImportAssets {
                             |_, assoc| Self::assoc_to_trait(assoc.container(db)),
                         )
                         .map(ModuleDef::from)
+                        .map(Either::Left)
                 }
                 ImportCandidate::TraitMethod(function_callee, _) => {
                     let located_assoc_item =
-                        if let ModuleDef::Function(located_function) = module_def {
+                        if let Either::Left(ModuleDef::Function(located_function)) = candidate {
                             located_function
                                 .as_assoc_item(db)
                                 .map(|assoc| assoc.container(db))
@@ -179,10 +182,18 @@ impl AutoImportAssets {
                             },
                         )
                         .map(ModuleDef::from)
+                        .map(Either::Left)
+                }
+                _ => Some(candidate),
+            })
+            .filter_map(|candidate| match candidate {
+                Either::Left(module_def) => {
+                    self.module_with_name_to_import.find_use_path(db, module_def)
+                }
+                Either::Right(macro_def) => {
+                    self.module_with_name_to_import.find_use_path(db, macro_def)
                 }
-                _ => Some(module_def),
             })
-            .filter_map(|module_def| self.module_with_name_to_import.find_use_path(db, module_def))
             .filter(|use_path| !use_path.segments.is_empty())
             .take(20)
             .collect::<BTreeSet<_>>()
@@ -440,6 +451,30 @@ mod tests {
     }
 
     #[test]
+    fn macro_import() {
+        check_assist(
+            auto_import,
+            r"
+                    //- /lib.rs crate:crate_with_macro
+                    #[macro_export]
+                    macro_rules! foo {
+                        () => ()
+                    }
+
+                    //- /main.rs crate:main deps:crate_with_macro
+                    fn main() {
+                        foo<|>
+                    }",
+            r"use crate_with_macro::foo;
+
+fn main() {
+    foo<|>
+}
+",
+        );
+    }
+
+    #[test]
     fn auto_import_target() {
         check_assist_target(
             auto_import,
diff --git a/crates/ra_assists/src/handlers/fill_match_arms.rs b/crates/ra_assists/src/handlers/fill_match_arms.rs
index 7463b2af7..88b4c8926 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::{Adt, HasSource, Semantics};
+use hir::{Adt, HasSource, ModuleDef, Semantics};
 use itertools::Itertools;
 use ra_ide_db::RootDatabase;
 
@@ -154,7 +154,7 @@ fn resolve_tuple_of_enum_def(
 }
 
 fn build_pat(db: &RootDatabase, module: hir::Module, var: hir::EnumVariant) -> Option<ast::Pat> {
-    let path = crate::ast_transform::path_to_ast(module.find_use_path(db, var.into())?);
+    let path = crate::ast_transform::path_to_ast(module.find_use_path(db, ModuleDef::from(var))?);
 
     // FIXME: use HIR for this; it doesn't currently expose struct vs. tuple vs. unit variants though
     let pat: ast::Pat = match var.source(db).value.kind() {
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index b8704ea7d..bcc9b3f10 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -165,7 +165,6 @@ mod helpers {
 
     use ra_db::{fixture::WithFixture, FileId, FileRange, SourceDatabaseExt};
     use ra_ide_db::{symbol_index::SymbolsDatabase, RootDatabase};
-    use ra_syntax::TextRange;
     use test_utils::{add_cursor, assert_eq_text, extract_range_or_offset, RangeOrOffset};
 
     use crate::{AssistCtx, AssistHandler};
@@ -175,8 +174,7 @@ mod helpers {
         let (mut db, file_id) = RootDatabase::with_single_file(text);
         // FIXME: ideally, this should be done by the above `RootDatabase::with_single_file`,
         // but it looks like this might need specialization? :(
-        let local_roots = vec![db.file_source_root(file_id)];
-        db.set_local_roots(Arc::new(local_roots));
+        db.set_local_roots(Arc::new(vec![db.file_source_root(file_id)]));
         (db, file_id)
     }
 
@@ -206,11 +204,24 @@ mod helpers {
     }
 
     fn check(assist: AssistHandler, before: &str, expected: ExpectedResult) {
-        let (range_or_offset, before) = extract_range_or_offset(before);
-        let range: TextRange = range_or_offset.into();
+        let (text_without_caret, file_with_caret_id, range_or_offset, db) =
+            if before.contains("//-") {
+                let (mut db, position) = RootDatabase::with_position(before);
+                db.set_local_roots(Arc::new(vec![db.file_source_root(position.file_id)]));
+                (
+                    db.file_text(position.file_id).as_ref().to_owned(),
+                    position.file_id,
+                    RangeOrOffset::Offset(position.offset),
+                    db,
+                )
+            } else {
+                let (range_or_offset, text_without_caret) = extract_range_or_offset(before);
+                let (db, file_id) = with_single_file(&text_without_caret);
+                (text_without_caret, file_id, range_or_offset, db)
+            };
+
+        let frange = FileRange { file_id: file_with_caret_id, range: range_or_offset.into() };
 
-        let (db, file_id) = with_single_file(&before);
-        let frange = FileRange { file_id, range };
         let sema = Semantics::new(&db);
         let assist_ctx = AssistCtx::new(&sema, frange, true);
 
@@ -218,7 +229,7 @@ mod helpers {
             (Some(assist), ExpectedResult::After(after)) => {
                 let action = assist.0[0].action.clone().unwrap();
 
-                let mut actual = action.edit.apply(&before);
+                let mut actual = action.edit.apply(&text_without_caret);
                 match action.cursor_position {
                     None => {
                         if let RangeOrOffset::Offset(before_cursor_pos) = range_or_offset {
@@ -237,7 +248,7 @@ mod helpers {
             (Some(assist), ExpectedResult::Target(target)) => {
                 let action = assist.0[0].action.clone().unwrap();
                 let range = action.target.expect("expected target on action");
-                assert_eq_text!(&before[range], target);
+                assert_eq_text!(&text_without_caret[range], target);
             }
             (Some(_), ExpectedResult::NotApplicable) => panic!("assist should not be applicable!"),
             (None, ExpectedResult::After(_)) | (None, ExpectedResult::Target(_)) => {
diff --git a/crates/ra_fmt/Cargo.toml b/crates/ra_fmt/Cargo.toml
index ea9befeaf..e9d057afc 100644
--- a/crates/ra_fmt/Cargo.toml
+++ b/crates/ra_fmt/Cargo.toml
@@ -9,6 +9,6 @@ publish = false
 doctest = false
 
 [dependencies]
-itertools = "0.8.2"
+itertools = "0.9.0"
 
 ra_syntax = { path = "../ra_syntax" }
diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml
index 42193b492..ba7b39a19 100644
--- a/crates/ra_hir/Cargo.toml
+++ b/crates/ra_hir/Cargo.toml
@@ -13,7 +13,7 @@ rustc-hash = "1.1.0"
 either = "1.5.3"
 arrayvec = "0.5.1"
 
-itertools = "0.8.2"
+itertools = "0.9.0"
 
 ra_syntax = { path = "../ra_syntax" }
 ra_db = { path = "../ra_db" }
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index e91abf6f5..c5cfd875f 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -33,7 +33,11 @@ use ra_syntax::{
 };
 use rustc_hash::FxHashSet;
 
-use crate::{db::HirDatabase, has_source::HasSource, CallableDef, HirDisplay, InFile, Name};
+use crate::{
+    db::{DefDatabase, HirDatabase},
+    has_source::HasSource,
+    CallableDef, HirDisplay, InFile, Name,
+};
 
 /// hir::Crate describes a single crate. It's the main interface with which
 /// a crate's dependencies interact. Mostly, it should be just a proxy for the
@@ -274,20 +278,10 @@ impl Module {
     /// this module, if possible.
     pub fn find_use_path(
         self,
-        db: &dyn HirDatabase,
-        item: ModuleDef,
+        db: &dyn DefDatabase,
+        item: impl Into<ItemInNs>,
     ) -> Option<hir_def::path::ModPath> {
-        // FIXME expose namespace choice
-        hir_def::find_path::find_path(db.upcast(), determine_item_namespace(item), self.into())
-    }
-}
-
-fn determine_item_namespace(module_def: ModuleDef) -> ItemInNs {
-    match module_def {
-        ModuleDef::Static(_) | ModuleDef::Const(_) | ModuleDef::Function(_) => {
-            ItemInNs::Values(module_def.into())
-        }
-        _ => ItemInNs::Types(module_def.into()),
+        hir_def::find_path::find_path(db, item.into(), self.into())
     }
 }
 
diff --git a/crates/ra_hir/src/from_id.rs b/crates/ra_hir/src/from_id.rs
index c179b13c6..62fb52e72 100644
--- a/crates/ra_hir/src/from_id.rs
+++ b/crates/ra_hir/src/from_id.rs
@@ -9,8 +9,8 @@ use hir_def::{
 };
 
 use crate::{
-    Adt, AssocItem, AttrDef, DefWithBody, EnumVariant, GenericDef, Local, ModuleDef, StructField,
-    VariantDef,
+    code_model::ItemInNs, Adt, AssocItem, AttrDef, DefWithBody, EnumVariant, GenericDef, Local,
+    MacroDef, ModuleDef, StructField, VariantDef,
 };
 
 macro_rules! from_id {
@@ -228,3 +228,20 @@ impl From<(DefWithBodyId, PatId)> for Local {
         Local { parent, pat_id }
     }
 }
+
+impl From<MacroDef> for ItemInNs {
+    fn from(macro_def: MacroDef) -> Self {
+        ItemInNs::Macros(macro_def.into())
+    }
+}
+
+impl From<ModuleDef> for ItemInNs {
+    fn from(module_def: ModuleDef) -> Self {
+        match module_def {
+            ModuleDef::Static(_) | ModuleDef::Const(_) | ModuleDef::Function(_) => {
+                ItemInNs::Values(module_def.into())
+            }
+            _ => ItemInNs::Types(module_def.into()),
+        }
+    }
+}
diff --git a/crates/ra_ide/Cargo.toml b/crates/ra_ide/Cargo.toml
index 7235c944c..36eec0e60 100644
--- a/crates/ra_ide/Cargo.toml
+++ b/crates/ra_ide/Cargo.toml
@@ -14,7 +14,7 @@ wasm = []
 either = "1.5.3"
 format-buf = "1.0.0"
 indexmap = "1.3.2"
-itertools = "0.8.2"
+itertools = "0.9.0"
 join_to_string = "0.1.3"
 log = "0.4.8"
 rustc-hash = "1.1.0"
diff --git a/crates/ra_ide/src/completion/complete_postfix.rs b/crates/ra_ide/src/completion/complete_postfix.rs
index 0ba382165..0a00054b2 100644
--- a/crates/ra_ide/src/completion/complete_postfix.rs
+++ b/crates/ra_ide/src/completion/complete_postfix.rs
@@ -1,6 +1,9 @@
 //! FIXME: write short doc here
 
-use ra_syntax::{ast::AstNode, TextRange, TextUnit};
+use ra_syntax::{
+    ast::{self, AstNode},
+    TextRange, TextUnit,
+};
 use ra_text_edit::TextEdit;
 
 use crate::{
@@ -21,13 +24,8 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
         None => return,
     };
 
-    let receiver_text = if ctx.dot_receiver_is_ambiguous_float_literal {
-        let text = dot_receiver.syntax().text();
-        let without_dot = ..text.len() - TextUnit::of_char('.');
-        text.slice(without_dot).to_string()
-    } else {
-        dot_receiver.syntax().text().to_string()
-    };
+    let receiver_text =
+        get_receiver_text(dot_receiver, ctx.dot_receiver_is_ambiguous_float_literal);
 
     let receiver_ty = match ctx.sema.type_of_expr(&dot_receiver) {
         Some(it) => it,
@@ -35,10 +33,17 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
     };
 
     if receiver_ty.is_bool() || receiver_ty.is_unknown() {
-        postfix_snippet(ctx, "if", "if expr {}", &format!("if {} {{$0}}", receiver_text))
-            .add_to(acc);
         postfix_snippet(
             ctx,
+            &dot_receiver,
+            "if",
+            "if expr {}",
+            &format!("if {} {{$0}}", receiver_text),
+        )
+        .add_to(acc);
+        postfix_snippet(
+            ctx,
+            &dot_receiver,
             "while",
             "while expr {}",
             &format!("while {} {{\n$0\n}}", receiver_text),
@@ -46,28 +51,70 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
         .add_to(acc);
     }
 
-    postfix_snippet(ctx, "not", "!expr", &format!("!{}", receiver_text)).add_to(acc);
+    // !&&&42 is a compiler error, ergo process it before considering the references
+    postfix_snippet(ctx, &dot_receiver, "not", "!expr", &format!("!{}", receiver_text)).add_to(acc);
 
-    postfix_snippet(ctx, "ref", "&expr", &format!("&{}", receiver_text)).add_to(acc);
-    postfix_snippet(ctx, "refm", "&mut expr", &format!("&mut {}", receiver_text)).add_to(acc);
+    postfix_snippet(ctx, &dot_receiver, "ref", "&expr", &format!("&{}", receiver_text)).add_to(acc);
+    postfix_snippet(ctx, &dot_receiver, "refm", "&mut expr", &format!("&mut {}", receiver_text))
+        .add_to(acc);
+
+    // The rest of the postfix completions create an expression that moves an argument,
+    // so it's better to consider references now to avoid breaking the compilation
+    let dot_receiver = include_references(dot_receiver);
+    let receiver_text =
+        get_receiver_text(&dot_receiver, ctx.dot_receiver_is_ambiguous_float_literal);
 
     postfix_snippet(
         ctx,
+        &dot_receiver,
         "match",
         "match expr {}",
         &format!("match {} {{\n    ${{1:_}} => {{$0\\}},\n}}", receiver_text),
     )
     .add_to(acc);
 
-    postfix_snippet(ctx, "dbg", "dbg!(expr)", &format!("dbg!({})", receiver_text)).add_to(acc);
+    postfix_snippet(
+        ctx,
+        &dot_receiver,
+        "box",
+        "Box::new(expr)",
+        &format!("Box::new({})", receiver_text),
+    )
+    .add_to(acc);
 
-    postfix_snippet(ctx, "box", "Box::new(expr)", &format!("Box::new({})", receiver_text))
+    postfix_snippet(ctx, &dot_receiver, "dbg", "dbg!(expr)", &format!("dbg!({})", receiver_text))
         .add_to(acc);
 }
 
-fn postfix_snippet(ctx: &CompletionContext, label: &str, detail: &str, snippet: &str) -> Builder {
+fn get_receiver_text(receiver: &ast::Expr, receiver_is_ambiguous_float_literal: bool) -> String {
+    if receiver_is_ambiguous_float_literal {
+        let text = receiver.syntax().text();
+        let without_dot = ..text.len() - TextUnit::of_char('.');
+        text.slice(without_dot).to_string()
+    } else {
+        receiver.to_string()
+    }
+}
+
+fn include_references(initial_element: &ast::Expr) -> ast::Expr {
+    let mut resulting_element = initial_element.clone();
+    while let Some(parent_ref_element) =
+        resulting_element.syntax().parent().and_then(ast::RefExpr::cast)
+    {
+        resulting_element = ast::Expr::from(parent_ref_element);
+    }
+    resulting_element
+}
+
+fn postfix_snippet(
+    ctx: &CompletionContext,
+    receiver: &ast::Expr,
+    label: &str,
+    detail: &str,
+    snippet: &str,
+) -> Builder {
     let edit = {
-        let receiver_syntax = ctx.dot_receiver.as_ref().expect("no receiver available").syntax();
+        let receiver_syntax = receiver.syntax();
         let receiver_range = ctx.sema.original_range(receiver_syntax).range;
         let delete_range = TextRange::from_to(receiver_range.start(), ctx.source_range().end());
         TextEdit::replace(delete_range, snippet.to_string())
@@ -340,4 +387,63 @@ mod tests {
         "###
         );
     }
+
+    #[test]
+    fn postfix_completion_for_references() {
+        assert_debug_snapshot!(
+            do_postfix_completion(
+                r#"
+                fn main() {
+                    &&&&42.<|>
+                }
+                "#,
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "box",
+                source_range: [56; 56),
+                delete: [49; 56),
+                insert: "Box::new(&&&&42)",
+                detail: "Box::new(expr)",
+            },
+            CompletionItem {
+                label: "dbg",
+                source_range: [56; 56),
+                delete: [49; 56),
+                insert: "dbg!(&&&&42)",
+                detail: "dbg!(expr)",
+            },
+            CompletionItem {
+                label: "match",
+                source_range: [56; 56),
+                delete: [49; 56),
+                insert: "match &&&&42 {\n    ${1:_} => {$0\\},\n}",
+                detail: "match expr {}",
+            },
+            CompletionItem {
+                label: "not",
+                source_range: [56; 56),
+                delete: [53; 56),
+                insert: "!42",
+                detail: "!expr",
+            },
+            CompletionItem {
+                label: "ref",
+                source_range: [56; 56),
+                delete: [53; 56),
+                insert: "&42",
+                detail: "&expr",
+            },
+            CompletionItem {
+                label: "refm",
+                source_range: [56; 56),
+                delete: [53; 56),
+                insert: "&mut 42",
+                detail: "&mut expr",
+            },
+        ]
+        "###
+        );
+    }
 }
diff --git a/crates/ra_ide_db/Cargo.toml b/crates/ra_ide_db/Cargo.toml
index de4f5bce0..c3921bd40 100644
--- a/crates/ra_ide_db/Cargo.toml
+++ b/crates/ra_ide_db/Cargo.toml
@@ -17,6 +17,7 @@ fst = { version = "0.4", default-features = false }
 rustc-hash = "1.1.0"
 superslice = "1.0.0"
 once_cell = "1.3.1"
+either = "1.5.3"
 
 ra_syntax = { path = "../ra_syntax" }
 ra_text_edit = { path = "../ra_text_edit" }
diff --git a/crates/ra_ide_db/src/imports_locator.rs b/crates/ra_ide_db/src/imports_locator.rs
index c96351982..bf0d8db60 100644
--- a/crates/ra_ide_db/src/imports_locator.rs
+++ b/crates/ra_ide_db/src/imports_locator.rs
@@ -1,7 +1,7 @@
 //! This module contains an import search funcionality that is provided to the ra_assists module.
 //! Later, this should be moved away to a separate crate that is accessible from the ra_assists module.
 
-use hir::{ModuleDef, Semantics};
+use hir::{MacroDef, ModuleDef, Semantics};
 use ra_prof::profile;
 use ra_syntax::{ast, AstNode, SyntaxKind::NAME};
 
@@ -10,6 +10,7 @@ use crate::{
     symbol_index::{self, FileSymbol, Query},
     RootDatabase,
 };
+use either::Either;
 
 pub struct ImportsLocator<'a> {
     sema: Semantics<'a, RootDatabase>,
@@ -20,7 +21,7 @@ impl<'a> ImportsLocator<'a> {
         Self { sema: Semantics::new(db) }
     }
 
-    pub fn find_imports(&mut self, name_to_import: &str) -> Vec<ModuleDef> {
+    pub fn find_imports(&mut self, name_to_import: &str) -> Vec<Either<ModuleDef, MacroDef>> {
         let _p = profile("search_for_imports");
         let db = self.sema.db;
 
@@ -43,7 +44,8 @@ impl<'a> ImportsLocator<'a> {
             .chain(lib_results.into_iter())
             .filter_map(|import_candidate| self.get_name_definition(&import_candidate))
             .filter_map(|name_definition_to_import| match name_definition_to_import {
-                Definition::ModuleDef(module_def) => Some(module_def),
+                Definition::ModuleDef(module_def) => Some(Either::Left(module_def)),
+                Definition::Macro(macro_def) => Some(Either::Right(macro_def)),
                 _ => None,
             })
             .collect()
diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index 8efc6b368..6fccc2303 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -11,7 +11,7 @@ repository = "https://github.com/rust-analyzer/rust-analyzer"
 doctest = false
 
 [dependencies]
-itertools = "0.8.2"
+itertools = "0.9.0"
 rowan = "0.9.1"
 rustc_lexer = "0.1.0"
 rustc-hash = "1.1.0"
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index d44f0ef1d..e071e9b8d 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -17,7 +17,7 @@ anyhow = "1.0.26"
 crossbeam-channel = "0.4.0"
 env_logger = { version = "0.7.1", default-features = false }
 globset = "0.4.4"
-itertools = "0.8.2"
+itertools = "0.9.0"
 jod-thread = "0.1.0"
 log = "0.4.8"
 lsp-types = { version = "0.73.0", features = ["proposed"] }
diff --git a/editors/code/package.json b/editors/code/package.json
index eb5748515..1d113ebb6 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -73,10 +73,18 @@
                         "type": "string"
                     },
                     "args": {
-                        "type": "array"
+                        "type": "array",
+                        "items": {
+                            "type": "string"
+                        }
                     },
                     "env": {
-                        "type": "object"
+                        "type": "object",
+                        "patternProperties": {
+                            ".+": {
+                                "type": "string"
+                            }
+                        }
                     }
                 }
             }
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 08d821dd0..82ca749f3 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -99,8 +99,10 @@ export async function createClient(config: Config, serverPath: string): Promise<
     // Note that while the CallHierarchyFeature is stable the LSP protocol is not.
     res.registerFeature(new CallHierarchyFeature(res));
 
-    if (config.highlightingSemanticTokens) {
-        res.registerFeature(new SemanticTokensFeature(res));
+    if (config.package.enableProposedApi) {
+        if (config.highlightingSemanticTokens) {
+            res.registerFeature(new SemanticTokensFeature(res));
+        }
     }
 
     return res;
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 16ac50a0a..7668c20b7 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -19,17 +19,11 @@ export class Config {
     ]
         .map(opt => `${this.rootSection}.${opt}`);
 
-    readonly packageJsonVersion: string = vscode
-        .extensions
-        .getExtension(this.extensionId)!
-        .packageJSON
-        .version;
-
-    readonly releaseTag: string | undefined = vscode
-        .extensions
-        .getExtension(this.extensionId)!
-        .packageJSON
-        .releaseTag ?? undefined;
+    readonly package: {
+        version: string;
+        releaseTag: string | undefined;
+        enableProposedApi: boolean | undefined;
+    } = vscode.extensions.getExtension(this.extensionId)!.packageJSON;
 
     readonly globalStoragePath: string;
 
@@ -42,7 +36,7 @@ export class Config {
     private refreshLogging() {
         log.setEnabled(this.traceExtension);
         log.debug(
-            "Extension version:", this.packageJsonVersion,
+            "Extension version:", this.package.version,
             "using configuration:", this.cfg
         );
     }
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 5d2da9a76..7b7c19dfc 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -110,9 +110,9 @@ async function bootstrap(config: Config, state: PersistentState): Promise<string
 }
 
 async function bootstrapExtension(config: Config, state: PersistentState): Promise<void> {
-    if (config.releaseTag === undefined) return;
+    if (config.package.releaseTag === undefined) return;
     if (config.channel === "stable") {
-        if (config.releaseTag === NIGHTLY_TAG) {
+        if (config.package.releaseTag === NIGHTLY_TAG) {
             vscode.window.showWarningMessage(`You are running a nightly version of rust-analyzer extension.
 To switch to stable, uninstall the extension and re-install it from the marketplace`);
         }
@@ -185,7 +185,7 @@ async function getServer(config: Config, state: PersistentState): Promise<string
         }
         return explicitPath;
     };
-    if (config.releaseTag === undefined) return "rust-analyzer";
+    if (config.package.releaseTag === undefined) return "rust-analyzer";
 
     let binaryName: string | undefined = undefined;
     if (process.arch === "x64" || process.arch === "x32") {
@@ -211,21 +211,21 @@ async function getServer(config: Config, state: PersistentState): Promise<string
         await state.updateServerVersion(undefined);
     }
 
-    if (state.serverVersion === config.packageJsonVersion) return dest;
+    if (state.serverVersion === config.package.version) return dest;
 
     if (config.askBeforeDownload) {
         const userResponse = await vscode.window.showInformationMessage(
-            `Language server version ${config.packageJsonVersion} for rust-analyzer is not installed.`,
+            `Language server version ${config.package.version} for rust-analyzer is not installed.`,
             "Download now"
         );
         if (userResponse !== "Download now") return dest;
     }
 
-    const release = await fetchRelease(config.releaseTag);
+    const release = await fetchRelease(config.package.releaseTag);
     const artifact = release.assets.find(artifact => artifact.name === binaryName);
     assert(!!artifact, `Bad release: ${JSON.stringify(release)}`);
 
     await download(artifact.browser_download_url, dest, "Downloading rust-analyzer server", { mode: 0o755 });
-    await state.updateServerVersion(config.packageJsonVersion);
+    await state.updateServerVersion(config.package.version);
     return dest;
 }