25 files changed, 346 insertions, 133 deletions

diff --git a/Cargo.lock b/Cargo.lock
index e3ad50623..330bdd1cb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -88,21 +88,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "byteorder"
-version = "1.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
-
-[[package]]
-name = "c2-chacha"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "214238caa1bf3a496ec3392968969cab8549f96ff30652c9e56885329315f6bb"
-dependencies = [
- "ppv-lite86",
-]
-
-[[package]]
 name = "cargo_metadata"
 version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -401,12 +386,9 @@ dependencies = [
 
 [[package]]
 name = "fst"
-version = "0.3.5"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "927fb434ff9f0115b215dc0efd2e4fbdd7448522a92a1aa37c77d6a2f8f1ebd6"
-dependencies = [
- "byteorder",
-]
+checksum = "3f7c13470d799474d44e2b9c6a0925807def7af4d120cd4de761433be76f7579"
 
 [[package]]
 name = "fuchsia-zircon"
@@ -1180,11 +1162,11 @@ dependencies = [
 
 [[package]]
 name = "rand_chacha"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03a2a90da8c7523f554344f921aa97283eadf6ac484a6d2a7d0212fa7f8d6853"
+checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
 dependencies = [
- "c2-chacha",
+ "ppv-lite86",
  "rand_core",
 ]
 
diff --git a/crates/ra_db/src/fixture.rs b/crates/ra_db/src/fixture.rs
index 947d6ad56..7f43c2971 100644
--- a/crates/ra_db/src/fixture.rs
+++ b/crates/ra_db/src/fixture.rs
@@ -5,7 +5,7 @@ use std::sync::Arc;
 
 use ra_cfg::CfgOptions;
 use rustc_hash::FxHashMap;
-use test_utils::{extract_offset, parse_fixture, CURSOR_MARKER};
+use test_utils::{extract_offset, parse_fixture, parse_single_fixture, CURSOR_MARKER};
 
 use crate::{
     input::CrateName, CrateGraph, CrateId, Edition, Env, FileId, FilePosition, RelativePathBuf,
@@ -45,23 +45,37 @@ pub trait WithFixture: Default + SourceDatabaseExt + 'static {
 
 impl<DB: SourceDatabaseExt + Default + 'static> WithFixture for DB {}
 
-fn with_single_file(db: &mut dyn SourceDatabaseExt, text: &str) -> FileId {
+fn with_single_file(db: &mut dyn SourceDatabaseExt, ra_fixture: &str) -> FileId {
     let file_id = FileId(0);
     let rel_path: RelativePathBuf = "/main.rs".into();
 
     let mut source_root = SourceRoot::new_local();
     source_root.insert_file(rel_path.clone(), file_id);
 
-    let mut crate_graph = CrateGraph::default();
-    crate_graph.add_crate_root(
-        file_id,
-        Edition::Edition2018,
-        None,
-        CfgOptions::default(),
-        Env::default(),
-    );
-
-    db.set_file_text(file_id, Arc::new(text.to_string()));
+    let fixture = parse_single_fixture(ra_fixture);
+
+    let crate_graph = if let Some(entry) = fixture {
+        let meta = match parse_meta(&entry.meta) {
+            ParsedMeta::File(it) => it,
+            _ => panic!("with_single_file only support file meta"),
+        };
+
+        let mut crate_graph = CrateGraph::default();
+        crate_graph.add_crate_root(file_id, meta.edition, meta.krate, meta.cfg, meta.env);
+        crate_graph
+    } else {
+        let mut crate_graph = CrateGraph::default();
+        crate_graph.add_crate_root(
+            file_id,
+            Edition::Edition2018,
+            None,
+            CfgOptions::default(),
+            Env::default(),
+        );
+        crate_graph
+    };
+
+    db.set_file_text(file_id, Arc::new(ra_fixture.to_string()));
     db.set_file_relative_path(file_id, rel_path);
     db.set_file_source_root(file_id, WORKSPACE);
     db.set_source_root(WORKSPACE, Arc::new(source_root));
@@ -104,7 +118,7 @@ fn with_files(db: &mut dyn SourceDatabaseExt, fixture: &str) -> Option<FilePosit
                 meta.edition,
                 Some(krate.clone()),
                 meta.cfg,
-                Env::default(),
+                meta.env,
             );
             let prev = crates.insert(krate.clone(), crate_id);
             assert!(prev.is_none());
@@ -167,9 +181,10 @@ struct FileMeta {
     deps: Vec<String>,
     cfg: CfgOptions,
     edition: Edition,
+    env: Env,
 }
 
-//- /lib.rs crate:foo deps:bar,baz
+//- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b env:OUTDIR=path/to,OTHER=foo)
 fn parse_meta(meta: &str) -> ParsedMeta {
     let components = meta.split_ascii_whitespace().collect::<Vec<_>>();
 
@@ -186,6 +201,7 @@ fn parse_meta(meta: &str) -> ParsedMeta {
     let mut deps = Vec::new();
     let mut edition = Edition::Edition2018;
     let mut cfg = CfgOptions::default();
+    let mut env = Env::default();
     for component in components[1..].iter() {
         let (key, value) = split1(component, ':').unwrap();
         match key {
@@ -200,11 +216,18 @@ fn parse_meta(meta: &str) -> ParsedMeta {
                     }
                 }
             }
+            "env" => {
+                for key in value.split(',') {
+                    if let Some((k, v)) = split1(key, '=') {
+                        env.set(k.into(), v.into());
+                    }
+                }
+            }
             _ => panic!("bad component: {:?}", component),
         }
     }
 
-    ParsedMeta::File(FileMeta { path, krate, deps, edition, cfg })
+    ParsedMeta::File(FileMeta { path, krate, deps, edition, cfg, env })
 }
 
 fn split1(haystack: &str, delim: char) -> Option<(&str, &str)> {
diff --git a/crates/ra_db/src/input.rs b/crates/ra_db/src/input.rs
index b77640b2b..1a1c64202 100644
--- a/crates/ra_db/src/input.rs
+++ b/crates/ra_db/src/input.rs
@@ -261,6 +261,16 @@ impl fmt::Display for Edition {
     }
 }
 
+impl Env {
+    pub fn set(&mut self, env: &str, value: String) {
+        self.entries.insert(env.to_owned(), value);
+    }
+
+    pub fn get(&self, env: &str) -> Option<String> {
+        self.entries.get(env).cloned()
+    }
+}
+
 #[derive(Debug)]
 pub struct ParseEditionError {
     invalid_input: String,
diff --git a/crates/ra_hir_ty/src/method_resolution.rs b/crates/ra_hir_ty/src/method_resolution.rs
index b7e8855fb..7f5e1469e 100644
--- a/crates/ra_hir_ty/src/method_resolution.rs
+++ b/crates/ra_hir_ty/src/method_resolution.rs
@@ -516,9 +516,31 @@ pub(crate) fn inherent_impl_substs(
     let self_ty_with_vars =
         Canonical { num_vars: vars.len() + self_ty.num_vars, value: self_ty_with_vars };
     let substs = super::infer::unify(&self_ty_with_vars, self_ty);
-    // we only want the substs for the vars we added, not the ones from self_ty
-    let result = substs.map(|s| s.suffix(vars.len()));
-    result
+    // We only want the substs for the vars we added, not the ones from self_ty.
+    // Also, if any of the vars we added are still in there, we replace them by
+    // Unknown. I think this can only really happen if self_ty contained
+    // Unknown, and in that case we want the result to contain Unknown in those
+    // places again.
+    substs.map(|s| fallback_bound_vars(s.suffix(vars.len()), self_ty.num_vars))
+}
+
+/// This replaces any 'free' Bound vars in `s` (i.e. those with indices past
+/// num_vars_to_keep) by `Ty::Unknown`.
+fn fallback_bound_vars(s: Substs, num_vars_to_keep: usize) -> Substs {
+    s.fold_binders(
+        &mut |ty, binders| {
+            if let Ty::Bound(idx) = &ty {
+                if *idx >= binders as u32 {
+                    Ty::Unknown
+                } else {
+                    ty
+                }
+            } else {
+                ty
+            }
+        },
+        num_vars_to_keep,
+    )
 }
 
 fn transform_receiver_ty(
diff --git a/crates/ra_ide/src/completion.rs b/crates/ra_ide/src/completion.rs
index c378c2c62..a27e0fc15 100644
--- a/crates/ra_ide/src/completion.rs
+++ b/crates/ra_ide/src/completion.rs
@@ -33,6 +33,23 @@ pub use crate::completion::completion_item::{
     CompletionItem, CompletionItemKind, InsertTextFormat,
 };
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CompletionOptions {
+    pub enable_postfix_completions: bool,
+    pub add_call_parenthesis: bool,
+    pub add_call_argument_snippets: bool,
+}
+
+impl Default for CompletionOptions {
+    fn default() -> Self {
+        CompletionOptions {
+            enable_postfix_completions: true,
+            add_call_parenthesis: true,
+            add_call_argument_snippets: true,
+        }
+    }
+}
+
 /// Main entry point for completion. We run completion as a two-phase process.
 ///
 /// First, we look at the position and collect a so-called `CompletionContext.
@@ -55,8 +72,12 @@ pub use crate::completion::completion_item::{
 /// `foo` *should* be present among the completion variants. Filtering by
 /// identifier prefix/fuzzy match should be done higher in the stack, together
 /// with ordering of completions (currently this is done by the client).
-pub(crate) fn completions(db: &RootDatabase, position: FilePosition) -> Option<Completions> {
-    let ctx = CompletionContext::new(db, position)?;
+pub(crate) fn completions(
+    db: &RootDatabase,
+    position: FilePosition,
+    opts: &CompletionOptions,
+) -> Option<Completions> {
+    let ctx = CompletionContext::new(db, position, opts)?;
 
     let mut acc = Completions::default();
 
diff --git a/crates/ra_ide/src/completion/complete_dot.rs b/crates/ra_ide/src/completion/complete_dot.rs
index f275305e2..d8f6f0d9d 100644
--- a/crates/ra_ide/src/completion/complete_dot.rs
+++ b/crates/ra_ide/src/completion/complete_dot.rs
@@ -718,4 +718,35 @@ mod tests {
         "###
         );
     }
+
+    #[test]
+    fn test_method_completion_3547() {
+        assert_debug_snapshot!(
+            do_ref_completion(
+                r"
+            struct HashSet<T> {}
+            impl<T> HashSet<T> {
+                pub fn the_method(&self) {}
+            }
+            fn foo() {
+                let s: HashSet<_>;
+                s.<|>
+            }
+            ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "the_method()",
+                source_range: [201; 201),
+                delete: [201; 201),
+                insert: "the_method()$0",
+                kind: Method,
+                lookup: "the_method",
+                detail: "pub fn the_method(&self)",
+            },
+        ]
+        "###
+        );
+    }
 }
diff --git a/crates/ra_ide/src/completion/complete_postfix.rs b/crates/ra_ide/src/completion/complete_postfix.rs
index 65ecea125..6d000548d 100644
--- a/crates/ra_ide/src/completion/complete_postfix.rs
+++ b/crates/ra_ide/src/completion/complete_postfix.rs
@@ -12,7 +12,7 @@ use crate::{
 };
 
 pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
-    if !ctx.db.feature_flags.get("completion.enable-postfix") {
+    if !ctx.options.enable_postfix_completions {
         return;
     }
 
diff --git a/crates/ra_ide/src/completion/complete_trait_impl.rs b/crates/ra_ide/src/completion/complete_trait_impl.rs
index 18a1d2995..2bf654a57 100644
--- a/crates/ra_ide/src/completion/complete_trait_impl.rs
+++ b/crates/ra_ide/src/completion/complete_trait_impl.rs
@@ -34,7 +34,7 @@
 use hir::{self, Docs, HasSource};
 use ra_assists::utils::get_missing_impl_items;
 use ra_syntax::{
-    ast::{self, edit},
+    ast::{self, edit, ImplDef},
     AstNode, SyntaxKind, SyntaxNode, TextRange,
 };
 use ra_text_edit::TextEdit;
@@ -47,22 +47,22 @@ use crate::{
 };
 
 pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext) {
-    let trigger = ctx.token.ancestors().find(|p| match p.kind() {
-        SyntaxKind::FN_DEF
-        | SyntaxKind::TYPE_ALIAS_DEF
-        | SyntaxKind::CONST_DEF
-        | SyntaxKind::BLOCK_EXPR => true,
-        _ => false,
-    });
-
-    let impl_def = trigger
-        .as_ref()
-        .and_then(|node| node.parent())
-        .and_then(|node| node.parent())
-        .and_then(ast::ImplDef::cast);
-
-    if let (Some(trigger), Some(impl_def)) = (trigger, impl_def) {
+    if let Some((trigger, impl_def)) = completion_match(ctx) {
         match trigger.kind() {
+            SyntaxKind::NAME_REF => {
+                get_missing_impl_items(&ctx.sema, &impl_def).iter().for_each(|item| match item {
+                    hir::AssocItem::Function(fn_item) => {
+                        add_function_impl(&trigger, acc, ctx, &fn_item)
+                    }
+                    hir::AssocItem::TypeAlias(type_item) => {
+                        add_type_alias_impl(&trigger, acc, ctx, &type_item)
+                    }
+                    hir::AssocItem::Const(const_item) => {
+                        add_const_impl(&trigger, acc, ctx, &const_item)
+                    }
+                })
+            }
+
             SyntaxKind::FN_DEF => {
                 for missing_fn in get_missing_impl_items(&ctx.sema, &impl_def).iter().filter_map(
                     |item| match item {
@@ -101,6 +101,21 @@ pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext
     }
 }
 
+fn completion_match(ctx: &CompletionContext) -> Option<(SyntaxNode, ImplDef)> {
+    let (trigger, impl_def_offset) = ctx.token.ancestors().find_map(|p| match p.kind() {
+        SyntaxKind::FN_DEF
+        | SyntaxKind::TYPE_ALIAS_DEF
+        | SyntaxKind::CONST_DEF
+        | SyntaxKind::BLOCK_EXPR => Some((p, 2)),
+        SyntaxKind::NAME_REF => Some((p, 5)),
+        _ => None,
+    })?;
+    let impl_def = (0..impl_def_offset - 1)
+        .try_fold(trigger.parent()?, |t, _| t.parent())
+        .and_then(ast::ImplDef::cast)?;
+    Some((trigger, impl_def))
+}
+
 fn add_function_impl(
     fn_def_node: &SyntaxNode,
     acc: &mut Completions,
@@ -210,6 +225,103 @@ mod tests {
     }
 
     #[test]
+    fn name_ref_function_type_const() {
+        let completions = complete(
+            r"
+            trait Test {
+                type TestType;
+                const TEST_CONST: u16;
+                fn test();
+            }
+
+            struct T1;
+
+            impl Test for T1 {
+                t<|>
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "const TEST_CONST: u16 = ",
+                source_range: [209; 210),
+                delete: [209; 210),
+                insert: "const TEST_CONST: u16 = ",
+                kind: Const,
+                lookup: "TEST_CONST",
+            },
+            CompletionItem {
+                label: "fn test()",
+                source_range: [209; 210),
+                delete: [209; 210),
+                insert: "fn test() {}",
+                kind: Function,
+                lookup: "test",
+            },
+            CompletionItem {
+                label: "type TestType = ",
+                source_range: [209; 210),
+                delete: [209; 210),
+                insert: "type TestType = ",
+                kind: TypeAlias,
+                lookup: "TestType",
+            },
+        ]
+        "###);
+    }
+
+    #[test]
+    fn no_nested_fn_completions() {
+        let completions = complete(
+            r"
+            trait Test {
+                fn test();
+                fn test2();
+            }
+
+            struct T1;
+
+            impl Test for T1 {
+                fn test() {
+                    t<|>
+                }
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"[]"###);
+    }
+
+    #[test]
+    fn name_ref_single_function() {
+        let completions = complete(
+            r"
+            trait Test {
+                fn test();
+            }
+
+            struct T1;
+
+            impl Test for T1 {
+                t<|>
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "fn test()",
+                source_range: [139; 140),
+                delete: [139; 140),
+                insert: "fn test() {}",
+                kind: Function,
+                lookup: "test",
+            },
+        ]
+        "###);
+    }
+
+    #[test]
     fn single_function() {
         let completions = complete(
             r"
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index 40535c09e..3646fb8dc 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -11,7 +11,7 @@ use ra_syntax::{
 };
 use ra_text_edit::AtomTextEdit;
 
-use crate::FilePosition;
+use crate::{completion::CompletionOptions, FilePosition};
 
 /// `CompletionContext` is created early during completion to figure out, where
 /// exactly is the cursor, syntax-wise.
@@ -19,6 +19,7 @@ use crate::FilePosition;
 pub(crate) struct CompletionContext<'a> {
     pub(super) sema: Semantics<'a, RootDatabase>,
     pub(super) db: &'a RootDatabase,
+    pub(super) options: &'a CompletionOptions,
     pub(super) offset: TextUnit,
     /// The token before the cursor, in the original file.
     pub(super) original_token: SyntaxToken,
@@ -57,6 +58,7 @@ impl<'a> CompletionContext<'a> {
     pub(super) fn new(
         db: &'a RootDatabase,
         position: FilePosition,
+        options: &'a CompletionOptions,
     ) -> Option<CompletionContext<'a>> {
         let sema = Semantics::new(db);
 
@@ -80,6 +82,7 @@ impl<'a> CompletionContext<'a> {
         let mut ctx = CompletionContext {
             sema,
             db,
+            options,
             original_token,
             token,
             offset: position.offset,
diff --git a/crates/ra_ide/src/completion/completion_item.rs b/crates/ra_ide/src/completion/completion_item.rs
index 19bbb2517..1d14e9636 100644
--- a/crates/ra_ide/src/completion/completion_item.rs
+++ b/crates/ra_ide/src/completion/completion_item.rs
@@ -321,14 +321,18 @@ impl Into<Vec<CompletionItem>> for Completions {
 
 #[cfg(test)]
 pub(crate) fn do_completion(code: &str, kind: CompletionKind) -> Vec<CompletionItem> {
-    use crate::completion::completions;
-    use crate::mock_analysis::{analysis_and_position, single_file_with_position};
+    use crate::{
+        completion::{completions, CompletionOptions},
+        mock_analysis::{analysis_and_position, single_file_with_position},
+    };
+
     let (analysis, position) = if code.contains("//-") {
         analysis_and_position(code)
     } else {
         single_file_with_position(code)
     };
-    let completions = completions(&analysis.db, position).unwrap();
+    let options = CompletionOptions::default();
+    let completions = completions(&analysis.db, position, &options).unwrap();
     let completion_items: Vec<CompletionItem> = completions.into();
     let mut kind_completions: Vec<CompletionItem> =
         completion_items.into_iter().filter(|c| c.completion_kind == kind).collect();
diff --git a/crates/ra_ide/src/completion/presentation.rs b/crates/ra_ide/src/completion/presentation.rs
index aada4d025..3dc56e4a3 100644
--- a/crates/ra_ide/src/completion/presentation.rs
+++ b/crates/ra_ide/src/completion/presentation.rs
@@ -104,10 +104,7 @@ impl Completions {
         };
 
         // Add `<>` for generic types
-        if ctx.is_path_type
-            && !ctx.has_type_args
-            && ctx.db.feature_flags.get("completion.insertion.add-call-parenthesis")
-        {
+        if ctx.is_path_type && !ctx.has_type_args && ctx.options.add_call_parenthesis {
             let has_non_default_type_params = match resolution {
                 ScopeDef::ModuleDef(Adt(it)) => it.has_non_default_type_params(ctx.db),
                 ScopeDef::ModuleDef(TypeAlias(it)) => it.has_non_default_type_params(ctx.db),
@@ -212,21 +209,14 @@ impl Completions {
                 .detail(function_signature.to_string());
 
         // If not an import, add parenthesis automatically.
-        if ctx.use_item_syntax.is_none()
-            && !ctx.is_call
-            && ctx.db.feature_flags.get("completion.insertion.add-call-parenthesis")
-        {
+        if ctx.use_item_syntax.is_none() && !ctx.is_call && ctx.options.add_call_parenthesis {
             tested_by!(inserts_parens_for_function_calls);
 
             let (snippet, label) = if params.is_empty() || has_self_param && params.len() == 1 {
                 (format!("{}()$0", name), format!("{}()", name))
             } else {
                 builder = builder.trigger_call_info();
-                let snippet = if ctx
-                    .db
-                    .feature_flags
-                    .get("completion.insertion.add-argument-snippets")
-                {
+                let snippet = if ctx.options.add_call_argument_snippets {
                     let to_skip = if has_self_param { 1 } else { 0 };
                     let function_params_snippet = join(
                         function_signature.parameter_names.iter().skip(to_skip).enumerate().map(
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index c60e86aea..9f45003d3 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -62,7 +62,7 @@ use crate::display::ToNav;
 pub use crate::{
     assists::{Assist, AssistId},
     call_hierarchy::CallItem,
-    completion::{CompletionItem, CompletionItemKind, InsertTextFormat},
+    completion::{CompletionItem, CompletionItemKind, CompletionOptions, InsertTextFormat},
     diagnostics::Severity,
     display::{file_structure, FunctionSignature, NavigationTarget, StructureNode},
     expand_macro::ExpandedMacro,
@@ -84,7 +84,6 @@ pub use ra_db::{
 };
 pub use ra_ide_db::{
     change::{AnalysisChange, LibraryData},
-    feature_flags::FeatureFlags,
     line_index::{LineCol, LineIndex},
     line_index_utils::translate_offset_with_edit,
     search::SearchScope,
@@ -131,13 +130,13 @@ pub struct AnalysisHost {
 
 impl Default for AnalysisHost {
     fn default() -> AnalysisHost {
-        AnalysisHost::new(None, FeatureFlags::default())
+        AnalysisHost::new(None)
     }
 }
 
 impl AnalysisHost {
-    pub fn new(lru_capcity: Option<usize>, feature_flags: FeatureFlags) -> AnalysisHost {
-        AnalysisHost { db: RootDatabase::new(lru_capcity, feature_flags) }
+    pub fn new(lru_capacity: Option<usize>) -> AnalysisHost {
+        AnalysisHost { db: RootDatabase::new(lru_capacity) }
     }
     /// Returns a snapshot of the current state, which you can query for
     /// semantic information.
@@ -145,10 +144,6 @@ impl AnalysisHost {
         Analysis { db: self.db.snapshot() }
     }
 
-    pub fn feature_flags(&self) -> &FeatureFlags {
-        &self.db.feature_flags
-    }
-
     /// Applies changes to the current state of the world. If there are
     /// outstanding snapshots, they will be canceled.
     pub fn apply_change(&mut self, change: AnalysisChange) {
@@ -224,11 +219,6 @@ impl Analysis {
         (host.analysis(), file_id)
     }
 
-    /// Features for Analysis.
-    pub fn feature_flags(&self) -> &FeatureFlags {
-        &self.db.feature_flags
-    }
-
     /// Debug info about the current state of the analysis.
     pub fn status(&self) -> Cancelable<String> {
         self.with_db(|db| status::status(&*db))
@@ -450,8 +440,12 @@ impl Analysis {
     }
 
     /// Computes completions at the given position.
-    pub fn completions(&self, position: FilePosition) -> Cancelable<Option<Vec<CompletionItem>>> {
-        self.with_db(|db| completion::completions(db, position).map(Into::into))
+    pub fn completions(
+        &self,
+        position: FilePosition,
+        options: &CompletionOptions,
+    ) -> Cancelable<Option<Vec<CompletionItem>>> {
+        self.with_db(|db| completion::completions(db, position, options).map(Into::into))
     }
 
     /// Computes assists (aka code actions aka intentions) for the given
diff --git a/crates/ra_ide_db/Cargo.toml b/crates/ra_ide_db/Cargo.toml
index 52f0f23df..de4f5bce0 100644
--- a/crates/ra_ide_db/Cargo.toml
+++ b/crates/ra_ide_db/Cargo.toml
@@ -13,7 +13,7 @@ wasm = []
 [dependencies]
 log = "0.4.8"
 rayon = "1.3.0"
-fst = { version = "0.3.5", default-features = false }
+fst = { version = "0.4", default-features = false }
 rustc-hash = "1.1.0"
 superslice = "1.0.0"
 once_cell = "1.3.1"
diff --git a/crates/ra_ide_db/src/lib.rs b/crates/ra_ide_db/src/lib.rs
index a105c7556..6bcccc848 100644
--- a/crates/ra_ide_db/src/lib.rs
+++ b/crates/ra_ide_db/src/lib.rs
@@ -5,7 +5,6 @@
 pub mod marks;
 pub mod line_index;
 pub mod line_index_utils;
-pub mod feature_flags;
 pub mod symbol_index;
 pub mod change;
 pub mod defs;
@@ -22,7 +21,7 @@ use ra_db::{
 };
 use rustc_hash::FxHashMap;
 
-use crate::{feature_flags::FeatureFlags, line_index::LineIndex, symbol_index::SymbolsDatabase};
+use crate::{line_index::LineIndex, symbol_index::SymbolsDatabase};
 
 #[salsa::database(
     ra_db::SourceDatabaseStorage,
@@ -37,7 +36,6 @@ use crate::{feature_flags::FeatureFlags, line_index::LineIndex, symbol_index::Sy
 #[derive(Debug)]
 pub struct RootDatabase {
     runtime: salsa::Runtime<RootDatabase>,
-    pub feature_flags: Arc<FeatureFlags>,
     pub(crate) debug_data: Arc<DebugData>,
     pub last_gc: crate::wasm_shims::Instant,
     pub last_gc_check: crate::wasm_shims::Instant,
@@ -82,17 +80,16 @@ impl salsa::Database for RootDatabase {
 
 impl Default for RootDatabase {
     fn default() -> RootDatabase {
-        RootDatabase::new(None, FeatureFlags::default())
+        RootDatabase::new(None)
     }
 }
 
 impl RootDatabase {
-    pub fn new(lru_capacity: Option<usize>, feature_flags: FeatureFlags) -> RootDatabase {
+    pub fn new(lru_capacity: Option<usize>) -> RootDatabase {
         let mut db = RootDatabase {
             runtime: salsa::Runtime::default(),
             last_gc: crate::wasm_shims::Instant::now(),
             last_gc_check: crate::wasm_shims::Instant::now(),
-            feature_flags: Arc::new(feature_flags),
             debug_data: Default::default(),
         };
         db.set_crate_graph_with_durability(Default::default(), Durability::HIGH);
@@ -112,7 +109,6 @@ impl salsa::ParallelDatabase for RootDatabase {
             runtime: self.runtime.snapshot(self),
             last_gc: self.last_gc,
             last_gc_check: self.last_gc_check,
-            feature_flags: Arc::clone(&self.feature_flags),
             debug_data: Arc::clone(&self.debug_data),
         })
     }
diff --git a/crates/ra_ide_db/src/symbol_index.rs b/crates/ra_ide_db/src/symbol_index.rs
index e6b3126b6..884359ee3 100644
--- a/crates/ra_ide_db/src/symbol_index.rs
+++ b/crates/ra_ide_db/src/symbol_index.rs
@@ -163,7 +163,7 @@ pub fn index_resolve(db: &RootDatabase, name_ref: &ast::NameRef) -> Vec<FileSymb
 #[derive(Default)]
 pub struct SymbolIndex {
     symbols: Vec<FileSymbol>,
-    map: fst::Map,
+    map: fst::Map<Vec<u8>>,
 }
 
 impl fmt::Debug for SymbolIndex {
@@ -221,7 +221,7 @@ impl SymbolIndex {
             builder.insert(key, value).unwrap();
         }
 
-        let map = fst::Map::from_bytes(builder.into_inner().unwrap()).unwrap();
+        let map = fst::Map::new(builder.into_inner().unwrap()).unwrap();
         SymbolIndex { symbols, map }
     }
 
diff --git a/crates/rust-analyzer/src/cli/analysis_bench.rs b/crates/rust-analyzer/src/cli/analysis_bench.rs
index 91855e592..28a23934f 100644
--- a/crates/rust-analyzer/src/cli/analysis_bench.rs
+++ b/crates/rust-analyzer/src/cli/analysis_bench.rs
@@ -12,7 +12,7 @@ use ra_db::{
     salsa::{Database, Durability},
     FileId, SourceDatabaseExt,
 };
-use ra_ide::{Analysis, AnalysisChange, AnalysisHost, FilePosition, LineCol};
+use ra_ide::{Analysis, AnalysisChange, AnalysisHost, CompletionOptions, FilePosition, LineCol};
 
 use crate::cli::{load_cargo::load_cargo, Verbosity};
 
@@ -94,17 +94,19 @@ pub fn analysis_bench(verbosity: Verbosity, path: &Path, what: BenchWhat) -> Res
                 .analysis()
                 .file_line_index(file_id)?
                 .offset(LineCol { line: pos.line - 1, col_utf16: pos.column });
-            let file_postion = FilePosition { file_id, offset };
+            let file_position = FilePosition { file_id, offset };
 
             if is_completion {
-                let res =
-                    do_work(&mut host, file_id, |analysis| analysis.completions(file_postion));
+                let options = CompletionOptions::default();
+                let res = do_work(&mut host, file_id, |analysis| {
+                    analysis.completions(file_position, &options)
+                });
                 if verbosity.is_verbose() {
                     println!("\n{:#?}", res);
                 }
             } else {
                 let res =
-                    do_work(&mut host, file_id, |analysis| analysis.goto_definition(file_postion));
+                    do_work(&mut host, file_id, |analysis| analysis.goto_definition(file_position));
                 if verbosity.is_verbose() {
                     println!("\n{:#?}", res);
                 }
diff --git a/crates/rust-analyzer/src/cli/load_cargo.rs b/crates/rust-analyzer/src/cli/load_cargo.rs
index 4be987860..5df29a383 100644
--- a/crates/rust-analyzer/src/cli/load_cargo.rs
+++ b/crates/rust-analyzer/src/cli/load_cargo.rs
@@ -6,7 +6,7 @@ use std::path::Path;
 use anyhow::Result;
 use crossbeam_channel::{unbounded, Receiver};
 use ra_db::{CrateGraph, FileId, SourceRootId};
-use ra_ide::{AnalysisChange, AnalysisHost, FeatureFlags};
+use ra_ide::{AnalysisChange, AnalysisHost};
 use ra_project_model::{get_rustc_cfg_options, PackageRoot, ProjectWorkspace};
 use ra_vfs::{RootEntry, Vfs, VfsChange, VfsTask, Watch};
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -82,7 +82,7 @@ pub(crate) fn load(
     receiver: Receiver<VfsTask>,
 ) -> AnalysisHost {
     let lru_cap = std::env::var("RA_LRU_CAP").ok().and_then(|it| it.parse::<usize>().ok());
-    let mut host = AnalysisHost::new(lru_cap, FeatureFlags::default());
+    let mut host = AnalysisHost::new(lru_cap);
     let mut analysis_change = AnalysisChange::new();
     analysis_change.set_crate_graph(crate_graph);
 
diff --git a/crates/ra_ide_db/src/feature_flags.rs b/crates/rust-analyzer/src/feature_flags.rs
index 968415072..dbb3f50a0 100644
--- a/crates/ra_ide_db/src/feature_flags.rs
+++ b/crates/rust-analyzer/src/feature_flags.rs
@@ -2,6 +2,10 @@
 
 use rustc_hash::FxHashMap;
 
+// FIXME: looks like a much better design is to pass options to each call,
+// rather than to have a global ambient feature flags -- that way, the clients
+// can issue two successive calls with different options.
+
 /// Feature flags hold fine-grained toggles for all *user-visible* features of
 /// rust-analyzer.
 ///
diff --git a/crates/rust-analyzer/src/lib.rs b/crates/rust-analyzer/src/lib.rs
index a0f968823..e50e47b19 100644
--- a/crates/rust-analyzer/src/lib.rs
+++ b/crates/rust-analyzer/src/lib.rs
@@ -37,6 +37,7 @@ mod config;
 mod world;
 mod diagnostics;
 mod semantic_tokens;
+mod feature_flags;
 
 use serde::de::DeserializeOwned;
 
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 221f464b6..f9de712a0 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -18,7 +18,7 @@ use crossbeam_channel::{select, unbounded, RecvError, Sender};
 use lsp_server::{Connection, ErrorCode, Message, Notification, Request, RequestId, Response};
 use lsp_types::{ClientCapabilities, NumberOrString};
 use ra_cargo_watch::{url_from_path_with_drive_lowercasing, CheckOptions, CheckTask};
-use ra_ide::{Canceled, FeatureFlags, FileId, LibraryData, SourceRootId};
+use ra_ide::{Canceled, FileId, LibraryData, SourceRootId};
 use ra_prof::profile;
 use ra_vfs::{VfsFile, VfsTask, Watch};
 use relative_path::RelativePathBuf;
@@ -28,6 +28,7 @@ use threadpool::ThreadPool;
 
 use crate::{
     diagnostics::DiagnosticTask,
+    feature_flags::FeatureFlags,
     main_loop::{
         pending_requests::{PendingRequest, PendingRequests},
         subscriptions::Subscriptions,
@@ -423,7 +424,7 @@ fn loop_turn(
     {
         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") {
+        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);
         }
@@ -839,7 +840,7 @@ fn update_file_notifications_on_threadpool(
     subscriptions: Vec<FileId>,
 ) {
     log::trace!("updating notifications for {:?}", subscriptions);
-    let publish_diagnostics = world.feature_flags().get("lsp.diagnostics");
+    let publish_diagnostics = world.feature_flags.get("lsp.diagnostics");
     pool.execute(move || {
         for file_id in subscriptions {
             if publish_diagnostics {
diff --git a/crates/rust-analyzer/src/main_loop/handlers.rs b/crates/rust-analyzer/src/main_loop/handlers.rs
index 8dc6e8dc0..fcb40432d 100644
--- a/crates/rust-analyzer/src/main_loop/handlers.rs
+++ b/crates/rust-analyzer/src/main_loop/handlers.rs
@@ -20,8 +20,8 @@ use lsp_types::{
     TextEdit, WorkspaceEdit,
 };
 use ra_ide::{
-    Assist, AssistId, FileId, FilePosition, FileRange, Query, RangeInfo, Runnable, RunnableKind,
-    SearchScope,
+    Assist, AssistId, CompletionOptions, FileId, FilePosition, FileRange, Query, RangeInfo,
+    Runnable, RunnableKind, SearchScope,
 };
 use ra_prof::profile;
 use ra_syntax::{AstNode, SyntaxKind, TextRange, TextUnit};
@@ -424,7 +424,15 @@ pub fn handle_completion(
         return Ok(None);
     }
 
-    let items = match world.analysis().completions(position)? {
+    let options = CompletionOptions {
+        enable_postfix_completions: world.feature_flags.get("completion.enable-postfix"),
+        add_call_parenthesis: world.feature_flags.get("completion.insertion.add-call-parenthesis"),
+        add_call_argument_snippets: world
+            .feature_flags
+            .get("completion.insertion.add-argument-snippets"),
+    };
+
+    let items = match world.analysis().completions(position, &options)? {
         None => return Ok(None),
         Some(items) => items,
     };
@@ -461,7 +469,7 @@ pub fn handle_signature_help(
     let _p = profile("handle_signature_help");
     let position = params.try_conv_with(&world)?;
     if let Some(call_info) = world.analysis().call_info(position)? {
-        let concise = !world.analysis().feature_flags().get("call-info.full");
+        let concise = !world.feature_flags.get("call-info.full");
         let mut active_parameter = call_info.active_parameter.map(|it| it as i64);
         if concise && call_info.signature.has_self_param {
             active_parameter = active_parameter.map(|it| it.saturating_sub(1));
diff --git a/crates/rust-analyzer/src/world.rs b/crates/rust-analyzer/src/world.rs
index 6f394055a..1ddc3c1a5 100644
--- a/crates/rust-analyzer/src/world.rs
+++ b/crates/rust-analyzer/src/world.rs
@@ -13,8 +13,7 @@ use lsp_types::Url;
 use parking_lot::RwLock;
 use ra_cargo_watch::{url_from_path_with_drive_lowercasing, CheckOptions, CheckWatcher};
 use ra_ide::{
-    Analysis, AnalysisChange, AnalysisHost, CrateGraph, FeatureFlags, FileId, LibraryData,
-    SourceRootId,
+    Analysis, AnalysisChange, AnalysisHost, CrateGraph, FileId, LibraryData, SourceRootId,
 };
 use ra_project_model::{get_rustc_cfg_options, ProjectWorkspace};
 use ra_vfs::{LineEndings, RootEntry, Vfs, VfsChange, VfsFile, VfsRoot, VfsTask, Watch};
@@ -22,6 +21,7 @@ use relative_path::RelativePathBuf;
 
 use crate::{
     diagnostics::{CheckFixes, DiagnosticCollection},
+    feature_flags::FeatureFlags,
     main_loop::pending_requests::{CompletedRequest, LatestRequests},
     vfs_glob::{Glob, RustPackageFilterBuilder},
     LspError, Result,
@@ -45,6 +45,7 @@ pub struct Options {
 #[derive(Debug)]
 pub struct WorldState {
     pub options: Options,
+    pub feature_flags: Arc<FeatureFlags>,
     //FIXME: this belongs to `LoopState` rather than to `WorldState`
     pub roots_to_scan: usize,
     pub roots: Vec<PathBuf>,
@@ -60,6 +61,7 @@ pub struct WorldState {
 /// An immutable snapshot of the world's state at a point in time.
 pub struct WorldSnapshot {
     pub options: Options,
+    pub feature_flags: Arc<FeatureFlags>,
     pub workspaces: Arc<Vec<ProjectWorkspace>>,
     pub analysis: Analysis,
     pub latest_requests: Arc<RwLock<LatestRequests>>,
@@ -146,10 +148,11 @@ impl WorldState {
                 CheckWatcher::dummy()
             });
 
-        let mut analysis_host = AnalysisHost::new(lru_capacity, feature_flags);
+        let mut analysis_host = AnalysisHost::new(lru_capacity);
         analysis_host.apply_change(change);
         WorldState {
             options,
+            feature_flags: Arc::new(feature_flags),
             roots_to_scan,
             roots: folder_roots,
             workspaces: Arc::new(workspaces),
@@ -216,6 +219,7 @@ impl WorldState {
     pub fn snapshot(&self) -> WorldSnapshot {
         WorldSnapshot {
             options: self.options.clone(),
+            feature_flags: Arc::clone(&self.feature_flags),
             workspaces: Arc::clone(&self.workspaces),
             analysis: self.analysis_host.analysis(),
             vfs: Arc::clone(&self.vfs),
@@ -235,10 +239,6 @@ impl WorldState {
     pub fn complete_request(&mut self, request: CompletedRequest) {
         self.latest_requests.write().record(request)
     }
-
-    pub fn feature_flags(&self) -> &FeatureFlags {
-        self.analysis_host.feature_flags()
-    }
 }
 
 impl WorldSnapshot {
@@ -306,8 +306,4 @@ impl WorldSnapshot {
         let path = self.vfs.read().file2path(VfsFile(file_id.0));
         self.workspaces.iter().find_map(|ws| ws.workspace_root_for(&path))
     }
-
-    pub fn feature_flags(&self) -> &FeatureFlags {
-        self.analysis.feature_flags()
-    }
 }
diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index 69deddcb5..a0d8f4d37 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -202,6 +202,19 @@ pub fn parse_fixture(fixture: &str) -> Vec<FixtureEntry> {
     res
 }
 
+/// Same as `parse_fixture`, except it allow empty fixture
+pub fn parse_single_fixture(fixture: &str) -> Option<FixtureEntry> {
+    if !fixture.lines().any(|it| it.trim_start().starts_with("//-")) {
+        return None;
+    }
+
+    let fixtures = parse_fixture(fixture);
+    if fixtures.len() > 1 {
+        panic!("too many fixtures");
+    }
+    fixtures.into_iter().nth(0)
+}
+
 // Comparison functionality borrowed from cargo:
 
 /// Compare a line with an expected pattern.
diff --git a/editors/code/package-lock.json b/editors/code/package-lock.json
index 77ee5a0cf..b07964546 100644
--- a/editors/code/package-lock.json
+++ b/editors/code/package-lock.json
@@ -114,9 +114,9 @@
             }
         },
         "@types/vscode": {
-            "version": "1.42.0",
-            "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.42.0.tgz",
-            "integrity": "sha512-ds6TceMsh77Fs0Mq0Vap6Y72JbGWB8Bay4DrnJlf5d9ui2RSe1wis13oQm+XhguOeH1HUfLGzaDAoupTUtgabw==",
+            "version": "1.43.0",
+            "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.43.0.tgz",
+            "integrity": "sha512-kIaR9qzd80rJOxePKpCB/mdy00mz8Apt2QA5Y6rdrKFn13QNFNeP3Hzmsf37Bwh/3cS7QjtAeGSK7wSqAU0sYQ==",
             "dev": true
         },
         "@typescript-eslint/eslint-plugin": {
diff --git a/editors/code/package.json b/editors/code/package.json
index 7a4a93e30..512885454 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -21,7 +21,7 @@
         "Programming Languages"
     ],
     "engines": {
-        "vscode": "^1.42.0"
+        "vscode": "^1.43.0"
     },
     "enableProposedApi": true,
     "scripts": {
@@ -41,7 +41,7 @@
         "@rollup/plugin-node-resolve": "^7.1.1",
         "@types/node": "^12.12.29",
         "@types/node-fetch": "^2.5.5",
-        "@types/vscode": "^1.42.0",
+        "@types/vscode": "^1.43.0",
         "@typescript-eslint/eslint-plugin": "^2.22.0",
         "@typescript-eslint/parser": "^2.22.0",
         "eslint": "^6.8.0",