Hacky implementation of find implementations

src/gqls-ide/src/implementation.rs

@@ -5,8 +5,16 @@ use vfs::FileId;
 use crate::{Analysis, Location};
 
 impl Analysis {
-    pub fn implementations(&self, file: FileId, at: Point) -> Vec<Location> {
-        todo!()
+    pub fn goto_implementation(&self, file: FileId, at: Point) -> Vec<Location> {
+        let name = match self.name_at(file, at) {
+            Some(name) => name,
+            None => return vec![],
+        };
+        self.implementations(file, name)
+            .into_iter()
+            .map(|res| self.item(res))
+            .map(|item| Location::new(file, item.name.range.into()))
+            .collect()
     }
 }
 

src/gqls-ide/src/implementation/tests.rs

@@ -1 +1,42 @@
+use std::collections::HashSet;
 
+use gqls_fixture::{fixture, Fixture};
+
+use crate::{Ide, Location};
+
+fn test(fixture: Fixture) {
+    let mut ide = Ide::default();
+    ide.setup_fixture(&fixture);
+    let analysis = ide.analysis();
+    let expected_locations = fixture
+        .all_ranges()
+        .map(|(file, range)| Location::new(file, range.into()))
+        .collect::<HashSet<_>>();
+
+    for (file, at) in fixture.all_points() {
+        let locations = analysis.goto_implementation(file, at).into_iter().collect::<HashSet<_>>();
+        assert_eq!(expected_locations, locations);
+    }
+}
+
+#[test]
+fn test_find_implementations() {
+    let fixture = fixture!(
+        "foo" => "
+interface Iface {
+         #^^^^^
+    i: Int
+}
+
+type Foo implements Iface {
+    #...
+    i: Int
+}
+
+extend type Foo implements Iface {
+           #...
+    k: Int
+}"
+    );
+    test(fixture);
+}

src/gqls-ir/src/db.rs

@@ -1,4 +1,5 @@
 use std::sync::Arc;
+use std::vec;
 
 use gqls_base_db::SourceDatabase;
 use gqls_parse::{NodeExt, NodeKind, Point, RangeExt};
@@ -10,19 +11,35 @@ use crate::*;
 
 #[salsa::query_group(DefDatabaseStorage)]
 pub trait DefDatabase: SourceDatabase {
-    fn items(&self, file: FileId) -> Arc<Items>;
+    fn field(&self, res: FieldRes) -> Field;
+    fn implementations(&self, file: FileId, name: Name) -> Vec<ItemRes>;
     fn item(&self, res: ItemRes) -> Item;
     fn item_at(&self, file: FileId, at: Point) -> Option<Idx<Item>>;
-    fn item_map(&self, file: FileId) -> Arc<ItemMap>;
     fn item_body(&self, res: ItemRes) -> Option<Arc<ItemBody>>;
+    fn item_map(&self, file: FileId) -> Arc<ItemMap>;
+    fn item_references(&self, res: ItemRes) -> References;
+    fn items(&self, file: FileId) -> Arc<Items>;
     fn name_at(&self, file: FileId, at: Point) -> Option<Name>;
-    fn field(&self, res: FieldRes) -> Field;
     fn references(&self, res: Res) -> References;
-    fn item_references(&self, res: ItemRes) -> References;
     fn resolve(&self, file: FileId, at: Point) -> Option<Res>;
     fn resolve_item(&self, file: FileId, name: Name) -> ItemResolutions;
 }
 
+fn implementations(db: &dyn DefDatabase, file: FileId, interface: Name) -> Vec<ItemRes> {
+    let mut implementations = vec![];
+    for project in db.projects_of(file) {
+        for &file in db.project_files(project).iter() {
+            let items = db.items(file);
+            for (idx, _) in items.items.iter() {
+                if items.implements(idx, &interface) {
+                    implementations.push(ItemRes { file, idx });
+                }
+            }
+        }
+    }
+    implementations
+}
+
 fn items(db: &dyn DefDatabase, file: FileId) -> Arc<Items> {
     let data = db.file_data(file);
     lower::ItemCtxt::new(data.text).lower(data.tree)

src/gqls-ir/src/lib.rs

@@ -14,7 +14,7 @@ use gqls_parse::{Node, NodeExt, Range};
 use la_arena::IdxRange;
 use smallvec::SmallVec;
 use smol_str::SmolStr;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::fmt::{self, Debug, Display};
 use std::hash::{Hash, Hasher};
 use std::sync::Arc;
@@ -36,6 +36,17 @@ impl Items {
             ItemKind::DirectiveDefinition(_) => None,
         }
     }
+
+    pub fn implements(&self, idx: Idx<Item>, interface: &Name) -> bool {
+        match self.items[idx].kind {
+            ItemKind::TypeDefinition(typedef) => &self.types[typedef].implementations,
+            ItemKind::TypeExtension(type_ext) => &self.type_exts[type_ext].implementations,
+            ItemKind::DirectiveDefinition(_) => return false,
+        }
+        .as_ref()
+        .map(|implements| implements.contains(interface))
+        .unwrap_or_default()
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -60,7 +71,7 @@ pub enum ItemKind {
     DirectiveDefinition(Idx<DirectiveDefinition>),
 }
 
-pub type Implementations = Vec<Ty>;
+pub type Implementations = HashSet<Name>;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct TypeDefinition {

src/gqls-ir/src/lower.rs

@@ -237,7 +237,7 @@ impl ItemCtxt {
         Some(
             implementations
                 .children_of_kind(cursor, NodeKind::NAMED_TYPE)
-                .map(|node| self.lower_named_type(node))
+                .map(|node| self.lower_named_type(node).name())
                 .collect(),
         )
     }

src/gqls-ir/src/tests.rs

@@ -425,9 +425,9 @@ fn test_definitions() {
                     TypeExtension {
                         directives: [],
                         implementations: Some(
-                            [
+                            {
                                 Iface,
-                            ],
+                            },
                         ),
                     },
                 ],

src/gqls/src/lsp.rs

@@ -206,7 +206,7 @@ impl LanguageServer for Gqls {
         self.with_ide(|ide| {
             let path = ide.path(&position.text_document.uri)?;
             let analysis = ide.analysis();
-            let locations = analysis.implementations(path, position.position.convert());
+            let locations = analysis.goto_implementation(path, position.position.convert());
             Ok(convert::locations_to_goto_definition_response(&locations))
         })
     }

vscode-gqls/src/bootstrap.ts

@@ -6,7 +6,7 @@ import { dirname, join } from "path";
 import { createGunzip } from "zlib";
 import assert = require("assert");
 
-const GQLS_VERSION = "v0.0.1";
+const GQLS_VERSION = "v0.0.2";
 
 export async function bootstrap(
   context: vscode.ExtensionContext,