Add new goto definition tests for workspace package import() and importFrom()

With some extracted support infrastructure: `DescriptionWriter`, `NamespaceWriter`, and the generic `TestSourceHandler`

Author: DavisVaughan

crates/ark/src/lsp/tests.rs

@@ -4,6 +4,7 @@ mod find_references;
 mod goto_definition;
 mod main_loop;
 mod rename;
+mod source_handler;
 mod sources;
 mod state;
 mod state_handlers;

crates/ark/src/lsp/tests/goto_definition.rs

@@ -1,14 +1,32 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
 use aether_path::FilePath;
 use assert_matches::assert_matches;
+use oak_db::Db;
+use oak_db::OakDatabase;
+use oak_scan::DbScan;
+use oak_semantic::library::Library;
 use tower_lsp::lsp_types;
 use tower_lsp::lsp_types::GotoDefinitionParams;
 use tower_lsp::lsp_types::GotoDefinitionResponse;
 use url::Url;
 
+use super::source_handler::TestBehavior;
+use super::source_handler::TestSourceHandler;
+use super::utils::did_change_workspace_folders;
 use super::utils::insert_file;
 use super::utils::make_state;
 use super::utils::range;
+use super::utils::test_client;
+use super::utils::write_sources;
+use super::utils::DescriptionWriter;
+use super::utils::NamespaceWriter;
 use crate::lsp::goto_definition::goto_definition;
+use crate::lsp::main_loop::init_aux_for_test;
+use crate::lsp::main_loop::GlobalState;
+use crate::lsp::main_loop::LspState;
+use crate::lsp::sources::SourceScheduler;
 use crate::lsp::state::WorldState;
 use crate::lsp::util::test_path;
 
@@ -214,3 +232,135 @@ fn test_sourced_file_with_sequential_redef_offers_runtime_winner() {
         }
     );
 }
+
+/// Goto-def from a bare `foo()` through to `foopkg::foo()`'s definition via the
+/// workspace package's `import(foopkg)`
+#[tokio::test]
+async fn test_goto_definition_resolves_unqualified_import_into_package() {
+    let _aux = init_aux_for_test();
+
+    let handler = Arc::new(TestSourceHandler::new(HashMap::from([(
+        String::from("foopkg"),
+        TestBehavior::Success(vec![("foo.R", "foo <- function() 1\n")]),
+    )])));
+
+    // Set up the library that our "installed" package lives in
+    let library = tempfile::tempdir().unwrap();
+    DescriptionWriter::new()
+        .package("foopkg")
+        .version("0.0.0")
+        .built("dummy")
+        .write(&library.path().join("foopkg"));
+    NamespaceWriter::new()
+        .export("foo")
+        .write(&library.path().join("foopkg"));
+
+    let mut db = OakDatabase::new();
+    db.set_library_paths(&[library.path().to_path_buf()]);
+
+    let mut state = GlobalState::from_parts(
+        test_client(),
+        WorldState::new(db, Library::new(vec![])),
+        LspState::new(
+            tokio::sync::mpsc::unbounded_channel().0,
+            SourceScheduler::new(Some(handler)),
+        ),
+    );
+
+    // The workspace folder is itself the package that imports `foo`.
+    let workspace = tempfile::tempdir().unwrap();
+    DescriptionWriter::new()
+        .package("mypackage")
+        .version("0.0.0")
+        .imports(&["foopkg"])
+        .write(workspace.path());
+    NamespaceWriter::new()
+        .import("foopkg")
+        .write(workspace.path());
+    let use_path = workspace.path().join("R").join("use.R");
+    let use_uri = Url::from_file_path(&use_path).unwrap();
+    write_sources(&workspace.path().join("R"), &[("use.R", "foo()\n")]);
+
+    // Open the workspace folder, triggering a workspace scan
+    state
+        .handle_event_to_quiescence(did_change_workspace_folders(workspace.path()))
+        .await;
+
+    let world = state.world();
+    let foo_file = world.db.package_by_name("foopkg").unwrap().files(&world.db)[0];
+
+    assert_matches!(
+        goto_definition(make_params(use_uri, 0, 0), world).unwrap(),
+        Some(GotoDefinitionResponse::Link(ref links)) => {
+            assert_eq!(links.len(), 1);
+            assert_eq!(links[0].target_uri, world.wire_url(foo_file));
+            assert_eq!(links[0].target_range, range((0, 0), (0, 3)));
+        }
+    );
+}
+
+/// Goto-def from a bare `bar()` through to `barpkg::bar()`'s definition via the
+/// workspace package's `importFrom(barpkg, bar)`
+#[tokio::test]
+async fn test_goto_definition_resolves_unqualified_import_from_into_package() {
+    let _aux = init_aux_for_test();
+
+    let handler = Arc::new(TestSourceHandler::new(HashMap::from([(
+        String::from("barpkg"),
+        TestBehavior::Success(vec![("bar.R", "bar <- function() 2\n")]),
+    )])));
+
+    // Set up the library that our "installed" package lives in
+    let library = tempfile::tempdir().unwrap();
+    DescriptionWriter::new()
+        .package("barpkg")
+        .version("0.0.0")
+        .built("dummy")
+        .write(&library.path().join("barpkg"));
+    NamespaceWriter::new()
+        .export("bar")
+        .write(&library.path().join("barpkg"));
+
+    let mut db = OakDatabase::new();
+    db.set_library_paths(&[library.path().to_path_buf()]);
+
+    let mut state = GlobalState::from_parts(
+        test_client(),
+        WorldState::new(db, Library::new(vec![])),
+        LspState::new(
+            tokio::sync::mpsc::unbounded_channel().0,
+            SourceScheduler::new(Some(handler)),
+        ),
+    );
+
+    // The workspace folder is itself the package that imports `bar`.
+    let workspace = tempfile::tempdir().unwrap();
+    DescriptionWriter::new()
+        .package("mypackage")
+        .version("0.0.0")
+        .imports(&["barpkg"])
+        .write(workspace.path());
+    NamespaceWriter::new()
+        .import_from("barpkg", "bar")
+        .write(workspace.path());
+    let use_path = workspace.path().join("R").join("use.R");
+    let use_uri = Url::from_file_path(&use_path).unwrap();
+    write_sources(&workspace.path().join("R"), &[("use.R", "bar()\n")]);
+
+    // Open the workspace folder, triggering a workspace scan
+    state
+        .handle_event_to_quiescence(did_change_workspace_folders(workspace.path()))
+        .await;
+
+    let world = state.world();
+    let bar_file = world.db.package_by_name("barpkg").unwrap().files(&world.db)[0];
+
+    assert_matches!(
+        goto_definition(make_params(use_uri, 0, 0), world).unwrap(),
+        Some(GotoDefinitionResponse::Link(ref links)) => {
+            assert_eq!(links.len(), 1);
+            assert_eq!(links[0].target_uri, world.wire_url(bar_file));
+            assert_eq!(links[0].target_range, range((0, 0), (0, 3)));
+        }
+    );
+}

crates/ark/src/lsp/tests/main_loop.rs

@@ -16,8 +16,8 @@ use tower_lsp::lsp_types::WorkspaceFoldersChangeEvent;
 use url::Url;
 
 use super::utils::test_client;
-use super::utils::write_description;
 use super::utils::write_sources;
+use super::utils::DescriptionWriter;
 use crate::lsp::backend::LspMessage;
 use crate::lsp::backend::LspNotification;
 use crate::lsp::main_loop::init_aux_for_test;
@@ -44,7 +44,10 @@ async fn test_workspace_folder_scan_drives_through_main_loop() {
 
     let tmp = tempfile::tempdir().unwrap();
     let pkg = tmp.path().join("pkg");
-    write_description(&pkg, "pkg");
+    DescriptionWriter::new()
+        .package("pkg")
+        .version("0.0.0")
+        .write(&pkg);
     write_sources(&pkg.join("R"), &[("a.R", "x <- 1\n")]);
 
     let params = DidChangeWorkspaceFoldersParams {

crates/ark/src/lsp/tests/source_handler.rs

@@ -0,0 +1,59 @@
+use std::collections::HashMap;
+use std::sync::Mutex;
+
+use super::utils::write_sources;
+use crate::lsp::sources::SourceHandler;
+use crate::lsp::sources::SourceRequest;
+use crate::lsp::sources::SourceResponse;
+
+/// A test [`SourceHandler`] that serves canned behavior per package name and records
+/// every call, so tests can count the number of calls. The handler is shared (as the
+/// `Arc<dyn SourceHandler>` the `SourceScheduler` holds and the clone the test keeps), so
+/// `calls` is a plain `Mutex`.
+pub(super) struct TestSourceHandler {
+    /// Owns the cache directory that `Success` writes per-package sources into.
+    sources: tempfile::TempDir,
+    /// Per-package canned behavior.
+    behavior: HashMap<String, TestBehavior>,
+    /// Each request passed to `handle`, in call order.
+    calls: Mutex<Vec<SourceRequest>>,
+}
+
+// Canned behavior to perform when a particular package is requested
+pub(super) enum TestBehavior {
+    /// Write these `(basename, contents)` files into the package's source dir
+    /// and return `Success(dir)`.
+    Success(Vec<(&'static str, &'static str)>),
+    Failure,
+}
+
+impl TestSourceHandler {
+    pub(super) fn new(behavior: HashMap<String, TestBehavior>) -> Self {
+        Self {
+            sources: tempfile::tempdir().unwrap(),
+            behavior,
+            calls: Mutex::new(Vec::new()),
+        }
+    }
+
+    /// The requests passed to `handle`, in call order, for the test to assert on.
+    pub(super) fn calls(&self) -> &Mutex<Vec<SourceRequest>> {
+        &self.calls
+    }
+}
+
+impl SourceHandler for TestSourceHandler {
+    fn handle(&self, request: &SourceRequest) -> SourceResponse {
+        self.calls.lock().unwrap().push(request.clone());
+
+        match self.behavior.get(request.name()) {
+            Some(TestBehavior::Success(files)) => {
+                let dir = self.sources.path().join(request.name());
+                write_sources(&dir, files);
+                SourceResponse::Success(dir)
+            },
+            Some(TestBehavior::Failure) => SourceResponse::Failure,
+            None => panic!("Unknown test package {}", request.name()),
+        }
+    }
+}