diff --git a/crates/ide-host/src/ops/nav.rs b/crates/ide-host/src/ops/nav.rs index 02f6c9882..e2bc3541d 100644 --- a/crates/ide-host/src/ops/nav.rs +++ b/crates/ide-host/src/ops/nav.rs @@ -2,7 +2,7 @@ use super::doc::blocking; use crate::Host; use crate::Project; use crate::rpc::Dispatcher; -use ide_core::{DocId, IdeResult, IpcPath, Location, Pos}; +use ide_core::{DocId, IdeResult, IpcPath, LanguageId, Location, Pos}; use ide_index::{ExtensionCount, FileMatch, IndexStatus, SymbolFilter, SymbolMatch}; use ide_language::{FileReference, WebReference}; use ide_workspace::file_refs::{self, PathCompletion}; @@ -22,6 +22,23 @@ pub struct WebGoto { const MAX_WEB_TARGETS: usize = 200; +/// A Python class definition and the base names written in its source. The UI builds a +/// name → locations index from every class in the project (attached dependency roots +/// included) to compute ↑ overrides / ↓ overridden gutter markers without a language +/// server's type-hierarchy provider. +#[derive(Clone, Debug, Serialize, Deserialize, Type)] +#[serde(rename_all = "camelCase")] +pub struct ClassInheritance { + /// Start of the class definition's selection range (0-based line, UTF-16 column). + pub path: IpcPath, + pub line: u32, + pub col: u32, + pub name: String, + /// Base names as written in source (bare name, e.g. `AllToAllTokenDispatcher`; a + /// qualified name keeps only its last segment). + pub bases: Vec, +} + /// The project root and its resource roots (served at `/`), for file references. fn reference_roots(project: &Project) -> (PathBuf, Vec) { let resources = project.roots().resource_dirs().iter().map(|d| project.root.join(d)).collect(); @@ -174,6 +191,74 @@ pub async fn nav_index_definitions( .await } +/// Every Python class in the project (attached dependency roots included) and its base +/// names. The index covers content roots, so this is the whole-project answer the UI uses +/// for inheritance gutter markers when no type-hierarchy provider exists. +pub async fn nav_inheritance(host: &Host, window: &str) -> IdeResult> { + let project = host.project(window)?; + let syntax = host.syntax(); + blocking(move || { + let python = LanguageId::new("python"); + let files = project.index.files_with_extensions(&["py".into(), "pyi".into()], 20_000); + let mut cache = CLASS_BASES.lock(); + let mut out = Vec::new(); + for path in files { + // The open (possibly unsaved) buffer is keyed by its text, a file on disk by its + // size and modification time, so only changed files are parsed again. + let open = project.documents.text_of(&path); + let stamp = match &open { + Some(text) => Stamp::Text(text_hash(text)), + None => match std::fs::metadata(&path) { + Ok(m) => Stamp::Disk(m.len(), m.modified().ok()), + Err(_) => continue, + }, + }; + let classes = match cache.get(&path) { + Some((cached, classes)) if *cached == stamp => classes, + _ => { + let text = match open { + Some(text) => text, + None => match project.text_of(&path) { + Ok(text) => text, + Err(_) => continue, + }, + }; + let classes = syntax.class_bases(&python, &text); + &cache.entry(path.clone()).insert_entry((stamp, classes)).into_mut().1 + } + }; + out.extend(classes.iter().map(|class| ClassInheritance { + path: IpcPath::from(path.clone()), + line: class.line, + col: class.col, + name: class.name.clone(), + bases: class.bases.clone(), + })); + } + Ok(out) + }) + .await +} + +#[derive(Clone, PartialEq, Eq)] +enum Stamp { + Text(u64), + Disk(u64, Option), +} + +fn text_hash(text: &str) -> u64 { + use std::hash::{Hash, Hasher}; + let mut h = std::collections::hash_map::DefaultHasher::new(); + text.hash(&mut h); + h.finish() +} + +type ClassBasesCache = std::collections::HashMap)>; + +/// Class bases per Python file, reused while the file is unchanged. +static CLASS_BASES: std::sync::LazyLock> = + std::sync::LazyLock::new(Default::default); + /// The existing file or directory a path written in `from` names (`href`, `url()`, a string literal). pub async fn fs_resolve_reference( host: &Host, @@ -249,6 +334,7 @@ pub(crate) fn register(d: &mut Dispatcher) { d.add("nav_index_definitions", |c| async move { nav_index_definitions(&c.host, &c.window, c.arg("name")?, c.arg("from")?).await }); + d.add("nav_inheritance", |c| async move { nav_inheritance(&c.host, &c.window).await }); d.add("fs_resolve_reference", |c| async move { fs_resolve_reference(&c.host, &c.window, c.arg("from")?, c.arg("value")?).await }); diff --git a/crates/ide-host/tests/nav_inheritance.rs b/crates/ide-host/tests/nav_inheritance.rs new file mode 100644 index 000000000..d9adc6f14 --- /dev/null +++ b/crates/ide-host/tests/nav_inheritance.rs @@ -0,0 +1,141 @@ +//! The native `nav_inheritance` command: it must return every Python class definition +//! in the project — attached dependency roots included — together with the base names +//! written in its source, so the UI can compute inheritance gutter markers without a +//! language server's type-hierarchy provider. + +use ide_host::{Host, HostConfig, ops}; +use std::path::PathBuf; +use std::sync::Arc; +use std::time::{Duration, Instant}; + +const WINDOW: &str = "main"; + +struct Opened { + host: Arc, + root: PathBuf, + _tmp: tempfile::TempDir, +} + +/// Opens a synthetic project whose Python files carry known class / base shapes, then +/// waits for the index to settle (it walks content roots, so dependency roots are covered). +async fn open() -> Opened { + let tmp = tempfile::tempdir().unwrap(); + let root = dunce::canonicalize(tmp.path()).unwrap().join("proj"); + let src = root.join("src"); + let dep = root.join("vendor"); + std::fs::create_dir_all(&src).unwrap(); + std::fs::create_dir_all(&dep).unwrap(); + + // Own root: a plain class, a class with two bases + a keyword arg, a qualified base, + // and a subscripted generic base. A comment / docstring that mentions `class X(Y)` + // must not be reported. + std::fs::write( + src.join("app.py"), + concat!( + "class Base:\n", + " pass\n", + "\n", + "class Mixin:\n", + " pass\n", + "\n", + "class Child(Base, Mixin, metaclass=Meta):\n", + " # class Ghost(Spook): must be ignored\n", + " \"\"\"class Phantom(Apparition): must be ignored\"\"\"\n", + " pass\n", + "\n", + "class Qualified(pkg.mod.Base):\n", + " pass\n", + "\n", + "class Generic(Generic[T]):\n", + " pass\n", + ), + ) + .unwrap(); + // A second own-root file to prove the command scans more than one file. + std::fs::write(src.join("extra.pyi"), "class Stub(Base):\n ...\n").unwrap(); + // An attached dependency root (content root) — must be covered by the index. + std::fs::write(dep.join("dep.py"), "class DepBase:\n pass\n").unwrap(); + + let app = tmp.path().join("app"); + let host = Arc::new(Host::new(HostConfig { + config_dir: app.join("config"), + data_dir: app.join("data"), + local_data_dir: app.join("data"), + languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()), + syntax: Arc::default(), + sink_for: Box::new(|_| Arc::new(|_| {})), + owner: |w| w, + runtime: tokio::runtime::Handle::current(), + project_environment: false, + })); + host.trust.decide(&root, true, false).unwrap(); + ops::project::open(&host, WINDOW, &root).await.unwrap(); + + let deadline = Instant::now() + Duration::from_secs(30); + loop { + let s = ops::nav::index_status(&host, WINDOW).unwrap(); + if !s.indexing && s.files > 0 { + break; + } + assert!(Instant::now() < deadline, "indexing timed out; status: {s:?}"); + tokio::time::sleep(Duration::from_millis(100)).await; + } + Opened { host, root, _tmp: tmp } +} + +fn find<'a>(all: &'a [ide_host::ops::nav::ClassInheritance], name: &str) -> &'a ide_host::ops::nav::ClassInheritance { + all.iter().find(|c| c.name == name).unwrap_or_else(|| panic!("no class {name:?} in {all:#?}")) +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 4)] +async fn returns_all_python_classes_and_bases() { + let p = open().await; + let all = ops::nav::nav_inheritance(&p.host, WINDOW).await.unwrap(); + + // Both own-root Python files are scanned (src/app.py + src/extra.pyi). + let base = find(&all, "Base"); + assert!(base.path.0.ends_with("src/app.py"), "Base path: {:?}", base.path); + // The location is the class name identifier (selection-range start), i.e. after `class `. + assert_eq!(base.line, 0); + assert_eq!(base.col, 6); + assert!(base.bases.is_empty(), "a bare class has no bases: {:?}", base.bases); + + let child = find(&all, "Child"); + assert_eq!(child.line, 6); + assert_eq!(child.col, 6); + // The `metaclass=Meta` keyword argument is not a base. + assert!(child.bases.contains(&"Base".to_string()), "Child bases: {:?}", child.bases); + assert!(child.bases.contains(&"Mixin".to_string()), "Child bases: {:?}", child.bases); + assert!(!child.bases.iter().any(|b| b == "Meta"), "metaclass must be skipped: {:?}", child.bases); + + // A qualified base keeps only its last segment. + let qualified = find(&all, "Qualified"); + assert_eq!(qualified.bases, vec!["Base".to_string()], "qualified base: {:?}", qualified.bases); + + // A subscripted generic base keeps the identifier. + let generic = find(&all, "Generic"); + assert_eq!(generic.bases, vec!["Generic".to_string()], "generic base: {:?}", generic.bases); + + // Comments / docstrings are not mistaken for class definitions. + assert!(!all.iter().any(|c| c.name == "Ghost" || c.name == "Phantom"), "parsed a comment: {all:#?}"); + + // The .pyi stub in the second own-root file is included. + let stub = find(&all, "Stub"); + assert!(stub.path.0.ends_with("src/extra.pyi"), "Stub path: {:?}", stub.path); + assert_eq!(stub.bases, vec!["Base".to_string()]); + + // The attached dependency root is covered by the project index. + let dep = find(&all, "DepBase"); + assert!(dep.path.0.starts_with(&p.root), "DepBase path: {:?}", dep.path); + + // Every returned entry is a Python file. + assert!(all.iter().all(|c| { matches!(c.path.0.extension().and_then(|e| e.to_str()), Some("py" | "pyi")) })); + + // A file changed on disk is parsed again; the others come from the cache. + let extra = p.root.join("src/extra.pyi"); + std::fs::write(&extra, "class Stub(Child): ...\nclass Added(Base): ...\n").unwrap(); + let again = ops::nav::nav_inheritance(&p.host, WINDOW).await.unwrap(); + assert_eq!(find(&again, "Stub").bases, vec!["Child".to_string()]); + assert_eq!(find(&again, "Added").bases, vec!["Base".to_string()]); + assert_eq!(find(&again, "Child").bases, child.bases); +} diff --git a/crates/ide-language/src/lib.rs b/crates/ide-language/src/lib.rs index a06522afc..90e70c64d 100644 --- a/crates/ide-language/src/lib.rs +++ b/crates/ide-language/src/lib.rs @@ -22,11 +22,11 @@ pub use markers::{arduino_sketch_root, is_arduino_sketch_dir, marked_root}; pub use plugin_point::PluginLanguages; pub use registry::{FileTypes, LanguageRegistry}; pub use syntax::{ - CSS_CLASS, CSS_ID, CSS_VARIABLE, ConfigurationKey, ExternalFold, ExternalSymbol, ExternalSyntax, ExternalToken, - FileReference, Literal, LiteralKind, MAX_CACHED_TREES, MAX_PARSE_BYTES, ParsedTree, SpellingKind, SpellingRegion, - Syntax, SyntaxCache, SyntaxCacheStats, SyntaxHighlightKind, SyntaxHighlights, TreeError, VueComponentImport, - VueRefAccess, VueRefElement, WebReference, WebReferenceKind, merge_visibility, set_external_syntax, shift_pos, - shift_range, + CSS_CLASS, CSS_ID, CSS_VARIABLE, ClassBases, ConfigurationKey, ExternalFold, ExternalSymbol, ExternalSyntax, + ExternalToken, FileReference, Literal, LiteralKind, MAX_CACHED_TREES, MAX_PARSE_BYTES, ParsedTree, SpellingKind, + SpellingRegion, Syntax, SyntaxCache, SyntaxCacheStats, SyntaxHighlightKind, SyntaxHighlights, TreeError, + VueComponentImport, VueRefAccess, VueRefElement, WebReference, WebReferenceKind, merge_visibility, + set_external_syntax, shift_pos, shift_range, }; /// Parsed form of `languages/.toml`. Backend-only; the UI gets [`LanguageInfo`]. diff --git a/crates/ide-language/src/syntax/inheritance.rs b/crates/ide-language/src/syntax/inheritance.rs new file mode 100644 index 000000000..849094ec0 --- /dev/null +++ b/crates/ide-language/src/syntax/inheritance.rs @@ -0,0 +1,171 @@ +//! Extraction of Python class base names, used to build an inheritance graph +//! without an LSP `typeHierarchyProvider`. + +use super::lines::LineIndex; +use crate::{LanguageId, Syntax}; +use tree_sitter::{Node, Tree}; + +/// A Python class definition and the base names written in its source. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct ClassBases { + /// The class name (bare identifier). + pub name: String, + /// 0-based line of the class name (selection-range start). + pub line: u32, + /// 0-based UTF-16 column of the class name (selection-range start). + pub col: u32, + /// Source-written base names (last segment of a qualified name). + pub bases: Vec, +} + +impl Syntax { + /// Class definitions of `text` with their base names, in source order. + /// Only Python is supported; every other language returns an empty vector. + pub fn class_bases(&self, lang: &LanguageId, text: &str) -> Vec { + self.analyze(lang, text, |g, tree, text| (g.spec.name == "python").then(|| extract(tree, text))) + .unwrap_or_default() + } +} + +fn extract(tree: &Tree, text: &str) -> Vec { + let idx = LineIndex::new(text); + let mut out = Vec::new(); + let mut cursor = tree.walk(); + visit(&mut cursor, &mut |node| { + if node.kind() != "class_definition" { + return; + } + let Some(name_node) = node.child_by_field_name("name") else { return }; + let name = text.get(name_node.byte_range()).unwrap_or_default().to_owned(); + if name.is_empty() { + return; + } + // Selection-range start of the class: its name identifier (`class Foo` + // -> `Foo`), matching `outline.rs` and the gutter marker candidates. + let range = idx.range(name_node.start_byte(), name_node.end_byte()); + let bases = node.child_by_field_name("superclasses").map(|args| base_names(args, text)).unwrap_or_default(); + out.push(ClassBases { name, line: range.start.line, col: range.start.col, bases }); + }); + out +} + +/// Depth-first pre-order traversal of all descendants of `cursor`'s node. +fn visit(cursor: &mut tree_sitter::TreeCursor, f: &mut impl FnMut(Node)) { + loop { + f(cursor.node()); + if cursor.goto_first_child() { + continue; + } + loop { + if cursor.goto_next_sibling() { + break; + } + if !cursor.goto_parent() { + return; + } + } + } +} + +fn base_names(args: Node, text: &str) -> Vec { + let mut out = Vec::new(); + let mut cursor = args.walk(); + for arg in args.named_children(&mut cursor) { + if let Some(name) = base_name(arg, text) { + out.push(name); + } + } + out +} + +/// Bare name of one base expression, or `None` for keyword arguments and +/// expressions that are not a (possibly qualified) name. +fn base_name(arg: Node, text: &str) -> Option { + match arg.kind() { + "identifier" => text.get(arg.byte_range()).map(str::to_owned), + // `pkg.mod.Base` -> `Base`. + "attribute" => { + let attr = arg.child_by_field_name("attribute")?; + (attr.kind() == "identifier").then(|| text.get(attr.byte_range()).unwrap_or_default().to_owned()) + } + // `Generic[T]` -> `Generic`. + "subscript" => { + let value = arg.child_by_field_name("value")?; + (value.kind() == "identifier").then(|| text.get(value.byte_range()).unwrap_or_default().to_owned()) + } + // `metaclass=Meta`, `**kwargs`, `*bases` and other expressions. + _ => None, + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn bases(src: &str) -> Vec { + static S: std::sync::OnceLock = std::sync::OnceLock::new(); + S.get_or_init(Syntax::new).class_bases(&LanguageId::new("python"), src) + } + + fn shape(src: &str) -> Vec<(String, u32, u32, Vec)> { + bases(src).into_iter().map(|c| (c.name, c.line, c.col, c.bases)).collect() + } + + #[test] + fn no_bases() { + assert_eq!(shape("class A: pass"), vec![("A".to_owned(), 0, 6, vec![])]); + } + + #[test] + fn multiple_bases_skips_metaclass() { + assert_eq!( + shape("class B(A, C, metaclass=Meta): pass"), + vec![("B".to_owned(), 0, 6, vec!["A".to_owned(), "C".to_owned()])] + ); + } + + #[test] + fn qualified_name_takes_last_segment() { + assert_eq!(shape("class D(pkg.mod.Base): pass"), vec![("D".to_owned(), 0, 6, vec!["Base".to_owned()])]); + } + + #[test] + fn subscript_takes_value() { + assert_eq!(shape("class E(Generic[T]): pass"), vec![("E".to_owned(), 0, 6, vec!["Generic".to_owned()])]); + } + + #[test] + fn multiline_bases() { + let src = "class F(\n A,\n B,\n):\n pass"; + assert_eq!(shape(src), vec![("F".to_owned(), 0, 6, vec!["A".to_owned(), "B".to_owned()])]); + } + + #[test] + fn nested_classes() { + let src = "class Outer:\n class Inner(Y):\n pass"; + assert_eq!( + shape(src), + vec![("Outer".to_owned(), 0, 6, vec![]), ("Inner".to_owned(), 1, 10, vec!["Y".to_owned()]),] + ); + } + + #[test] + fn comments_and_strings_are_ignored() { + let src = r#" +# class Fake(Nope): pass +doc = """ +class InDocstring(X): pass +""" +s = 'class InString(Y): pass' +class Real(Base): pass +"#; + assert_eq!(shape(src), vec![("Real".to_owned(), 6, 6, vec!["Base".to_owned()])]); + } + + #[test] + fn other_languages_are_empty() { + static S: std::sync::OnceLock = std::sync::OnceLock::new(); + let s = S.get_or_init(Syntax::new); + assert!(s.class_bases(&LanguageId::new("rust"), "struct A;").is_empty()); + } +} diff --git a/crates/ide-language/src/syntax/mod.rs b/crates/ide-language/src/syntax/mod.rs index 2ef95bb11..ff0bccac2 100644 --- a/crates/ide-language/src/syntax/mod.rs +++ b/crates/ide-language/src/syntax/mod.rs @@ -6,6 +6,7 @@ mod external; mod folding; mod grammars; mod highlight; +mod inheritance; pub(crate) mod lines; mod literals; mod outline; @@ -22,6 +23,7 @@ pub use external::{ExternalFold, ExternalSymbol, ExternalSyntax, ExternalToken, use grammars::{SPECS, Spec}; pub use highlight::{SyntaxHighlightKind, SyntaxHighlights}; use ide_core::{LanguageId, OutlineItem, Pos, Range}; +pub use inheritance::ClassBases; pub use lines::{shift_pos, shift_range}; pub use literals::{Literal, LiteralKind, SpellingKind, SpellingRegion}; pub use outline::merge_visibility; diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs index 7cceb1f1a..7c5297e38 100644 --- a/src-tauri/src/commands/mod.rs +++ b/src-tauri/src/commands/mod.rs @@ -248,6 +248,7 @@ pub fn builder() -> tauri_specta::Builder { nav::web_goto, nav::nav_resolve_module, nav::nav_index_definitions, + nav::nav_inheritance, nav::fs_resolve_reference, nav::path_completions, nav::web_unresolved_references, diff --git a/src-tauri/src/commands/nav.rs b/src-tauri/src/commands/nav.rs index 68478efeb..e2351164c 100644 --- a/src-tauri/src/commands/nav.rs +++ b/src-tauri/src/commands/nav.rs @@ -115,6 +115,14 @@ pub async fn nav_index_definitions( ide_host::ops::nav::nav_index_definitions(&state.host, window.label(), name, from).await } +/// Every Python class in the project (attached dependency roots included) and its base names, +/// for native inheritance gutter markers. +#[tauri::command] +#[specta::specta] +pub async fn nav_inheritance(window: Window, state: State<'_, AppState>) -> IdeResult> { + ide_host::ops::nav::nav_inheritance(&state.host, window.label()).await +} + /// The existing file or directory a path written in `from` names (`href`, `url()`, a string literal). #[tauri::command] #[specta::specta] diff --git a/src/bindings.ts b/src/bindings.ts index 2c153bb9b..602159c61 100644 --- a/src/bindings.ts +++ b/src/bindings.ts @@ -475,6 +475,11 @@ export const commands = { * plus its configured dependencies). */ navIndexDefinitions: (name: string, from: IpcPath) => typedError(__TAURI_INVOKE("nav_index_definitions", { name, from })), + /** + * Every Python class in the project (attached dependency roots included) and its base names, + * for native inheritance gutter markers. + */ + navInheritance: () => typedError(__TAURI_INVOKE("nav_inheritance")), /** The existing file or directory a path written in `from` names (`href`, `url()`, a string literal). */ fsResolveReference: (from: IpcPath, value: string) => typedError(__TAURI_INVOKE("fs_resolve_reference", { from, value })), /** Files and folders that continue `prefix`, a path being typed in `from`. */ @@ -2889,6 +2894,25 @@ export type ChoiceOption = { label: string, }; +/** + * A Python class definition and the base names written in its source. The UI builds a + * name → locations index from every class in the project (attached dependency roots + * included) to compute ↑ overrides / ↓ overridden gutter markers without a language + * server's type-hierarchy provider. + */ +export type ClassInheritance = { + /** Start of the class definition's selection range (0-based line, UTF-16 column). */ + path: IpcPath, + line: number, + col: number, + name: string, + /** + * Base names as written in source (bare name, e.g. `AllToAllTokenDispatcher`; a + * qualified name keeps only its last segment). + */ + bases: string[], +}; + export type ClassifiedReference = { /** Optional for older Java extensions; missing means unclassified. */ access?: ReferenceAccess | null, diff --git a/src/editor/navigation/implementationGutter.ts b/src/editor/navigation/implementationGutter.ts index 2d7d6bcd1..27e1f8242 100644 --- a/src/editor/navigation/implementationGutter.ts +++ b/src/editor/navigation/implementationGutter.ts @@ -27,12 +27,14 @@ import { isCancelled, nextRequestId, onIdeEvent, + type ClassInheritance, type HierarchyItem, type Location, type OutlineItem, type Pos, type RequestId, } from "@/platform/ipc"; +import { tx } from "@/platform/i18n"; import { editorPrefs, type EditorExtras } from "@/platform/editorSettings"; import { useProject } from "@/platform/project"; import { gutterIconMarkup } from "@/ui"; @@ -48,7 +50,7 @@ import { type MarkerCandidate, type MarkerGroup, } from "./lineMarkers"; -import { overridersInType, superMethodTargets, type SuperDeps, type SuperMethod } from "./structureNav"; +import { baseName, overridersInType, superMethodTargets, type SuperDeps, type SuperMethod } from "./structureNav"; import styles from "./LineMarkers.module.css"; /** Lines above / below the viewport that are asked with it. */ @@ -85,16 +87,49 @@ export function affectsMarkers(paths: readonly string[]): boolean { return paths.some((p) => !OUTPUT_PATH.test(p)); } +/** + * The Python inheritance graph of the open project, shared by every document and kept + * across edits: it is a whole-project index answer, not a per-document one, so scanning + * it again for each edit would walk every Python file again. Dropped when other files + * change or a server settles (the index may have moved on). + */ +let inheritanceGraphCache: { root: string; promise: Promise } | null = null; + +/** The project whose graph is cached; `""` for no project (a loose file). */ +function projectRoot(): string { + return useProject.getState().project?.root ?? ""; +} + +/** Forgets the cached graph (files changed, a server settled, or tests). */ +export function forgetInheritanceGraph() { + inheritanceGraphCache = null; +} + +function inheritanceGraph(): Promise { + const root = projectRoot(); + if (!inheritanceGraphCache || inheritanceGraphCache.root !== root) { + inheritanceGraphCache = { root, promise: lspRequest(() => commands.navInheritance()) }; + // A failed request must not stick: the next pass retries it. + inheritanceGraphCache.promise.catch(() => { + if (inheritanceGraphCache?.root === root) inheritanceGraphCache = null; + }); + } + return inheritanceGraphCache.promise; +} + /** Subscribes once per window and stays subscribed, so the settle echo guard survives remounts. */ function watchChanges() { if (watching) return; watching = true; onIdeEvent("fsChanged", (e) => { - if (affectsMarkers([...e.created, ...e.modified, ...e.removed])) changes++; + if (!affectsMarkers([...e.created, ...e.modified, ...e.removed])) return; + changes++; + forgetInheritanceGraph(); }); // Answers (outlines too) given while a server was starting or indexing may be incomplete. onServerSettled(() => { docMarkers.clear(); + forgetInheritanceGraph(); for (const plugin of live) plugin.refreshSoon(); }); } @@ -131,6 +166,13 @@ export interface MarkerDeps { implementations: (positions: Pos[]) => Promise; supers: SuperDeps; readFiles: (paths: readonly string[]) => Promise>; + /** + * Every Python class of the project and its base names (the IDE index, attached + * dependency roots included). Some servers (basedpyright, pyrefly) answer no + * `typeHierarchyProvider`, so ↑/↓ are computed from this graph instead. + * Absent for languages whose servers do provide one (Java, Go, ...). + */ + inheritance?: () => Promise; } interface CacheEntry { @@ -142,6 +184,8 @@ interface CacheEntry { export interface MarkerCache { entries: Map; unsupported: Set; + /** The Python inheritance graph for this document version, fetched once per cache. */ + inheritance?: Promise; } export const emptyCache = (): MarkerCache => ({ entries: new Map(), unsupported: new Set() }); @@ -164,11 +208,16 @@ export async function fillMarkers( if (!e) cache.entries.set(key, (e = {})); return e; }; + // A Python inheritance graph answers both groups even when the language server + // has no type hierarchy: it must keep the candidates alive through the LSP + // "unsupported" bookkeeping, or the fallback would never get to run. + const graph = deps.inheritance ? await (cache.inheritance ??= deps.inheritance().catch(() => null)) : null; + const fallback = (graph?.length ?? 0) > 0; const down = - groups.has("inheritors") && !cache.unsupported.has("inheritors") + groups.has("inheritors") && (fallback || !cache.unsupported.has("inheritors")) ? candidates.filter((c) => c.inheritable && cache.entries.get(candidateKey(c))?.inheritors === undefined) : []; - const askSupers = groups.has("supers") && !cache.unsupported.has("supers"); + const askSupers = groups.has("supers") && (fallback || !cache.unsupported.has("supers")); const up = askSupers ? candidates.filter((c) => c.overriding && c.owner && cache.entries.get(candidateKey(c))?.supers === undefined) : []; @@ -186,8 +235,11 @@ export async function fillMarkers( asked = await deps.implementations(ask.map((c) => ({ line: c.line, col: c.col }))); } catch (e) { if (isCancelled(e)) throw e; - if (isUnavailable(e)) cache.unsupported.add("inheritors"); - for (let i = down.length - 1; i >= 0; i--) if (!known.has(down[i]!)) down.splice(i, 1); + // With a fallback the candidates stay: the graph may still answer them. + if (!fallback) { + if (isUnavailable(e)) cache.unsupported.add("inheritors"); + for (let i = down.length - 1; i >= 0; i--) if (!known.has(down[i]!)) down.splice(i, 1); + } } } implementations = down.map((c) => withoutSelf(path, c, known.get(c) ?? asked[ask.indexOf(c)] ?? [])); @@ -208,8 +260,79 @@ export async function fillMarkers( }), ); } + // Python without a type-hierarchy provider: the IDE's inheritance graph holds every + // `class X(A)` of the project, so ↑/↓ are computed from it instead. + const byName = new Map(); + if (graph) for (const cls of graph) byName.set(cls.name, [...(byName.get(cls.name) ?? []), cls]); + // The inheritance graph's direct subclasses, keyed by the *declaration* each base + // resolves to (path + position), so classes sharing a bare name never mix up. + const subclassesOf = new Map(); + for (const cls of graph ?? []) { + for (const base of new Set(cls.bases)) { + for (const decl of resolveBase(byName, base, cls.path)) { + const key = declarationKey(decl); + subclassesOf.set(key, [...(subclassesOf.get(key) ?? []), cls]); + } + } + } + const classOf = (c: MarkerCandidate): ClassInheritance | null => { + // A class candidate is its own declaration; a method's is the `owner` it records. + const at = c.method ? c.owner : { line: c.line, col: c.col }; + if (!at) return null; + const cls = candidates.find((k) => !k.method && k.line === at.line && k.col === at.col) ?? (c.method ? null : c); + if (!cls) return null; + return byName.get(cls.name)?.find((x) => x.path === path && x.line === cls.line && x.col === cls.col) ?? null; + }; + /** The declarations a subclass overrides: the subclass itself, or its same-named method. */ + const subclassDeclarations = async (c: MarkerCandidate, owner: ClassInheritance): Promise => { + const subs = subclassesOf.get(declarationKey(owner)) ?? []; + if (!c.method) return subs.map(classLocation); + const bare = c.symbol.replace(/\s*[(<].*$/, ""); + const targets: Location[] = []; + for (const sub of subs) { + const outline = await deps.supers.outline(sub.path).catch(() => [] as OutlineItem[]); + const m = methodInOutline(outline, sub, bare); + if (m) targets.push({ path: sub.path, range: m.selection_range }); + } + return targets; + }; + if (byName.size) { + for (let i = 0; i < down.length; i++) { + const c = down[i]!; + const owner = classOf(c); + if (!owner) continue; + // Merge, never replace: a server that answers sees one root, so its list can miss + // the subclasses living in an attached project while still being non-empty. + implementations[i] = withoutSelf( + path, + c, + mergeLocations(implementations[i] ?? [], await subclassDeclarations(c, owner)), + ); + } + } const supers: SuperMethod[][] = []; for (const c of up) supers.push(await superMethodTargets(path, c.owner!, c.symbol, deps.supers)); + if (byName.size) { + for (let i = 0; i < up.length; i++) { + const c = up[i]!; + const self = classOf(c); + if (!self) continue; + const found = await superMethodsFrom(byName, self.name, c.symbol, deps); + if (!found.length) continue; + const known = supers[i]!; + // Same merge rule as ↓: add the graph's super methods to what the server answered. + const extra = found.map((f) => f.location).filter((l) => !known.some((s) => sameLocation(s.location, l))); + const owners = [...new Set(found.map((f) => f.owner))].sort((a, b) => a.localeCompare(b)); + entry(c).supers = { + kind: "overriding", + line: c.line, + name: c.name, + targets: [...known.map((s) => s.location), ...extra], + tooltip: tx`Overrides method in ${owners.join(", ")}`, + chooserTitle: tx`Choose Super Method of ${c.name} (${known.length + extra.length} found)`, + }; + } + } // Go: an implementation request on a type or method answers the interfaces it satisfies. let satisfied: Location[][] = []; if (implicit.length) { @@ -228,10 +351,103 @@ export async function fillMarkers( ...satisfied.flat().map((l) => l.path), ]); down.forEach((c, i) => (entry(c).inheritors = inheritorsMarker(c, implementations[i] ?? [], files))); - up.forEach((c, i) => (entry(c).supers = supersMarker(c, supers[i]!, files))); + // A candidate the graph answered already has its marker: don't null it out here. + up.forEach((c, i) => { + if (supers[i]!.length) entry(c).supers = supersMarker(c, supers[i]!, files); + }); implicit.forEach((c, i) => (entry(c).supers = implementsMarker(c, withoutSelf(path, c, satisfied[i] ?? []), files))); } +// One entry per declaration line: the server and the graph may point at the same +// declaration with different columns (the name vs the whole statement). +const sameLocation = (a: Location, b: Location) => a.path === b.path && a.range.start.line === b.range.start.line; + +/** `first`, then the locations of `more` not already in it. */ +function mergeLocations(first: readonly Location[], more: readonly Location[]): Location[] { + return [...first, ...more.filter((l) => !first.some((f) => sameLocation(f, l)))]; +} + +/** Identifies one class declaration in the inheritance graph. */ +function declarationKey(cls: ClassInheritance): string { + return `${cls.path}:${cls.line}:${cls.col}`; +} + +/** + * The classes a base name names. A bare name is only trusted when it is unique in the + * project, or names a class in the subclass's own file: a `Config` declared in hundreds + * of modules must not make every one of them a subclass of every other. + */ +function resolveBase(byName: ReadonlyMap, name: string, from: string): ClassInheritance[] { + const found = byName.get(name) ?? []; + if (found.length <= 1) return found; + return found.filter((c) => c.path === from); +} + +/** The class declaration itself as a navigation target (its name identifier). */ +function classLocation(cls: ClassInheritance): Location { + const start = { line: cls.line, col: cls.col }; + return { path: cls.path, range: { start, end: start } }; +} + +/** The method `method` (bare name) directly inside the class at `cls`'s position. */ +function methodInOutline(outline: readonly OutlineItem[], cls: ClassInheritance, method: string): OutlineItem | null { + const at = cls; + const find = (items: readonly OutlineItem[]): OutlineItem | null => { + for (const it of items) { + if (it.kind === "class" && it.selection_range.start.line === at.line && it.selection_range.start.col === at.col) { + return it.children.find((ch) => ch.kind === "method" && baseName(ch.name) === method) ?? null; + } + const deeper = find(it.children); + if (deeper) return deeper; + } + return null; + }; + return find(outline); +} + +/** + * Super methods of `method` declared by a class in `byName`, walking the inheritance + * graph's bases up to a few levels. Empty when no base declares the method. + */ +async function superMethodsFrom( + byName: ReadonlyMap, + start: string, + method: string, + deps: MarkerDeps, + depth = 3, +): Promise<{ location: Location; owner: string }[]> { + const bare = method.replace(/\s*[(<].*$/, ""); + const seen = new Set([start]); + let level = [start]; + for (let d = 0; d < depth && level.length; d++) { + const next: string[] = []; + const found: { location: Location; owner: string }[] = []; + for (const name of level) { + for (const cls of byName.get(name) ?? []) { + for (const base of cls.bases) { + if (!seen.add(base)) continue; + // Same rule as the graph: only a base that names one class is followed. + const declarations = resolveBase(byName, base, cls.path); + let answered = false; + for (const baseCls of declarations) { + const outline = await deps.supers.outline(baseCls.path).catch(() => [] as OutlineItem[]); + const m = methodInOutline(outline, baseCls, bare); + if (m) { + found.push({ location: { path: baseCls.path, range: m.selection_range }, owner: base }); + answered = true; + } + } + // Not found in a base that declares nothing: keep walking its own bases. + if (!answered) next.push(base); + } + } + } + if (found.length) return found; + level = next; + } + return []; +} + /** * Overriders of a type's methods from one walk of its subtypes and their outlines, instead of one * implementation request per method: jdtls builds the type hierarchy again for every implementation @@ -575,6 +791,9 @@ function markerDeps(ctx: EditorDocContext, items: OutlineItem[], request: Reques }, }, readFiles: readManyFileLines, + // Python servers answer no type hierarchy (basedpyright, pyrefly): the IDE's + // own index knows every `class X(Base)` of the project, attached roots included. + inheritance: ctx.language === "python" ? inheritanceGraph : undefined, }; } diff --git a/src/editor/navigation/lineMarkers.test.ts b/src/editor/navigation/lineMarkers.test.ts index 7ad4ea342..3b0d3b9d3 100644 --- a/src/editor/navigation/lineMarkers.test.ts +++ b/src/editor/navigation/lineMarkers.test.ts @@ -1,6 +1,7 @@ import { beforeEach, describe, expect, it, vi } from "vitest"; import { IpcError, + type ClassInheritance, type HierarchyItem, type Location, type OutlineItem, @@ -208,8 +209,9 @@ function server( impls: Record, supers: Record, subtypes: Record = {}, + inheritance?: ClassInheritance[], ) { - const calls = { implementations: [] as Pos[][], supertypes: 0, subtypes: 0 }; + const calls = { implementations: [] as Pos[][], supertypes: 0, subtypes: 0, inheritance: 0 }; const outlines: Record = { [SHAPE_PATH]: SHAPE_OUTLINE, "/p/Circle.java": CIRCLE_OUTLINE, @@ -234,6 +236,35 @@ function server( outline: async (p) => outlines[p] ?? [], }, readFiles: async (paths) => new Map(paths.map((p) => [p, FILES[p] ?? null])), + inheritance: inheritance + ? async () => { + calls.inheritance++; + return inheritance; + } + : undefined, + }); + return { calls, deps }; +} + +/** A Python project: the server answers neither implementations nor a type hierarchy. */ +function pythonServer(inheritance: ClassInheritance[], outlines: Record) { + const calls = { implementations: 0, inheritance: 0 }; + const deps = (): MarkerDeps => ({ + implementations: async () => { + calls.implementations++; + throw new IpcError({ kind: "unavailable", message: "basedpyright doesn't support implementation" }); + }, + supers: { + supertypes: async () => { + throw new IpcError({ kind: "unavailable", message: "basedpyright doesn't support type hierarchy" }); + }, + outline: async (p) => outlines[p] ?? [], + }, + readFiles: async () => new Map(), + inheritance: async () => { + calls.inheritance++; + return inheritance; + }, }); return { calls, deps }; } @@ -637,3 +668,98 @@ describe("overriders of a type's methods from its subtypes", () => { ]); }); }); + +describe("python inheritance fallback", () => { + // a.py: `class A` (line 0) with `m` (line 1), then `class B(A)` (line 3) with `m` (line 4). + const outline = [ + item("A", "class", 0, 2, [item("m", "method", 1, 1)], 6), + item("B", "class", 3, 5, [item("m", "method", 4, 4)], 6), + ]; + const graph: ClassInheritance[] = [ + { path: "/p/a.py", line: 0, col: 6, name: "A", bases: [] }, + { path: "/p/a.py", line: 3, col: 6, name: "B", bases: ["A"] }, + ]; + + it("marks the subclass and the overridden method with no type hierarchy", async () => { + const { deps, calls } = pythonServer(graph, { "/p/a.py": outline }); + const candidates = markerCandidates(outline, () => ""); + const cache = emptyCache(); + await fillMarkers("/p/a.py", candidates, ALL, deps(), cache); + const markers = cachedMarkers(candidates, ALL, cache).map((m) => [m.line, m.kind, m.targets.map((t) => t.path)]); + expect(markers).toEqual([ + // The class B subclasses A... + [0, "overridden", ["/p/a.py"]], + // ...and its `m` overrides A's `m`. + [1, "overridden", ["/p/a.py"]], + [4, "overriding", ["/p/a.py"]], + ]); + // The graph is asked once per cache, not once per candidate. + expect(calls.inheritance).toBe(1); + }); + + it("survives an unavailable implementation provider (the fallback keeps its candidates)", async () => { + const { deps, calls } = pythonServer(graph, { "/p/a.py": outline }); + const candidates = markerCandidates(outline, () => ""); + const cache = emptyCache(); + await fillMarkers("/p/a.py", candidates, ALL, deps(), cache); + // The server said "unavailable", but the graph still answered ↓ and ↑. + expect(calls.implementations).toBeGreaterThan(0); + expect(cache.unsupported.size).toBe(0); + }); + + it("adds the graph's cross-project subclasses to a non-empty server answer", async () => { + // The server (single root) answers the local subclass only; the attached-project + // subclass is known to the IDE's graph and must join the list. + const outline = [item("A", "class", 0, 2, [], 6), item("B", "class", 3, 5, [], 6)]; + const graph: ClassInheritance[] = [ + { path: "/p/a.py", line: 0, col: 6, name: "A", bases: [] }, + { path: "/p/a.py", line: 3, col: 6, name: "B", bases: ["A"] }, + { path: "/p/attached/a.py", line: 0, col: 6, name: "C", bases: ["A"] }, + ]; + const { deps } = server({ "/p/a.py:0": [loc("/p/a.py", 3)] }, {}, {}, graph); + const candidates = markerCandidates(outline, () => ""); + const cache = emptyCache(); + await fillMarkers("/p/a.py", candidates, ALL, deps("/p/a.py"), cache); + const targets = cachedMarkers(candidates, ALL, cache) + .filter((m) => m.line === 0) + .flatMap((m) => m.targets.map((t) => t.path)); + expect(targets).toEqual(["/p/a.py", "/p/attached/a.py"]); + }); + + it("ignores a bare base name that many classes in the project share", async () => { + // `Config` is declared in hundreds of modules: no edge, so no marker. + const outline = [item("Child", "class", 0, 2, [], 6)]; + const graph: ClassInheritance[] = [ + { path: "/p/a.py", line: 0, col: 6, name: "Config", bases: [] }, + { path: "/p/b.py", line: 0, col: 6, name: "Config", bases: [] }, + { path: "/p/c.py", line: 0, col: 6, name: "Child", bases: ["Config"] }, + ]; + const { deps } = pythonServer(graph, { "/p/c.py": outline }); + const candidates = markerCandidates(outline, () => ""); + const cache = emptyCache(); + await fillMarkers("/p/c.py", candidates, ALL, deps(), cache); + expect(cachedMarkers(candidates, ALL, cache)).toEqual([]); + }); + + it("trusts a shared base name when the subclass's own file declares it", async () => { + const outline = [item("Config", "class", 0, 1, [], 6), item("Child", "class", 3, 5, [], 6)]; + const graph: ClassInheritance[] = [ + { path: "/p/c.py", line: 0, col: 6, name: "Config", bases: [] }, + { path: "/p/other.py", line: 0, col: 6, name: "Config", bases: [] }, + { path: "/p/c.py", line: 3, col: 6, name: "Child", bases: ["Config"] }, + ]; + const { deps } = pythonServer(graph, { "/p/c.py": outline }); + const candidates = markerCandidates(outline, () => ""); + const cache = emptyCache(); + await fillMarkers("/p/c.py", candidates, ALL, deps(), cache); + expect(cachedMarkers(candidates, ALL, cache).map((m) => [m.line, m.kind])).toEqual([[0, "overridden"]]); + }); + + it("keeps the existing server path when no inheritance graph is injected", async () => { + const { deps } = server({}, {}); + const candidates = markerCandidates([item("Foo", "class", 0, 2, [item("m", "method", 1, 1)], 6)], () => ""); + const cache = emptyCache(); + await fillMarkers("/p/a.py", candidates, ALL, deps("/p/a.py"), cache); + expect(cachedMarkers(candidates, ALL, cache)).toEqual([]); + }); +});