feat: assoc method completion

crates/mun_hir/src/lib.rs

@@ -25,7 +25,7 @@ pub use crate::{
         ArithOp, BinaryOp, Body, CmpOp, Expr, ExprId, ExprScopes, Literal, LogicOp, Ordering, Pat,
         PatId, RecordLitField, Statement, UnaryOp,
     },
-    ids::ItemLoc,
+    ids::{AssocItemId, ItemLoc},
     in_file::InFile,
     name::Name,
     name_resolution::PerNs,
@@ -62,7 +62,7 @@ mod utils;
 
 mod has_module;
 mod item_scope;
-mod method_resolution;
+pub mod method_resolution;
 #[cfg(test)]
 mod mock;
 mod package_defs;

crates/mun_hir/src/semantics.rs

@@ -27,6 +27,15 @@
     HirDatabase, InFile, ModuleDef, Name, PatId, PerNs, Resolver, Ty, Visibility,
 };
 
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum PathResolution {
+    /// An item
+    Def(ModuleDef),
+    /// A local binding (only value namespace)
+    Local(Local),
+    SelfType(Impl),
+}
+
 /// The primary API to get semantic information, like types, from syntax trees.
 /// Exposes the database it was created with through the `db` field.
 pub struct Semantics<'db> {
@@ -147,6 +156,11 @@
         });
         InFile::new(file_id, node)
     }
+
+    /// Resolves the specified `ast::Path`
+    pub fn resolve_path(&self, path: &ast::Path) -> Option<PathResolution> {
+        self.analyze(path.syntax()).resolve_path(self.db, path)
+    }
 }
 
 /// Returns the root node of the specified node.
@@ -201,6 +215,12 @@
     pub(crate) id: ImplId,
 }
 
+impl From<ImplId> for Impl {
+    fn from(id: ImplId) -> Self {
+        Impl { id }
+    }
+}
+
 impl Impl {
     pub fn self_ty(self, db: &dyn HirDatabase) -> Ty {
         db.type_for_impl_self(self.id)

crates/mun_hir/src/source_analyzer.rs

@@ -6,8 +6,10 @@
 use crate::{
     expr::{scope::LocalScopeId, BodySourceMap},
     ids::DefWithBodyId,
-    resolver_for_scope, Body, ExprId, ExprScopes, HirDatabase, InFile, InferenceResult, Resolver,
-    Ty,
+    resolver_for_scope,
+    semantics::PathResolution,
+    Body, ExprId, ExprScopes, HirDatabase, InFile, InferenceResult, Path, Resolver, Struct, Ty,
+    TypeAlias, TypeNs,
 };
 
 /// A `SourceAnalyzer` is a wrapper which exposes the HIR API in terms of the
@@ -79,6 +81,22 @@
         let sm = self.body_source_map.as_ref()?;
         sm.node_expr(expr)
     }
+
+    pub(crate) fn resolve_path(
+        &self,
+        db: &dyn HirDatabase,
+        path: &ast::Path,
+    ) -> Option<PathResolution> {
+        let hir_path = Path::from_ast(path.clone())?;
+
+        // Case where path is a qualifier of another path, e.g. foo::bar::Baz where we
+        // are trying to resolve foo::bar.
+        if path.parent_path().is_some() {
+            return resolve_hir_path_qualifier(db, &self.resolver, &hir_path);
+        }
+
+        None
+    }
 }
 
 /// Returns the id of the scope that is active at the location of `node`.
@@ -173,3 +191,31 @@
         })
         .map(|(_ptr, scope)| *scope)
 }
+
+/// Resolves a path where we know it is a qualifier of another path.
+fn resolve_hir_path_qualifier(
+    db: &dyn HirDatabase,
+    resolver: &Resolver,
+    path: &Path,
+) -> Option<PathResolution> {
+    let (ty, _, remaining_idx) = resolver.resolve_path_as_type(db.upcast(), path)?;
+    let (ty, _unresolved) = match remaining_idx {
+        Some(remaining_idx) => {
+            if remaining_idx + 1 == path.segments.len() {
+                Some((ty, path.segments.last()))
+            } else {
+                None
+            }
+        }
+        None => Some((ty, None)),
+    }?;
+
+    let res = match ty {
+        TypeNs::SelfType(it) => PathResolution::SelfType(it.into()),
+        TypeNs::StructId(it) => PathResolution::Def(Struct::from(it).into()),
+        TypeNs::TypeAliasId(it) => PathResolution::Def(TypeAlias::from(it).into()),
+        TypeNs::PrimitiveType(it) => PathResolution::Def(it.into()),
+    };
+
+    Some(res)
+}

crates/mun_hir/src/ty/lower.rs

@@ -340,7 +340,7 @@ pub mod diagnostics {
     };
 
     #[derive(Debug, PartialEq, Eq, Clone)]
-    pub(crate) enum LowerDiagnostic {
+    pub enum LowerDiagnostic {
         UnresolvedType { id: LocalTypeRefId },
         TypeIsPrivate { id: LocalTypeRefId },
     }

crates/mun_language_server/Cargo.toml

@@ -42,3 +42,4 @@ mun_test = { path = "../mun_test"}
 insta = { workspace = true }
 itertools = { workspace = true }
 tempdir = { workspace = true }
+text_trees = { workspace = true }

crates/mun_language_server/src/completion.rs

@@ -4,20 +4,26 @@
 //! completions.
 
 mod context;
-mod dot;
+// mod dot;
 mod item;
 mod render;
-mod unqualified_path;
+// mod unqualified_path;
 
+mod dot;
+mod expr;
+mod name_ref;
 #[cfg(test)]
 mod test_utils;
 
-use context::CompletionContext;
+use context::{
+    CompletionAnalysis, CompletionContext, DotAccess, NameRefContext, NameRefKind,
+    PathCompletionContext, PathExprContext, PathKind, Qualified,
+};
 pub use item::{CompletionItem, CompletionItemKind, CompletionKind};
 use mun_hir::semantics::ScopeDef;
 
 use crate::{
-    completion::render::{render_field, render_resolution, RenderContext},
+    completion::render::{render_field, render_fn, render_resolution, RenderContext},
     db::AnalysisDatabase,
     FilePosition,
 };
@@ -36,11 +42,18 @@ use crate::{
 /// complete the fields of `foo` and don't want the local variables of
 /// the active scope.
 pub(crate) fn completions(db: &AnalysisDatabase, position: FilePosition) -> Option<Completions> {
-    let context = CompletionContext::new(db, position)?;
+    let (context, analysis) = CompletionContext::new(db, position)?;
 
     let mut result = Completions::default();
-    unqualified_path::complete_unqualified_path(&mut result, &context);
-    dot::complete_dot(&mut result, &context);
+
+    match analysis {
+        CompletionAnalysis::NameRef(name_ref_ctx) => {
+            name_ref::complete_name_ref(&mut result, &context, &name_ref_ctx);
+        }
+    }
+
+    // unqualified_path::complete_unqualified_path(&mut result, &context);
+    // dot::complete_dot(&mut result, &context);
     Some(result)
 }
 
@@ -80,4 +93,15 @@ impl Completions {
         let item = render_field(RenderContext::new(ctx), field);
         self.add(item);
     }
+
+    fn add_function(
+        &mut self,
+        ctx: &CompletionContext<'_>,
+        func: mun_hir::Function,
+        local_name: Option<String>,
+    ) {
+        if let Some(item) = render_fn(RenderContext::new(ctx), local_name, func) {
+            self.add(item);
+        }
+    }
 }