The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
fix(lsp): find Go usages in build-constrained files and list their callers (#1911)
l0ng-ai159c2d6fd227
diff --git a/crates/ide-lsp/src/go_scope.rs b/crates/ide-lsp/src/go_scope.rsindex 09267d814..663dd5752 100644--- a/crates/ide-lsp/src/go_scope.rs+++ b/crates/ide-lsp/src/go_scope.rs@@ -1,20 +1,23 @@-//! Go modules a gopls search does not reach.+//! Go files a gopls search does not reach.//!//! gopls answers a search from the view of the file it is asked about: the-//! modules of a `go.work`, or that file's own module. Opening more files does-//! not widen it (each gets a view of its own), so the generic scope widening-//! is skipped for Go. Usages in other modules of the project, which use the-//! declaration's module through a local `replace` (a multi-module repository-//! without `go.work`), are found as GoLand finds them: their mentions of the-//! name are resolved one by one in their own module's view.+//! modules of a `go.work`, or that file's own module, built for the host's+//! GOOS/GOARCH without extra tags. Opening more files does not widen it (each+//! gets a view of its own), so the generic scope widening is skipped for Go.+//! Usages it leaves out are found as GoLand finds them, by resolving each+//! mention of the name in its own file's view: files of other modules that use+//! the declaration's module through a local `replace` (a multi-module+//! repository without `go.work`), and files whose build constraints exclude+//! them from the default build (`_windows.go`, `//go:build`).use ide_core::{Pos, Range};use std::collections::{HashMap, HashSet};use std::path::{Path, PathBuf};-/// The files of `candidates` in modules the search at `origin` does not cover and-/// that can refer to `declaration`: its own module, or one replacing it with its directory.-pub(crate) fn other_module_files(origin: &Path, declaration: &Path, candidates: Vec<PathBuf>) -> Vec<PathBuf> {+/// The files of `candidates` the search at `origin` does not cover and that can refer to+/// `declaration`: those of the covered modules excluded from their default build, and those+/// of the declaration's own module or one replacing it with its directory when not covered.+pub(crate) fn files_beyond_search(origin: &Path, declaration: &Path, candidates: Vec<PathBuf>) -> Vec<PathBuf> {let mut modules = ModuleRoots::default();let (Some(origin_module), Some(declaring)) = (modules.of(origin), modules.of(declaration)) else {return Vec::new();@@ -27,8 +30,9 @@ pub(crate) fn other_module_files(origin: &Path, declaration: &Path, candidates:.into_iter().filter(|file| {let Some(module) = modules.of(file) else { return false };+ // The covered modules share the search's view: only their excluded files are missed.if covered.contains(&module) {- return false;+ return !in_default_build(file);}*uses.entry(module.clone()).or_insert_with(|| {module == declaring@@ -42,6 +46,108 @@ pub(crate) fn other_module_files(origin: &Path, declaration: &Path, candidates:.collect()}+/// Whether gopls' default view builds `file`: no build constraint other than the host's+/// own GOOS/GOARCH file name suffix.+fn in_default_build(file: &Path) -> bool {+ let name = file.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();+ let stem = name.strip_suffix(".go").unwrap_or(&name);+ let stem = stem.strip_suffix("_test").unwrap_or(stem);+ let parts: Vec<&str> = stem.split('_').collect();+ // `name_GOOS`, `name_GOARCH`, `name_GOOS_GOARCH`; a file named just `linux.go` has no constraint.+ let host = |part: &&str| *part == host_goos() || *part == host_goarch();+ if parts.len() > 1 {+ let last = parts[parts.len() - 1];+ if (GOOS.contains(&last) || GOARCH.contains(&last)) && !host(&last) {+ return false;+ }+ if parts.len() > 2 && GOARCH.contains(&last) {+ let os = parts[parts.len() - 2];+ if GOOS.contains(&os) && !host(&os) {+ return false;+ }+ }+ }+ std::fs::read_to_string(file).is_ok_and(|text| !constrained_header(&text))+}++/// A `//go:build` or `// +build` line before the package clause.+fn constrained_header(text: &str) -> bool {+ for line in text.lines() {+ let line = line.trim();+ if line.starts_with("package ") {+ return false;+ }+ if line.starts_with("//go:build") || line.starts_with("// +build") {+ return true;+ }+ }+ false+}++fn host_goos() -> &'static str {+ match std::env::consts::OS {+ "macos" => "darwin",+ os => os,+ }+}++fn host_goarch() -> &'static str {+ match std::env::consts::ARCH {+ "x86_64" => "amd64",+ "aarch64" => "arm64",+ "x86" => "386",+ "powerpc64" => "ppc64",+ arch => arch,+ }+}++const GOOS: &[&str] = &[+ "aix",+ "android",+ "darwin",+ "dragonfly",+ "freebsd",+ "hurd",+ "illumos",+ "ios",+ "js",+ "linux",+ "nacl",+ "netbsd",+ "openbsd",+ "plan9",+ "solaris",+ "wasip1",+ "windows",+ "zos",+];+const GOARCH: &[&str] = &[+ "386",+ "amd64",+ "amd64p32",+ "arm",+ "armbe",+ "arm64",+ "arm64be",+ "loong64",+ "mips",+ "mipsle",+ "mips64",+ "mips64le",+ "mips64p32",+ "mips64p32le",+ "ppc",+ "ppc64",+ "ppc64le",+ "riscv",+ "riscv64",+ "s390",+ "s390x",+ "sparc",+ "sparc64",+ "wasm",+];+/// Whole-word occurrences of `word` in `text`, as ranges in UTF-16 columns.pub(crate) fn word_ranges(text: &str, word: &str) -> Vec<Range> {let ident = |c: char| c.is_alphanumeric() || c == '_';@@ -185,14 +291,19 @@ mod tests {write(root, "example/d/go.mod", "module d\n\nreplace example.com/app => github.com/fork/app v1.0.0\n");let candidates = vec![write(root, "same.go", "package app\n"),+ write(root, "same_plan9.go", "package app\n"),+ write(root, &format!("same_{}.go", host_goos()), "package app\n"),+ write(root, "same_plan9_test.go", "package app\n"),+ write(root, "tagged.go", "// Copyright\n\n//go:build integration\n\npackage app\n"),+ write(root, "plan9.go", "package app\n"),write(root, "example/a/main.go", "package main\n"),write(root, "example/b/main.go", "package main\n"),write(root, "example/c/main.go", "package main\n"),write(root, "example/d/main.go", "package main\n"),];assert_eq!(- names(root, other_module_files(&origin, &origin, candidates)),- ["example/a/main.go", "example/b/main.go"]+ names(root, files_beyond_search(&origin, &origin, candidates)),+ ["same_plan9.go", "same_plan9_test.go", "tagged.go", "example/a/main.go", "example/b/main.go"]);}@@ -205,9 +316,15 @@ mod tests {write(root, "app/go.mod", "module example.com/app\n\nreplace example.com/lib => ../lib\n");write(root, "tool/go.mod", "module example.com/tool\n\nreplace example.com/lib => ../lib\n");let declaration = write(root, "lib/lib.go", "package lib\n");- let candidates =- vec![write(root, "app/main.go", "package main\n"), write(root, "tool/main.go", "package main\n")];- assert_eq!(names(root, other_module_files(&declaration, &declaration, candidates)), ["tool/main.go"]);+ let candidates = vec![+ write(root, "app/main.go", "package main\n"),+ write(root, "app/main_plan9.go", "package main\n"),+ write(root, "tool/main.go", "package main\n"),+ ];+ assert_eq!(+ names(root, files_beyond_search(&declaration, &declaration, candidates)),+ ["app/main_plan9.go", "tool/main.go"]+ );}#[test]@@ -219,7 +336,7 @@ mod tests {write(root, "cmd/go.mod", "module cmd\n\nreplace example.com/app => ../\n");let origin = write(root, "cmd/main.go", "package main\n");let candidates = vec![write(root, "other.go", "package app\n"), write(root, "cmd/util.go", "package main\n")];- assert_eq!(names(root, other_module_files(&origin, &declaration, candidates)), ["other.go"]);+ assert_eq!(names(root, files_beyond_search(&origin, &declaration, candidates)), ["other.go"]);}#[test]diff --git a/crates/ide-lsp/src/lib.rs b/crates/ide-lsp/src/lib.rsindex 5bfed1714..0eebfed48 100644--- a/crates/ide-lsp/src/lib.rs+++ b/crates/ide-lsp/src/lib.rs@@ -1696,7 +1696,7 @@ impl LspManager {{partial(v.clone());}- v.locations.extend(self.go_other_module_references(&snap, t, pos, &cancel).await);+ v.locations.extend(self.go_mentions_beyond_search(&snap, t, pos, &cancel, false).await.locations);if cancel.is_cancelled() {return Err(IdeError::cancelled());}@@ -2136,7 +2136,7 @@ impl LspManager {// The second edit covers the first: its files stay analysed.let mut edit = w.second.unwrap_or(w.first);let mut more: BTreeMap<PathBuf, Vec<TextEdit>> = BTreeMap::new();- for l in self.go_other_module_references(snap, t, pos, cancel).await {+ for l in self.go_mentions_beyond_search(snap, t, pos, cancel, false).await.locations {more.entry(l.path.to_path_buf()).or_default().push(TextEdit { range: l.range, new_text: new_name.to_owned() });@@ -2592,6 +2592,15 @@ impl LspManager {}HierarchyDirection::Outgoing => (query().await?, None),};+ let mut out = out;+ if direction == HierarchyDirection::Incoming {+ for caller in self.go_mentions_beyond_search(&snap, t, pos, cancel, true).await.callers {+ match out.iter_mut().find(|i| i.path == caller.path && i.range == caller.range) {+ Some(item) => item.from_ranges.extend(caller.from_ranges),+ None => out.push(caller),+ }+ }+ }if cancel.is_cancelled() {return Err(IdeError::cancelled());}diff --git a/crates/ide-lsp/src/scope.rs b/crates/ide-lsp/src/scope.rsindex 8b8227111..281f40c0b 100644--- a/crates/ide-lsp/src/scope.rs+++ b/crates/ide-lsp/src/scope.rs@@ -11,7 +11,7 @@use crate::server::{Running, Server};use crate::text::DocText;-use crate::types::ReferencesIncomplete;+use crate::types::{HierarchyItem, ReferencesIncomplete};use crate::{DocSnap, LspManager, Target};use futures::StreamExt;use ide_core::{CancellationToken, IdeError, IdeResult, LanguageId, Location, Pos};@@ -53,6 +53,14 @@ pub struct CandidateFiles {/// blocking thread and should stop early when cancelled.pub type CandidateFn = dyn Fn(&CandidateQuery, &CancellationToken) -> CandidateFiles + Send + Sync;+/// What a Go search adds beyond gopls' own answer.+#[derive(Default)]+pub(crate) struct GoMentions {+ pub locations: Vec<Location>,+ /// The declarations containing them, as incoming calls (when asked for).+ pub callers: Vec<HierarchyItem>,+}+/// A reference-based answer and, when files were opened for it, the second one.pub(crate) struct Widened<R> {pub first: R,@@ -166,20 +174,21 @@ impl LspManager {}}- /// Go: usages of the symbol at `pos` in the project's other modules that use its module- /// through a local `replace`, which the search at `pos` does not reach (see `go_scope`).- /// Each mention of the name there is resolved in its own module's view.- pub(crate) async fn go_other_module_references(+ /// Go: usages of the symbol at `pos` that the search at `pos` does not reach (see+ /// `go_scope`), each mention of the name resolved in its own file's view; with `callers`,+ /// also the declarations containing them, as incoming calls.+ pub(crate) async fn go_mentions_beyond_search(&self,snap: &DocSnap,t: &Target,pos: Pos,cancel: &CancellationToken,- ) -> Vec<Location> {+ callers: bool,+ ) -> GoMentions {if snap.language.as_str() != "go" || !t.caps().open_close {- return Vec::new();+ return GoMentions::default();}- let Some(word) = search_word(snap, pos) else { return Vec::new() };+ let Some(word) = search_word(snap, pos) else { return GoMentions::default() };let declarations: Vec<Location> = self.goto_in(snap, std::slice::from_ref(t), "textDocument/definition", pos, Some(cancel), None).await@@ -187,11 +196,11 @@ impl LspManager {.into_iter().filter(|l| l.uri.is_none()).collect();- let Some(declaration) = declarations.first() else { return Vec::new() };- let Some(candidates) = self.candidates(t, word.clone(), cancel).await else { return Vec::new() };+ let Some(declaration) = declarations.first() else { return GoMentions::default() };+ let Some(candidates) = self.candidates(t, word.clone(), cancel).await else { return GoMentions::default() };let (origin, declared) = (snap.path.clone(), declaration.path.to_path_buf());let files = tokio::task::spawn_blocking(move || {- crate::go_scope::other_module_files(&origin, &declared, candidates.files)+ crate::go_scope::files_beyond_search(&origin, &declared, candidates.files).into_iter().filter_map(|f| {let text = std::fs::read_to_string(&f).ok()?;@@ -203,14 +212,17 @@ impl LspManager {.await.unwrap_or_default();if files.is_empty() || cancel.is_cancelled() {- return Vec::new();+ return GoMentions::default();}- // Open, each file gives gopls a view of its module to resolve the mentions in.+ // Open, each file gives gopls a view to resolve its mentions in (its module, its build).let _opened = self.open_transient(t, files.iter().map(|(f, _, _)| f.clone()).collect(), cancel).await;+ let texts: Vec<(PathBuf, Arc<DocText>)> =+ files.iter().map(|(path, text, _)| (path.clone(), Arc::new(text.clone()))).collect();let probes: Vec<(PathBuf, Arc<DocText>, ide_core::Range)> = files.into_iter()- .flat_map(|(path, text, ranges)| {- let text = Arc::new(text);+ .zip(&texts)+ .flat_map(|((path, _, ranges), (_, text))| {+ let text = text.clone();ranges.into_iter().map(move |r| (path.clone(), text.clone(), r))}).collect();@@ -249,10 +261,86 @@ impl LspManager {.buffer_unordered(8).collect().await;+ let locations: Vec<Location> = found.into_iter().flatten().collect();+ let mut out = GoMentions { callers: Vec::new(), locations };+ if callers && !cancel.is_cancelled() {+ for (path, text) in &texts {+ let here: Vec<ide_core::Range> =+ out.locations.iter().filter(|l| l.path == *path).map(|l| l.range).collect();+ if !here.is_empty() {+ out.callers.extend(self.go_callers_in(t, path, text, &here, cancel).await);+ }+ }+ }if cancel.is_cancelled() {- return Vec::new();+ return GoMentions::default();+ }+ out+ }++ /// The declarations of `path` containing `calls`, innermost first, each with its call sites.+ async fn go_callers_in(+ &self,+ t: &Target,+ path: &Path,+ text: &DocText,+ calls: &[ide_core::Range],+ cancel: &CancellationToken,+ ) -> Vec<HierarchyItem> {+ let params = json!({ "textDocument": { "uri": crate::uri::path_to_uri_string(path) } });+ let r: IdeResult<Option<lsp::DocumentSymbolResponse>> =+ self.call(t, "textDocument/documentSymbol", params, Some(cancel), crate::DEFAULT_TIMEOUT).await;+ let range =+ |r: lsp::Range| ide_core::Range::new(text.lsp_to_ide(t.enc(), r.start), text.lsp_to_ide(t.enc(), r.end));+ // (name, kind, detail, range, selection range) of every declaration.+ let mut symbols = Vec::new();+ match r {+ Ok(Some(lsp::DocumentSymbolResponse::Nested(nested))) => {+ let mut stack = nested;+ while let Some(s) = stack.pop() {+ symbols.push((s.name, s.kind, s.detail, range(s.range), range(s.selection_range)));+ stack.extend(s.children.unwrap_or_default());+ }+ }+ #[allow(deprecated)]+ Ok(Some(lsp::DocumentSymbolResponse::Flat(flat))) => {+ for s in flat {+ let r = range(s.location.range);+ symbols.push((s.name, s.kind, None, r, r));+ }+ }+ _ => return Vec::new(),+ }+ let contains =+ |outer: &ide_core::Range, inner: &ide_core::Range| outer.start <= inner.start && inner.end <= outer.end;+ let mut items: Vec<HierarchyItem> = Vec::new();+ for call in calls {+ // The innermost function or method; a package-level declaration otherwise.+ let callable = |k: lsp::SymbolKind| matches!(k, lsp::SymbolKind::FUNCTION | lsp::SymbolKind::METHOD);+ let innermost = |pick: &dyn Fn(lsp::SymbolKind) -> bool| {+ symbols+ .iter()+ .filter(|(_, kind, _, r, _)| pick(*kind) && contains(r, call))+ .min_by_key(|(_, _, _, r, _)| (r.end.line - r.start.line, r.end.col.saturating_sub(r.start.col)))+ };+ let Some((name, kind, detail, r, selection)) = innermost(&callable).or_else(|| innermost(&|_| true)) else {+ continue;+ };+ match items.iter_mut().find(|i| i.range == *r && i.name == *name) {+ Some(item) => item.from_ranges.push(*call),+ None => items.push(HierarchyItem {+ name: name.clone(),+ kind: crate::convert::symbol_kind(*kind),+ detail: detail.clone(),+ path: path.to_path_buf().into(),+ uri: None,+ range: *r,+ selection_range: *selection,+ from_ranges: vec![*call],+ }),+ }}- found.into_iter().flatten().collect()+ items}/// Opens `files` on `t` (read from disk) unless the user has them open;diff --git a/crates/ide-lsp/tests/mock_server.rs b/crates/ide-lsp/tests/mock_server.rsindex 2ffb03fa4..8deea1a2a 100644--- a/crates/ide-lsp/tests/mock_server.rs+++ b/crates/ide-lsp/tests/mock_server.rs@@ -2932,7 +2932,7 @@ async fn references_open_unopened_files_that_mention_the_name() {/// A Go project: the module at the root, `tools` replacing it with `../` and `other` requiring a/// published copy. The mock answers a definition in `tools` like gopls in that module's view.-fn go_modules_harness() -> (Harness, Arc<MockState>, PathBuf, PathBuf, PathBuf) {+fn go_modules_harness() -> (Harness, Arc<MockState>, PathBuf, PathBuf, PathBuf, PathBuf) {let h = harness_for("go", "go", &[("gopls", incremental_caps())], &[]);let s = h.launcher.state("gopls");let write = |rel: &str, text: &str| {@@ -2948,14 +2948,17 @@ fn go_modules_harness() -> (Harness, Arc<MockState>, PathBuf, PathBuf, PathBuf)// Line 1 uses the declaration; line 2 is a local `New` of the tools module.let tools = write("tools/gen.go", "package tools\nvar a = app.New()\nfunc New() {}\n");write("other/o.go", "package other\nvar b = app.New()\n");+ // Built for plan9 only: outside gopls' default view of the root module.+ let plan9 = write("boot_plan9.go", "package app\nfunc boot() { New() }\n");let decl = h.root.join("a.go");- let candidates = vec![same.clone(), tools.clone(), h.root.join("other/o.go")];+ let candidates = vec![same.clone(), tools.clone(), h.root.join("other/o.go"), plan9.clone()];h.mgr.set_candidates_hook(Box::new(move |_, _| ide_lsp::CandidateFiles {files: candidates.clone(),limit_hit: false,}));let at = |line: u32, col: u32| json!({ "start": { "line": line, "character": col }, "end": { "line": line, "character": col + 3 } });- let (decl_uri, same_uri, tools_uri) = (uri_of(&decl), uri_of(&same), uri_of(&tools));+ let (decl_uri, same_uri, tools_uri, plan9_uri) = (uri_of(&decl), uri_of(&same), uri_of(&tools), uri_of(&plan9));+ let span = |line: u32, from: u32, to: u32| json!({ "start": { "line": line, "character": from }, "end": { "line": line, "character": to } });*s.responder.lock() = Some(Arc::new(move |_, method, params| {let uri = params["textDocument"]["uri"].as_str().unwrap_or_default().to_owned();let line = params["position"]["line"].as_u64().unwrap_or(0);@@ -2974,15 +2977,30 @@ fn go_modules_harness() -> (Harness, Arc<MockState>, PathBuf, PathBuf, PathBuf)Some(json!({ "uri": decl_uri, "range": at(0, 5) }))}"textDocument/definition" if uri == tools_uri => Some(json!({ "uri": tools_uri, "range": at(2, 5) })),+ "textDocument/definition" if uri == plan9_uri => Some(json!({ "uri": decl_uri, "range": at(0, 5) })),+ "textDocument/documentSymbol" if uri == tools_uri => Some(json!([+ { "name": "a", "kind": 13, "range": span(1, 0, 17), "selectionRange": span(1, 4, 5) },+ { "name": "New", "kind": 12, "range": span(2, 0, 13), "selectionRange": span(2, 5, 8) },+ ])),+ "textDocument/documentSymbol" if uri == plan9_uri => Some(json!([+ { "name": "boot", "kind": 12, "range": span(1, 0, 20), "selectionRange": span(1, 5, 9) },+ ])),+ "textDocument/prepareCallHierarchy" => Some(+ json!([{ "name": "New", "kind": 12, "uri": decl_uri, "range": span(0, 0, 13), "selectionRange": at(0, 5) }]),+ ),+ "callHierarchy/incomingCalls" => Some(json!([{+ "from": { "name": "x", "kind": 13, "uri": same_uri, "range": span(1, 0, 13), "selectionRange": span(1, 4, 5) },+ "fromRanges": [at(1, 8)],+ }])),_ => None,}}));- (h, s, decl, same, tools)+ (h, s, decl, same, tools, plan9)}#[tokio::test(flavor = "multi_thread")]async fn go_searches_resolve_other_modules_that_replace_the_declarations_module() {- let (h, s, decl, same, tools) = go_modules_harness();+ let (h, s, decl, same, tools, plan9) = go_modules_harness();let (doc, _) = h.open("a.go", "func New() {}\n");h.wait_status("gopls", ServerStatus::Ready).await;eventually(|| s.docs.lock().len() == 1).await;@@ -2998,7 +3016,7 @@ async fn go_searches_resolve_other_modules_that_replace_the_declarations_module(let mut found: Vec<(PathBuf, u32)> =refs.locations.iter().map(|l| (l.path.to_path_buf(), l.range.start.line)).collect();found.sort();- let mut want = vec![(decl.clone(), 0), (same.clone(), 1), (tools.clone(), 1)];+ let mut want = vec![(decl.clone(), 0), (same.clone(), 1), (tools.clone(), 1), (plan9.clone(), 1)];want.sort();assert_eq!(found, want);// Those in gopls' reach arrive first.@@ -3006,6 +3024,7 @@ async fn go_searches_resolve_other_modules_that_replace_the_declarations_module(// Only the module replacing the declaration's module was opened, never the root module's file.let opened = uris(&s.notified("textDocument/didOpen"));assert!(opened.contains(&uri_of(&tools)));+ assert!(opened.contains(&uri_of(&plan9)));assert!(!opened.contains(&uri_of(&same)));assert!(!opened.iter().any(|u| u.ends_with("other/o.go")));assert_eq!(s.requested("textDocument/references").len(), 1);@@ -3023,15 +3042,42 @@ async fn go_searches_resolve_other_modules_that_replace_the_declarations_module(}).collect();edited.sort();- let mut want = vec![(decl, vec![0]), (same, vec![1]), (tools, vec![1])];+ let mut want = vec![(decl, vec![0]), (same, vec![1]), (tools, vec![1]), (plan9, vec![1])];want.sort();assert_eq!(edited, want);}+#[tokio::test(flavor = "multi_thread")]+async fn go_incoming_calls_include_callers_beyond_the_search() {+ let (h, s, _, same, tools, plan9) = go_modules_harness();+ let (doc, _) = h.open("a.go", "func New() {}\n");+ h.wait_status("gopls", ServerStatus::Ready).await;+ eventually(|| s.docs.lock().len() == 1).await;++ let calls =+ h.mgr.call_hierarchy(doc, Pos::new(0, 5), HierarchyDirection::Incoming, Default::default()).await.unwrap();+ let mut callers: Vec<(PathBuf, String, Vec<u32>)> = calls+ .items+ .iter()+ .map(|i| (i.path.to_path_buf(), i.name.clone(), i.from_ranges.iter().map(|r| r.start.line).collect()))+ .collect();+ callers.sort();+ let mut want = vec![+ (same, "x".to_owned(), vec![1]),+ (tools, "a".to_owned(), vec![1]),+ (plan9.clone(), "boot".to_owned(), vec![1]),+ ];+ want.sort();+ assert_eq!(callers, want);+ let boot = calls.items.iter().find(|i| i.name == "boot").unwrap();+ assert_eq!((boot.selection_range.start, boot.from_ranges[0].start), (Pos::new(1, 5), Pos::new(1, 14)));+}+#[tokio::test(flavor = "multi_thread")]async fn go_searches_open_nothing_when_no_other_module_uses_the_declaration() {- let (h, s, _, same, _) = go_modules_harness();+ let (h, s, _, same, _, plan9) = go_modules_harness();std::fs::write(h.root.join("tools/go.mod"), "module example.com/tools\n").unwrap();+ std::fs::remove_file(&plan9).unwrap();let (doc, _) = h.open("a.go", "func New() {}\n");h.wait_status("gopls", ServerStatus::Ready).await;eventually(|| s.docs.lock().len() == 1).await;