LS Go to Def for Current File Items (#460)

Author: ScottCarda-MS

compiler/qsc_hir/src/ty.rs

@@ -479,6 +479,28 @@ impl Udt {
         Some(field)
     }
 
+    /// The field with the given name. Returns [None] if this user-defined type does not
+    /// have a field with the given name.
+    #[must_use]
+    pub fn find_field_by_name(&self, name: &str) -> Option<&UdtField> {
+        Self::find_field_by_name_rec(&self.definition, name)
+    }
+
+    fn find_field_by_name_rec<'a>(def: &'a UdtDef, name: &str) -> Option<&'a UdtField> {
+        match &def.kind {
+            UdtDefKind::Field(field) => field.name.as_ref().and_then(|field_name| {
+                if field_name.as_ref() == name {
+                    Some(field)
+                } else {
+                    None
+                }
+            }),
+            UdtDefKind::Tuple(defs) => defs
+                .iter()
+                .find_map(|def| Self::find_field_by_name_rec(def, name)),
+        }
+    }
+
     /// The type of the field at the given path. Returns [None] if the path is not valid for this
     /// user-defined type.
     #[must_use]
@@ -490,8 +512,7 @@ impl Udt {
     /// have a field with the given name.
     #[must_use]
     pub fn field_ty_by_name(&self, name: &str) -> Option<&Ty> {
-        let path = self.field_path(name)?;
-        self.field_ty(&path)
+        self.find_field_by_name(name).map(|field| &field.ty)
     }
 }
 

language_service/src/definition.rs

@@ -4,9 +4,10 @@
 #[cfg(test)]
 mod tests;
 
-use crate::qsc_utils::{map_offset, span_contains, Compilation};
-use qsc::hir::{visit::walk_expr, visit::Visitor, Expr, ExprKind, ItemKind, Package, Res};
+use crate::qsc_utils::{find_item, map_offset, span_contains, Compilation};
+use qsc::ast::visit::{walk_callable_decl, walk_expr, walk_pat, walk_ty_def, Visitor};
 use qsc::SourceMap;
+use qsc::{ast, hir, resolve};
 
 #[derive(Debug, PartialEq)]
 pub struct Definition {
@@ -21,15 +22,16 @@ pub(crate) fn get_definition(
 ) -> Option<Definition> {
     // Map the file offset into a SourceMap offset
     let offset = map_offset(&compilation.unit.sources, source_name, offset);
-    let package = &compilation.unit.package;
+    let ast_package = &compilation.unit.ast;
 
     let mut definition_finder = DefinitionFinder {
-        package,
+        compilation,
         source_map: &compilation.unit.sources,
         offset,
         definition: None,
+        curr_callable: None,
     };
-    definition_finder.visit_package(package);
+    definition_finder.visit_package(&ast_package.package);
 
     definition_finder
         .definition
@@ -40,43 +42,192 @@ pub(crate) fn get_definition(
 }
 
 struct DefinitionFinder<'a> {
-    package: &'a Package,
+    compilation: &'a Compilation,
     source_map: &'a SourceMap,
     offset: u32,
     definition: Option<(String, u32)>,
+    curr_callable: Option<&'a ast::CallableDecl>,
 }
 
-impl<'a> Visitor<'_> for DefinitionFinder<'a> {
-    fn visit_expr(&mut self, expr: &Expr) {
+impl DefinitionFinder<'_> {
+    fn set_definition_from_position(&mut self, lo: u32) {
+        self.definition = Some((
+            self.source_map
+                .find_by_offset(lo)
+                .expect("source should exist for offset")
+                .name
+                .to_string(),
+            lo,
+        ));
+    }
+}
+
+impl<'a> Visitor<'a> for DefinitionFinder<'a> {
+    // Handles callable and UDT definitions
+    fn visit_item(&mut self, item: &'a ast::Item) {
+        if span_contains(item.span, self.offset) {
+            match &*item.kind {
+                ast::ItemKind::Callable(decl) => {
+                    if span_contains(decl.name.span, self.offset) {
+                        self.set_definition_from_position(decl.name.span.lo);
+                    } else if span_contains(decl.span, self.offset) {
+                        self.curr_callable = Some(decl);
+                        walk_callable_decl(self, decl);
+                        self.curr_callable = None;
+                    }
+                    // Note: the `item.span` can cover things like doc
+                    // comment, attributes, and visibility keywords, which aren't
+                    // things we want to have hover logic for, while the `decl.span` is
+                    // specific to the contents of the callable decl, which we do want
+                    // hover logic for. If the `if` or `else if` above is not met, then
+                    // the user is hovering over one of these non-decl parts of the item,
+                    // and we want to do nothing.
+                }
+                ast::ItemKind::Ty(ident, def) => {
+                    if span_contains(ident.span, self.offset) {
+                        self.set_definition_from_position(ident.span.lo);
+                    } else {
+                        self.visit_ty_def(def);
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+
+    // Handles UDT field definitions
+    fn visit_ty_def(&mut self, def: &'a ast::TyDef) {
+        if span_contains(def.span, self.offset) {
+            if let ast::TyDefKind::Field(ident, ty) = &*def.kind {
+                if let Some(ident) = ident {
+                    if span_contains(ident.span, self.offset) {
+                        self.set_definition_from_position(ident.span.lo);
+                    } else {
+                        self.visit_ty(ty);
+                    }
+                } else {
+                    self.visit_ty(ty);
+                }
+            } else {
+                walk_ty_def(self, def);
+            }
+        }
+    }
+
+    // Handles local variable definitions
+    fn visit_pat(&mut self, pat: &'a ast::Pat) {
+        if span_contains(pat.span, self.offset) {
+            match &*pat.kind {
+                ast::PatKind::Bind(ident, anno) => {
+                    if span_contains(ident.span, self.offset) {
+                        self.set_definition_from_position(ident.span.lo);
+                    } else if let Some(ty) = anno {
+                        self.visit_ty(ty);
+                    }
+                }
+                _ => walk_pat(self, pat),
+            }
+        }
+    }
+
+    // Handles UDT field references
+    fn visit_expr(&mut self, expr: &'a ast::Expr) {
         if span_contains(expr.span, self.offset) {
-            if let ExprKind::Var(res, _) = expr.kind {
-                let item = match res {
-                    Res::Err => None,
-                    // Just one package plus std for now, so let's live with this hack
-                    Res::Item(item) => {
-                        if item.package.is_none() {
-                            self.package.items.get(item.item)
-                        } else {
-                            // Handling std library is tricky for now
-                            None
+            match &*expr.kind {
+                ast::ExprKind::Field(udt, field) if span_contains(field.span, self.offset) => {
+                    if let Some(hir::ty::Ty::Udt(res)) =
+                        self.compilation.unit.ast.tys.terms.get(udt.id)
+                    {
+                        match res {
+                            hir::Res::Item(item_id) => {
+                                if let (Some(item), _) = find_item(self.compilation, item_id) {
+                                    match &item.kind {
+                                        hir::ItemKind::Ty(_, udt) => {
+                                            if let Some(field) = udt.find_field_by_name(&field.name)
+                                            {
+                                                let span = field.name_span.expect(
+                                                    "field found via name should have a name",
+                                                );
+                                                self.set_definition_from_position(span.lo);
+                                            }
+                                        }
+                                        _ => panic!("UDT has invalid resolution."),
+                                    }
+                                }
+                            }
+                            _ => panic!("UDT has invalid resolution."),
                         }
                     }
-                    Res::Local(_node) => None,
-                };
-                if let Some(def) = item {
-                    if let ItemKind::Callable(decl) = &def.kind {
-                        self.definition = Some((
-                            self.source_map
-                                .find_by_offset(decl.name.span.lo)
-                                .expect("source should exist for offset")
-                                .name
-                                .to_string(),
-                            decl.name.span.lo,
-                        ));
+                }
+                _ => walk_expr(self, expr),
+            }
+        }
+    }
+
+    // Handles local variable, UDT, and callable references
+    fn visit_path(&mut self, path: &'_ ast::Path) {
+        if span_contains(path.span, self.offset) {
+            let res = self.compilation.unit.ast.names.get(path.id);
+            if let Some(res) = res {
+                match &res {
+                    resolve::Res::Item(item_id) => {
+                        if item_id.package.is_none() {
+                            if let (Some(item), _) = find_item(self.compilation, item_id) {
+                                let lo = match &item.kind {
+                                    hir::ItemKind::Callable(decl) => decl.name.span.lo,
+                                    hir::ItemKind::Namespace(_, _) => {
+                                        panic!(
+                                            "Reference node should not refer to a namespace: {}",
+                                            path.id
+                                        )
+                                    }
+                                    hir::ItemKind::Ty(ident, _) => ident.span.lo,
+                                };
+                                self.set_definition_from_position(lo);
+                            };
+                        }
                     }
+                    resolve::Res::Local(node_id) => {
+                        if let Some(curr) = self.curr_callable {
+                            {
+                                let mut finder = AstPatFinder {
+                                    node_id,
+                                    result: None,
+                                };
+                                finder.visit_callable_decl(curr);
+                                if let Some(lo) = finder.result {
+                                    self.set_definition_from_position(lo);
+                                }
+                            }
+                        }
+                    }
+                    _ => {}
                 }
             }
         }
-        walk_expr(self, expr);
+    }
+}
+
+struct AstPatFinder<'a> {
+    node_id: &'a ast::NodeId,
+    result: Option<u32>,
+}
+
+impl<'a> Visitor<'a> for AstPatFinder<'_> {
+    fn visit_pat(&mut self, pat: &'a ast::Pat) {
+        match &*pat.kind {
+            ast::PatKind::Bind(ident, _) => {
+                if ident.id == *self.node_id {
+                    self.result = Some(ident.span.lo);
+                }
+            }
+            _ => walk_pat(self, pat),
+        }
+    }
+
+    fn visit_expr(&mut self, expr: &'a ast::Expr) {
+        if self.result.is_none() {
+            walk_expr(self, expr);
+        }
     }
 }