Implement completion for associated items

Author: lnicola

crates/ra_hir/src/ty/method_resolution.rs

@@ -174,4 +174,25 @@ impl Ty {
         }
         None
     }
+
+    // This would be nicer if it just returned an iterator, but that's really
+    // complicated with all the cancelable operations
+    pub fn iterate_impl_items<T>(
+        self,
+        db: &impl HirDatabase,
+        mut callback: impl FnMut(ImplItem) -> Option<T>,
+    ) -> Option<T> {
+        if let Some(krate) = def_crate(db, &self) {
+            let impls = db.impls_in_crate(krate);
+
+            for (_, impl_block) in impls.lookup_impl_blocks(db, &self) {
+                for item in impl_block.items() {
+                    if let Some(result) = callback(item.clone()) {
+                        return Some(result);
+                    }
+                }
+            }
+        }
+        None
+    }
 }

crates/ra_ide_api/src/completion.rs

@@ -80,3 +80,25 @@ pub fn function_label(node: &ast::FnDef) -> Option<String> {
 
     Some(label.trim().to_owned())
 }
+
+pub fn const_label(node: &ast::ConstDef) -> String {
+    let label: String = node
+        .syntax()
+        .children()
+        .filter(|child| ast::Comment::cast(child).is_none())
+        .map(|node| node.text().to_string())
+        .collect();
+
+    label.trim().to_owned()
+}
+
+pub fn type_label(node: &ast::TypeDef) -> String {
+    let label: String = node
+        .syntax()
+        .children()
+        .filter(|child| ast::Comment::cast(child).is_none())
+        .map(|node| node.text().to_string())
+        .collect();
+
+    label.trim().to_owned()
+}

crates/ra_ide_api/src/completion/complete_path.rs

@@ -1,6 +1,6 @@
 use join_to_string::join;
 use hir::{Docs, Resolution};
-use ra_syntax::AstNode;
+use ra_syntax::{AstNode, ast::NameOwner};
 use test_utils::tested_by;
 
 use crate::completion::{CompletionItem, CompletionItemKind, Completions, CompletionKind, CompletionContext};
@@ -58,6 +58,51 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
                 }
             });
         }
+        hir::ModuleDef::Struct(s) => {
+            let ty = s.ty(ctx.db);
+            ty.iterate_impl_items(ctx.db, |item| match item {
+                hir::ImplItem::Method(func) => {
+                    let sig = func.signature(ctx.db);
+                    if !sig.has_self_param() {
+                        CompletionItem::new(
+                            CompletionKind::Reference,
+                            ctx.source_range(),
+                            sig.name().to_string(),
+                        )
+                        .from_function(ctx, func)
+                        .kind(CompletionItemKind::Method)
+                        .add_to(acc);
+                    }
+                    None::<()>
+                }
+                hir::ImplItem::Const(ct) => {
+                    let source = ct.source(ctx.db);
+                    if let Some(name) = source.1.name() {
+                        CompletionItem::new(
+                            CompletionKind::Reference,
+                            ctx.source_range(),
+                            name.text().to_string(),
+                        )
+                        .from_const(ctx, ct)
+                        .add_to(acc);
+                    }
+                    None::<()>
+                }
+                hir::ImplItem::Type(ty) => {
+                    let source = ty.source(ctx.db);
+                    if let Some(name) = source.1.name() {
+                        CompletionItem::new(
+                            CompletionKind::Reference,
+                            ctx.source_range(),
+                            name.text().to_string(),
+                        )
+                        .from_type(ctx, ty)
+                        .add_to(acc);
+                    }
+                    None::<()>
+                }
+            });
+        }
         _ => return,
     };
 }

crates/ra_ide_api/src/completion/completion_item.rs

@@ -8,6 +8,8 @@ use test_utils::tested_by;
 use crate::completion::{
     completion_context::CompletionContext,
     function_label,
+    const_label,
+    type_label
 };
 
 /// `CompletionItem` describes a single completion variant in the editor pop-up.
@@ -267,6 +269,28 @@ impl Builder {
         self.kind = Some(CompletionItemKind::Function);
         self
     }
+
+    pub(super) fn from_const(mut self, ctx: &CompletionContext, ct: hir::Const) -> Builder {
+        if let Some(docs) = ct.docs(ctx.db) {
+            self.documentation = Some(docs);
+        }
+
+        self.detail = Some(const_item_label(ctx, ct));
+        self.kind = Some(CompletionItemKind::Const);
+
+        self
+    }
+
+    pub(super) fn from_type(mut self, ctx: &CompletionContext, ty: hir::Type) -> Builder {
+        if let Some(docs) = ty.docs(ctx.db) {
+            self.documentation = Some(docs);
+        }
+
+        self.detail = Some(type_item_label(ctx, ty));
+        self.kind = Some(CompletionItemKind::TypeAlias);
+
+        self
+    }
 }
 
 impl<'a> Into<CompletionItem> for Builder {
@@ -305,6 +329,16 @@ fn function_item_label(ctx: &CompletionContext, function: hir::Function) -> Opti
     function_label(&node)
 }
 
+fn const_item_label(ctx: &CompletionContext, ct: hir::Const) -> String {
+    let node = ct.source(ctx.db).1;
+    const_label(&node)
+}
+
+fn type_item_label(ctx: &CompletionContext, ty: hir::Type) -> String {
+    let node = ty.source(ctx.db).1;
+    type_label(&node)
+}
+
 #[cfg(test)]
 pub(crate) fn do_completion(code: &str, kind: CompletionKind) -> Vec<CompletionItem> {
     use crate::mock_analysis::{single_file_with_position, analysis_and_position};