mod candidate;
mod fragment;
mod namespace;
mod references;
mod scope;
use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::time::{Duration, Instant};
use rayon::prelude::*;
use vvv_core::{
Address, FileSet, Language, LanguageId, LanguageRegistry, Oracle, Package, Packages, Project,
Query, Role, SourceText,
};
pub use candidate::Candidate;
pub use fragment::{Declared, Edge, Fragment, Node, Structure};
pub use namespace::Namespace;
pub use references::{DeclarationSite, Evidence};
pub use scope::Scope;
use crate::{
Dep, EngineError, Importer, Match, ReferencesQuery, Search, Skipped, Stamp, Workspace,
};
pub struct Graph {
workspace: Workspace,
languages: LanguageRegistry,
walked: Vec<PathBuf>,
walked_at: Option<Instant>,
entries: Vec<Entry>,
projects: HashMap<LanguageId, (Arc<Project>, u64)>,
oracle: Option<Arc<dyn Oracle>>,
previous: HashMap<LanguageId, (Arc<Project>, u64)>,
}
struct Entry {
path: PathBuf,
stamp: Option<Stamp>,
candidate: Candidate,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Retention {
#[default]
PerCall,
Session { trust: Duration },
}
impl Retention {
pub const fn session() -> Self {
Self::Session {
trust: Duration::ZERO,
}
}
pub const fn trusting(self, trust: Duration) -> Self {
match self {
Self::PerCall => Self::PerCall,
Self::Session { .. } => Self::Session { trust },
}
}
}
impl Graph {
pub fn new(workspace: Workspace, languages: LanguageRegistry) -> Self {
Self {
workspace,
languages,
walked: Vec::new(),
walked_at: None,
oracle: None,
entries: Vec::new(),
projects: HashMap::new(),
previous: HashMap::new(),
}
}
pub fn refresh(&mut self, retention: Retention) -> Result<(), EngineError> {
if let Retention::Session { trust } = retention
&& self.walked_at.is_some_and(|at| at.elapsed() < trust)
{
return Ok(());
}
let walked = self.workspace.files()?;
let claimed: Vec<(&Path, Arc<dyn Language>)> = walked
.iter()
.filter_map(|abs| Some((abs.as_path(), self.languages.for_path(abs)?)))
.collect();
let before = std::mem::take(&mut self.entries);
let vfs = self.workspace.vfs();
let workspace = &self.workspace;
let stamping = matches!(retention, Retention::Session { .. });
let now: Vec<Entry> = claimed
.into_par_iter()
.map(|(abs, language)| {
let stamp = stamping.then(|| vfs.stamp(abs)).transpose()?;
let known = stamp.and_then(|stamp| {
before
.binary_search_by(|e| e.path.as_path().cmp(abs))
.ok()
.map(|i| &before[i])
.filter(|e| e.stamp == Some(stamp))
});
let candidate = match known {
Some(known) => known.candidate.clone(),
None => Candidate::new(workspace.load(abs)?, language),
};
Ok(Entry {
path: abs.to_path_buf(),
stamp,
candidate,
})
})
.collect::<Result<_, EngineError>>()?;
self.entries = now;
self.previous = std::mem::take(&mut self.projects);
self.walked = walked;
self.walked_at = Some(Instant::now());
Ok(())
}
pub fn touched(&mut self) {
self.walked_at = None;
}
pub fn with_oracle(mut self, oracle: Arc<dyn Oracle>) -> Self {
self.oracle = Some(oracle);
self
}
pub(crate) fn oracle(&self) -> Option<&Arc<dyn Oracle>> {
self.oracle.as_ref()
}
pub fn files(&self, language: Option<&LanguageId>) -> Vec<Candidate> {
self.entries
.iter()
.map(|e| &e.candidate)
.filter(|c| language.is_none_or(|id| &c.language() == id))
.cloned()
.collect()
}
pub fn candidate(&self, path: &Path) -> Option<Candidate> {
let abs = self.workspace.absolute(path);
self.entries
.binary_search_by(|e| e.path.as_path().cmp(abs.as_path()))
.ok()
.map(|i| self.entries[i].candidate.clone())
}
pub fn containing(&self, language: Option<&LanguageId>, literals: &[&str]) -> Vec<Candidate> {
self.files(language)
.into_par_iter()
.filter(|c| c.contains_all(literals))
.collect()
}
fn project_build(&mut self, language: &LanguageId) -> Option<(Arc<Project>, u64)> {
if let Some(built) = self.projects.get(language) {
return Some(built.clone());
}
let language_impl = self.languages.get(language)?;
let layout = language_impl.layout()?;
let vfs = self.workspace.vfs();
let files: FileSet = self
.walked
.iter()
.map(|abs| self.workspace.absolute(abs))
.map(|abs| self.workspace.relative(&abs))
.collect();
let manifests: Vec<&Path> = files
.iter()
.filter(|p| {
p.file_name()
.is_some_and(|n| layout.manifests().iter().any(|m| n == *m))
})
.collect();
let packages: Vec<Package> = manifests
.into_par_iter()
.filter_map(|manifest| {
let text = vfs.read(&self.workspace.absolute(manifest)).ok()?;
layout.package(manifest, &text)
})
.collect();
let packages = Packages::new(packages);
let project = Project { packages, files };
let built = match self.previous.remove(language) {
Some((last, generation)) if *last == project => (last, generation),
Some((_, generation)) => (Arc::new(project), generation + 1),
None => (Arc::new(project), 1),
};
self.projects.insert(language.clone(), built.clone());
Some(built)
}
pub fn language_ids(&self) -> Vec<LanguageId> {
self.languages.iter().map(|l| l.id()).collect()
}
pub fn language_of(&self, path: &Path) -> Option<Arc<dyn Language>> {
self.languages.for_path(path)
}
pub fn language(&self, id: &LanguageId) -> Option<Arc<dyn Language>> {
self.languages.get(id)
}
pub fn language_of_directory(&self, dir: &Path) -> Option<Arc<dyn Language>> {
self.workspace
.vfs()
.walk(&self.workspace.absolute(dir))
.ok()?
.iter()
.find_map(|p| self.languages.for_path(p))
}
pub fn namespace(&mut self, language: &LanguageId) -> Option<Namespace> {
let language = self.languages.get(language)?;
language.layout()?;
let (project, generation) = self.project_build(&language.id())?;
Some(Namespace::new(language, project, generation))
}
pub fn namespace_of(&mut self, path: &Path) -> Result<Namespace, EngineError> {
let language = self
.languages
.for_path(path)
.ok_or_else(|| EngineError::NoLanguage(path.into()))?;
self.namespace(&language.id())
.ok_or_else(|| EngineError::NoLayout(language.id()))
}
pub fn file(&self, path: &Path) -> Result<Candidate, EngineError> {
self.candidate(path)
.ok_or_else(|| EngineError::NoLanguage(path.into()))
}
pub fn search(&mut self, query: &Query) -> Result<Search, EngineError> {
let mut skipped = Vec::new();
let mut accepted: Vec<LanguageId> = Vec::new();
for language in self.languages.iter() {
if query.language().is_some_and(|id| id != &language.id()) {
continue;
}
match language.accepts(query) {
Ok(()) => accepted.push(language.id()),
Err(reason) => skipped.push(Skipped {
language: language.id(),
reason: reason.to_string(),
}),
}
}
let candidates: Vec<Candidate> = self
.containing(query.language(), &query.literals())
.into_iter()
.filter(|c| accepted.contains(&c.language()))
.collect();
let per_file: Vec<Vec<Match>> = candidates
.par_iter()
.map(|c| c.find(query))
.collect::<Result<_, _>>()?;
let mut matches: Vec<Match> = per_file.into_iter().flatten().collect();
self.address_declarations(&mut matches);
matches.sort_by_key(|m| m.role != Role::Declaration);
Ok(Search {
query: query.clone(),
matches,
skipped,
})
}
fn address_declarations(&mut self, matches: &mut [Match]) {
let mut last: Option<(PathBuf, Option<Address>)> = None;
for m in matches.iter_mut() {
let Some(symbol) = &m.symbol else {
continue;
};
let Some(ns) = self.namespace(&m.language) else {
continue;
};
if last.as_ref().is_none_or(|(path, _)| path != &m.path) {
last = Some((m.path.to_path_buf(), ns.address(&m.path).ok()));
}
m.address = last
.as_ref()
.and_then(|(_, module)| module.as_ref())
.and_then(|module| ns.address_of(module, symbol));
}
}
pub fn declarations(&mut self, query: &ReferencesQuery) -> Result<Vec<Match>, EngineError> {
let mut search = Query::named(query.name.as_str());
if let Some(symbol) = query.symbol {
search = search.with_symbol(symbol);
}
if let Some(language) = &query.language {
search = search.in_language(language.clone());
}
let mut declarations = self.search(&search)?.matches;
if let Some(file) = &query.declared_in {
let file = self.workspace.normalize(file);
declarations.retain(|d| d.path == file);
}
if declarations.is_empty() {
return Err(EngineError::NoSuchSymbol {
name: query.name.clone(),
kind: query.symbol,
});
}
Ok(declarations)
}
pub fn imports_of(&mut self, path: &Path) -> Result<Vec<Dep>, EngineError> {
let candidate = self.file(path)?;
let ns = self.namespace_of(path)?;
let source = candidate.file().source();
let fragment = candidate.fragment(&ns)?;
fragment
.imports()
.map(|edge| self.dep(&ns, source, edge))
.collect()
}
pub fn dep(
&self,
ns: &Namespace,
source: &SourceText,
edge: &Edge,
) -> Result<Dep, EngineError> {
let origin = match &edge.address {
Some(address) => self.origin_of(ns, address)?.filter(|o| o != address),
None => None,
};
let file = origin
.as_ref()
.or(edge.address.as_ref())
.and_then(|a| ns.file_of(a));
Ok(Dep {
import: edge.import.clone(),
start: source.position(edge.import.span.start),
address: edge.address.clone(),
origin,
file: file.map(Into::into),
})
}
pub fn fragments(&self, ns: &Namespace) -> Result<Vec<Node>, EngineError> {
self.files(Some(&ns.id()))
.into_par_iter()
.map(|candidate| {
Ok(Node {
fragment: candidate.fragment(ns)?,
candidate,
})
})
.collect()
}
pub fn importers(
&self,
ns: &Namespace,
path: &Path,
leads: impl Fn(&Address) -> bool + Sync,
) -> Result<Vec<Importer>, EngineError> {
Ok(self
.fragments(ns)?
.into_iter()
.filter(|node| node.path() != path)
.flat_map(|node| {
node.fragment
.imports()
.filter(|e| e.address.as_ref().is_some_and(&leads))
.map(|e| Importer {
path: node.path().into(),
import: e.import.clone(),
start: node.candidate.file().source().position(e.import.span.start),
})
.collect::<Vec<_>>()
})
.collect())
}
}
impl std::fmt::Debug for Graph {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Graph")
.field("root", &self.workspace.root())
.field("files", &self.walked.len())
.field("loaded", &self.entries.len())
.finish()
}
}