3 files changed, 305 insertions, 0 deletions

diff --git a/crates/ra_ide/src/completion.rs b/crates/ra_ide/src/completion.rs
index fedc02e14..4f24cd1f9 100644
--- a/crates/ra_ide/src/completion.rs
+++ b/crates/ra_ide/src/completion.rs
@@ -15,6 +15,7 @@ mod complete_path;
 mod complete_scope;
 mod complete_postfix;
 mod complete_macro_in_item_position;
+mod complete_trait_impl;
 
 use ra_db::SourceDatabase;
 use ra_ide_db::RootDatabase;
@@ -74,5 +75,7 @@ pub(crate) fn completions(db: &RootDatabase, position: FilePosition) -> Option<C
     complete_pattern::complete_pattern(&mut acc, &ctx);
     complete_postfix::complete_postfix(&mut acc, &ctx);
     complete_macro_in_item_position::complete_macro_in_item_position(&mut acc, &ctx);
+    complete_trait_impl::complete_trait_impl(&mut acc, &ctx);
+    
     Some(acc)
 }
diff --git a/crates/ra_ide/src/completion/complete_trait_impl.rs b/crates/ra_ide/src/completion/complete_trait_impl.rs
new file mode 100644
index 000000000..0175f5e55
--- /dev/null
+++ b/crates/ra_ide/src/completion/complete_trait_impl.rs
@@ -0,0 +1,293 @@
+use crate::completion::{CompletionContext, Completions, CompletionItem, CompletionKind, CompletionItemKind};
+
+use ra_syntax::ast::{self, NameOwner, AstNode};
+
+use hir::{self, db::HirDatabase, Docs};
+
+
+pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext) {
+    let impl_block = ctx.impl_block.as_ref();
+    let item_list = impl_block.and_then(|i| i.item_list());
+
+    if item_list.is_none() 
+    || impl_block.is_none() 
+    || ctx.function_syntax.is_some() {
+        return;
+    }
+
+    let item_list = item_list.unwrap();
+    let impl_block = impl_block.unwrap();
+
+    let target_trait = resolve_target_trait(ctx.db, &ctx.analyzer, &impl_block);
+    if target_trait.is_none() {
+        return;
+    }
+
+    let target_trait = target_trait.unwrap();
+
+    let trait_items = target_trait.items(ctx.db);
+    let missing_items = trait_items
+        .iter()
+        .filter(|i| {
+            match i {
+                hir::AssocItem::Function(f) => {
+                    let f_name = f.name(ctx.db).to_string();
+
+                    item_list
+                        .impl_items()
+                        .find(|impl_item| {
+                            match impl_item {
+                                ast::ImplItem::FnDef(impl_f) => {
+                                    if let Some(n) = impl_f.name() { 
+                                        f_name == n.syntax().to_string()
+                                    } else { 
+                                        false
+                                    }
+                                },
+                                _ => false
+                            }
+                        }).is_none()
+                },
+                hir::AssocItem::Const(c) => {
+                    let c_name = c.name(ctx.db)
+                        .map(|f| f.to_string());
+
+                    if c_name.is_none() {
+                        return false;
+                    }
+
+                    let c_name = c_name.unwrap();
+
+                    item_list
+                        .impl_items()
+                        .find(|impl_item| {
+                            match impl_item {
+                                ast::ImplItem::ConstDef(c) => {
+                                    if let Some(n) = c.name() { 
+                                        c_name == n.syntax().to_string()
+                                    } else { 
+                                        false
+                                    }
+                                },
+                                _ => false
+                            }
+                        }).is_none()
+                },
+                hir::AssocItem::TypeAlias(t) => {
+                    let t_name = t.name(ctx.db).to_string();
+
+                    item_list
+                        .impl_items()
+                        .find(|impl_item| {
+                            match impl_item {
+                                ast::ImplItem::TypeAliasDef(t) => {
+                                    if let Some(n) = t.name() { 
+                                        t_name == n.syntax().to_string()
+                                    } else { 
+                                        false
+                                    }
+                                },
+                                _ => false
+                            }
+                        }).is_none()
+                }
+            }
+        });
+
+    for item in missing_items {
+        match item {
+            hir::AssocItem::Function(f) => add_function_impl(acc, ctx, f),
+            hir::AssocItem::TypeAlias(t) => add_type_alias_impl(acc, ctx, t),
+            _ => {},
+        }
+    }
+}
+
+fn resolve_target_trait(
+    db: &impl HirDatabase,
+    analyzer: &hir::SourceAnalyzer,
+    impl_block: &ast::ImplBlock
+) -> Option<hir::Trait> {
+    let ast_path = impl_block
+        .target_trait()
+        .map(|it| it.syntax().clone())
+        .and_then(ast::PathType::cast)?
+        .path()?;
+
+    match analyzer.resolve_path(db, &ast_path) {
+        Some(hir::PathResolution::Def(hir::ModuleDef::Trait(def))) => {
+            Some(def)
+        }
+        _ => None,
+    }
+}
+
+fn add_function_impl(acc: &mut Completions, ctx: &CompletionContext, func: &hir::Function) {
+    use crate::display::FunctionSignature;
+
+    let display = FunctionSignature::from_hir(ctx.db, func.clone());
+
+    let func_name = func.name(ctx.db);
+
+    let label = if func.params(ctx.db).len() > 0 {
+        format!("fn {}(..)", func_name.to_string())
+    } else {
+        format!("fn {}()", func_name.to_string())
+    };
+
+    let builder = CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label.clone())
+        .lookup_by(label)
+        .set_documentation(func.docs(ctx.db));
+
+    let completion_kind = if func.has_self_param(ctx.db) {
+        CompletionItemKind::Method
+    } else {
+        CompletionItemKind::Function
+    };
+    
+    let snippet = {
+        let mut s = format!("{}", display);
+        s.push_str(" {}");
+        s
+    };
+
+    builder
+        .insert_text(snippet)
+        .kind(completion_kind)
+        .add_to(acc);
+}
+
+fn add_type_alias_impl(acc: &mut Completions, ctx: &CompletionContext, type_alias: &hir::TypeAlias) {
+    let snippet = format!("type {} = ", type_alias.name(ctx.db).to_string());
+
+    CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone())
+        .insert_text(snippet)
+        .kind(CompletionItemKind::TypeAlias)
+        .set_documentation(type_alias.docs(ctx.db))
+        .add_to(acc);
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+    use insta::assert_debug_snapshot;
+
+    fn complete(code: &str) -> Vec<CompletionItem> {
+        do_completion(code, CompletionKind::Magic)
+    }
+
+    #[test]
+    fn single_function() {
+        let completions = complete(
+            r"
+            trait Test {
+                fn foo();
+            }
+
+            struct T1;
+
+            impl Test for T1 {
+                <|>
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "fn foo()",
+                source_range: [138; 138),
+                delete: [138; 138),
+                insert: "fn foo() {}",
+                kind: Function,
+            },
+        ]
+        "###);
+    }
+
+    #[test]
+    fn hide_implemented_fn() {
+        let completions = complete(
+            r"
+            trait Test {
+                fn foo();
+                fn bar();
+            }
+
+            struct T1;
+
+            impl Test for T1 {
+                fn foo() {}
+
+                <|>
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "fn bar()",
+                source_range: [193; 193),
+                delete: [193; 193),
+                insert: "fn bar() {}",
+                kind: Function,
+            },
+        ]
+        "###);
+    }
+
+    #[test]
+    fn generic_fn() {
+        let completions = complete(
+            r"
+            trait Test {
+                fn foo<T>();
+            }
+
+            struct T1;
+
+            impl Test for T1 {
+                <|>
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "fn foo()",
+                source_range: [141; 141),
+                delete: [141; 141),
+                insert: "fn foo<T>() {}",
+                kind: Function,
+            },
+        ]
+        "###);
+    }
+
+    #[test]
+    fn generic_constrait_fn() {
+        let completions = complete(
+            r"
+            trait Test {
+                fn foo<T>() where T: Into<String>;
+            }
+
+            struct T1;
+
+            impl Test for T1 {
+                <|>
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "fn foo()",
+                source_range: [163; 163),
+                delete: [163; 163),
+                insert: "fn foo<T>()\nwhere T: Into<String> {}",
+                kind: Function,
+            },
+        ]
+        "###);
+    }
+}
\ No newline at end of file
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index 5a0407fd7..8678a3234 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -25,6 +25,7 @@ pub(crate) struct CompletionContext<'a> {
     pub(super) use_item_syntax: Option<ast::UseItem>,
     pub(super) record_lit_syntax: Option<ast::RecordLit>,
     pub(super) record_lit_pat: Option<ast::RecordPat>,
+    pub(super) impl_block: Option<ast::ImplBlock>,
     pub(super) is_param: bool,
     /// If a name-binding or reference to a const in a pattern.
     /// Irrefutable patterns (like let) are excluded.
@@ -72,6 +73,7 @@ impl<'a> CompletionContext<'a> {
             use_item_syntax: None,
             record_lit_syntax: None,
             record_lit_pat: None,
+            impl_block: None,
             is_param: false,
             is_pat_binding: false,
             is_trivial_path: false,
@@ -148,6 +150,13 @@ impl<'a> CompletionContext<'a> {
             self.record_lit_syntax = find_node_at_offset(original_file.syntax(), self.offset);
         }
 
+        self.impl_block = self
+            .token
+            .parent()
+            .ancestors()
+            .take_while(|it| it.kind() != SOURCE_FILE && it.kind() != MODULE)
+            .find_map(ast::ImplBlock::cast);
+
         let top_node = name_ref
             .syntax()
             .ancestors()