M2.5: symbol index and go-to commands
crates/index: walks the project with the search/VFS rules (vendor as library), parses .php files from tree-sitter outlines on a worker pool off the engine lock, updates incrementally from disk and buffers through an updater thread, caps at 200,000 files, and answers fuzzy file, class and symbol queries (nucleo-matcher, MPL-2.0 as a separate crate). Engine: index.status, goto.file, goto.class, goto.symbol; events indexProgress and indexReady drained by the pump; the index starts on project.open and is cancelled on close. Tests: unit, incremental, property (random queries and sources), engine and TCP control tests, release timing on a generated 20k-file project (3.9-4.2 s). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
parent
f13a49064d
commit
053441d066
26 changed files with 3455 additions and 9 deletions
313
crates/index/src/symbol.rs
Normal file
313
crates/index/src/symbol.rs
Normal file
|
|
@ -0,0 +1,313 @@
|
|||
//! Symbols and indexed files, extracted from tree-sitter outlines.
|
||||
|
||||
use lutra_syntax::{OutlineItem, OutlineKind, Parser};
|
||||
|
||||
use crate::{MAX_PARSE_BYTES, MAX_SYMBOLS_PER_FILE};
|
||||
|
||||
/// What a symbol declares.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
||||
pub enum SymbolKind {
|
||||
/// A class.
|
||||
Class,
|
||||
/// An interface.
|
||||
Interface,
|
||||
/// A trait.
|
||||
Trait,
|
||||
/// An enum.
|
||||
Enum,
|
||||
/// A function outside a class.
|
||||
Function,
|
||||
/// A method.
|
||||
Method,
|
||||
/// A property, declared or constructor-promoted.
|
||||
Property,
|
||||
/// A class constant or a `const` outside a class.
|
||||
Constant,
|
||||
/// A `case` of an enum.
|
||||
EnumCase,
|
||||
}
|
||||
|
||||
impl SymbolKind {
|
||||
/// The kind's name as the engine and the UI use it, the same as the
|
||||
/// outline's: `class`, `interface`, `trait`, `enum`, `function`,
|
||||
/// `method`, `property`, `constant` or `enumCase`.
|
||||
pub fn as_str(self) -> &'static str {
|
||||
match self {
|
||||
Self::Class => "class",
|
||||
Self::Interface => "interface",
|
||||
Self::Trait => "trait",
|
||||
Self::Enum => "enum",
|
||||
Self::Function => "function",
|
||||
Self::Method => "method",
|
||||
Self::Property => "property",
|
||||
Self::Constant => "constant",
|
||||
Self::EnumCase => "enumCase",
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether the kind is a class, interface, trait or enum (Go to Class);
|
||||
/// the others are found by Go to Symbol.
|
||||
pub fn is_class_like(self) -> bool {
|
||||
matches!(
|
||||
self,
|
||||
Self::Class | Self::Interface | Self::Trait | Self::Enum
|
||||
)
|
||||
}
|
||||
|
||||
/// The symbol kind of an outline kind; `None` for a namespace.
|
||||
fn from_outline(kind: OutlineKind) -> Option<Self> {
|
||||
Some(match kind {
|
||||
OutlineKind::Namespace => return None,
|
||||
OutlineKind::Class => Self::Class,
|
||||
OutlineKind::Interface => Self::Interface,
|
||||
OutlineKind::Trait => Self::Trait,
|
||||
OutlineKind::Enum => Self::Enum,
|
||||
OutlineKind::Function => Self::Function,
|
||||
OutlineKind::Method => Self::Method,
|
||||
OutlineKind::Property => Self::Property,
|
||||
OutlineKind::Constant => Self::Constant,
|
||||
OutlineKind::EnumCase => Self::EnumCase,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// One declaration.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
|
||||
pub struct Symbol {
|
||||
/// The name as written: `Product`, `find`, `$id` (properties keep the
|
||||
/// `$`), `MAX`.
|
||||
pub name: String,
|
||||
/// The fully qualified name without a leading `\`: `App\Models\Product`
|
||||
/// for a class or function, `App\Models\Product::find` for a member.
|
||||
pub fqn: String,
|
||||
/// What it declares.
|
||||
pub kind: SymbolKind,
|
||||
/// The FQN of the class, interface, trait or enum that declares a
|
||||
/// member; `None` for classes, functions and constants outside a class.
|
||||
pub container: Option<String>,
|
||||
/// 0-based line of the name.
|
||||
pub line: usize,
|
||||
/// Column of the name in UTF-16 code units.
|
||||
pub column: usize,
|
||||
}
|
||||
|
||||
/// A file in the index.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Default)]
|
||||
pub struct IndexedFile {
|
||||
/// Project-relative path with `/` separators.
|
||||
pub path: String,
|
||||
/// Library code: the file is below the root's `vendor/`.
|
||||
pub library: bool,
|
||||
/// Declarations in source order; empty for files that are not parsed.
|
||||
pub symbols: Vec<Symbol>,
|
||||
}
|
||||
|
||||
/// Whether the project-relative `path` is library code (the root's
|
||||
/// `vendor/` or anything below it).
|
||||
pub fn is_library(path: &str) -> bool {
|
||||
path == "vendor" || path.starts_with("vendor/")
|
||||
}
|
||||
|
||||
/// Whether the project-relative `path` is a PHP file to parse.
|
||||
pub(crate) fn is_php(path: &str) -> bool {
|
||||
path.rsplit('/')
|
||||
.next()
|
||||
.and_then(|name| name.rsplit_once('.'))
|
||||
.is_some_and(|(stem, ext)| !stem.is_empty() && ext.eq_ignore_ascii_case("php"))
|
||||
}
|
||||
|
||||
/// Indexes `text` as the file at `path`: parses it when it is a PHP file
|
||||
/// of at most [`MAX_PARSE_BYTES`] and extracts its symbols; other files get
|
||||
/// no symbols.
|
||||
///
|
||||
/// # Parameters
|
||||
/// - `parser`: reused between files.
|
||||
/// - `path`: project-relative path with `/` separators.
|
||||
/// - `text`: the file's text.
|
||||
pub fn index_text(parser: &mut Parser, path: String, text: &str) -> IndexedFile {
|
||||
let library = is_library(&path);
|
||||
let parse = is_php(&path) && text.len() as u64 <= MAX_PARSE_BYTES;
|
||||
let symbols = if parse {
|
||||
let tree = parser.parse(text);
|
||||
symbols_from_outline(&lutra_syntax::outline(&tree))
|
||||
} else {
|
||||
Vec::new()
|
||||
};
|
||||
IndexedFile {
|
||||
path,
|
||||
library,
|
||||
symbols,
|
||||
}
|
||||
}
|
||||
|
||||
/// The symbols declared in an outline, in source order, at most
|
||||
/// [`MAX_SYMBOLS_PER_FILE`].
|
||||
///
|
||||
/// Namespaces give the FQN prefix of what they contain; classes,
|
||||
/// interfaces, traits and enums are the container of their members.
|
||||
/// Anonymous classes and their members are skipped: nothing can navigate to
|
||||
/// them by name.
|
||||
pub fn symbols_from_outline(items: &[OutlineItem]) -> Vec<Symbol> {
|
||||
let mut out = Vec::new();
|
||||
collect(items, "", None, &mut out);
|
||||
out
|
||||
}
|
||||
|
||||
/// Adds the symbols of `items` to `out`.
|
||||
///
|
||||
/// # Parameters
|
||||
/// - `namespace`: the enclosing namespace without leading or trailing `\`;
|
||||
/// empty for the global namespace.
|
||||
/// - `container`: the FQN of the enclosing class-like declaration.
|
||||
fn collect(items: &[OutlineItem], namespace: &str, container: Option<&str>, out: &mut Vec<Symbol>) {
|
||||
for item in items {
|
||||
if out.len() >= MAX_SYMBOLS_PER_FILE {
|
||||
return;
|
||||
}
|
||||
let Some(kind) = SymbolKind::from_outline(item.kind) else {
|
||||
let name = item.name.trim_matches('\\');
|
||||
collect(&item.children, name, None, out);
|
||||
continue;
|
||||
};
|
||||
if item.is_anonymous() || item.name.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let (fqn, owner) = match container {
|
||||
Some(owner) if !kind.is_class_like() && kind != SymbolKind::Function => {
|
||||
(format!("{owner}::{}", item.name), Some(owner.to_string()))
|
||||
}
|
||||
_ => (qualify(namespace, &item.name), None),
|
||||
};
|
||||
let start = item.selection_range.start;
|
||||
out.push(Symbol {
|
||||
name: item.name.clone(),
|
||||
fqn: fqn.clone(),
|
||||
kind,
|
||||
container: owner,
|
||||
line: start.line,
|
||||
column: start.column,
|
||||
});
|
||||
if kind.is_class_like() {
|
||||
collect(&item.children, namespace, Some(&fqn), out);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// `name` qualified with `namespace`: `App\Product`, or `Product` in the
|
||||
/// global namespace.
|
||||
fn qualify(namespace: &str, name: &str) -> String {
|
||||
let name = name.trim_start_matches('\\');
|
||||
if namespace.is_empty() {
|
||||
name.to_string()
|
||||
} else {
|
||||
format!("{namespace}\\{name}")
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn symbols(source: &str) -> Vec<Symbol> {
|
||||
let mut parser = Parser::new().unwrap();
|
||||
index_text(&mut parser, "src/a.php".into(), source).symbols
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn qualifies_classes_members_and_functions() {
|
||||
let found = symbols(
|
||||
"<?php\nnamespace App\\Models;\n\ninterface HasId {}\nfinal class Product implements HasId\n{\n public const MAX = 3;\n private ?string $name = null;\n public function __construct(private int $id) {}\n public function find(int $id): ?self { return null; }\n}\nenum Status: string { case Draft = 'draft'; }\nfunction helper(): void {}\nconst VERSION = 1;\n$x = new class { public function hidden() {} };\n",
|
||||
);
|
||||
let summary: Vec<(String, &str, Option<String>)> = found
|
||||
.iter()
|
||||
.map(|s| (s.fqn.clone(), s.kind.as_str(), s.container.clone()))
|
||||
.collect();
|
||||
let product = Some("App\\Models\\Product".to_string());
|
||||
assert_eq!(
|
||||
summary,
|
||||
vec![
|
||||
("App\\Models\\HasId".into(), "interface", None),
|
||||
("App\\Models\\Product".into(), "class", None),
|
||||
(
|
||||
"App\\Models\\Product::MAX".into(),
|
||||
"constant",
|
||||
product.clone()
|
||||
),
|
||||
(
|
||||
"App\\Models\\Product::$name".into(),
|
||||
"property",
|
||||
product.clone()
|
||||
),
|
||||
(
|
||||
"App\\Models\\Product::__construct".into(),
|
||||
"method",
|
||||
product.clone()
|
||||
),
|
||||
(
|
||||
"App\\Models\\Product::$id".into(),
|
||||
"property",
|
||||
product.clone()
|
||||
),
|
||||
("App\\Models\\Product::find".into(), "method", product),
|
||||
("App\\Models\\Status".into(), "enum", None),
|
||||
(
|
||||
"App\\Models\\Status::Draft".into(),
|
||||
"enumCase",
|
||||
Some("App\\Models\\Status".into())
|
||||
),
|
||||
("App\\Models\\helper".into(), "function", None),
|
||||
("App\\Models\\VERSION".into(), "constant", None),
|
||||
]
|
||||
);
|
||||
let product = found.iter().find(|s| s.name == "Product").unwrap();
|
||||
assert_eq!((product.line, product.column), (4, 12));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn braced_and_global_namespaces() {
|
||||
let found = symbols(
|
||||
"<?php\nnamespace A { class One {} }\nnamespace { class Two {} function three() {} }\n",
|
||||
);
|
||||
let fqns: Vec<&str> = found.iter().map(|s| s.fqn.as_str()).collect();
|
||||
assert_eq!(fqns, vec!["A\\One", "Two", "three"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn only_php_files_are_parsed() {
|
||||
let mut parser = Parser::new().unwrap();
|
||||
let text = "<?php class A {}";
|
||||
assert_eq!(
|
||||
index_text(&mut parser, "a.php".into(), text).symbols.len(),
|
||||
1
|
||||
);
|
||||
assert_eq!(
|
||||
index_text(&mut parser, "A.PHP".into(), text).symbols.len(),
|
||||
1
|
||||
);
|
||||
assert!(
|
||||
index_text(&mut parser, "a.twig".into(), text)
|
||||
.symbols
|
||||
.is_empty()
|
||||
);
|
||||
assert!(
|
||||
index_text(&mut parser, ".php".into(), text)
|
||||
.symbols
|
||||
.is_empty()
|
||||
);
|
||||
let file = index_text(&mut parser, "vendor/x/a.php".into(), text);
|
||||
assert!(file.library);
|
||||
assert!(!is_library("vendors/a.php"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn oversized_files_have_no_symbols() {
|
||||
let mut parser = Parser::new().unwrap();
|
||||
let mut text = String::from("<?php class A {}\n");
|
||||
text.push_str(&"// filler\n".repeat((MAX_PARSE_BYTES as usize) / 10 + 1));
|
||||
assert!(
|
||||
index_text(&mut parser, "a.php".into(), &text)
|
||||
.symbols
|
||||
.is_empty()
|
||||
);
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue