use super::*;
#[derive(Debug, Clone)]
pub struct BoundedFrontier {
pub reached: Vec<Reached>,
pub bounded_seeds: Vec<String>,
}
pub struct TenantView<'a> {
pub(super) base: &'a Base,
pub(super) overlay: Option<&'a Overlay>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ViewSymbol {
pub name: String,
pub kind: String,
pub file: String,
pub start_line: usize,
}
impl TenantView<'_> {
#[must_use]
pub fn has_symbol(&self, name: &str) -> bool {
!self.seeds(name).is_empty()
}
#[must_use]
pub fn frontier(&self, changed: &[&str], hops: u32) -> Vec<Reached> {
self.frontier_bounded(changed, hops, usize::MAX).reached
}
#[must_use]
pub fn frontier_bounded(
&self,
changed: &[&str],
hops: u32,
high_fanin_threshold: usize,
) -> BoundedFrontier {
let seeds: std::collections::BTreeSet<&str> = changed.iter().copied().collect();
let mut seen: std::collections::BTreeSet<(String, String)> =
std::collections::BTreeSet::new();
let mut out = Vec::new();
let mut bounded_seeds = Vec::new();
for &name in changed {
let direct_fan = crate::graph::reachable_over(self, name, Dir::Callers, 1).len()
+ crate::graph::reachable_over(self, name, Dir::Callees, 1).len();
let effective_hops = if direct_fan > high_fanin_threshold {
bounded_seeds.push(name.to_string());
1
} else {
hops
};
for dir in [Dir::Callers, Dir::Callees] {
for r in crate::graph::reachable_over(self, name, dir, effective_hops) {
if !seeds.contains(r.name.as_str())
&& seen.insert((r.name.clone(), r.file.clone()))
{
out.push(r);
}
}
}
}
BoundedFrontier {
reached: out,
bounded_seeds,
}
}
#[must_use]
pub fn definitions(&self, name: &str) -> Vec<ViewSymbol> {
self.defs_of_name(name, None)
.into_iter()
.map(|r| self.view_symbol(r))
.collect()
}
#[must_use]
pub fn file_symbols(&self, rel: &str) -> Vec<ViewSymbol> {
if let Some(overlay) = self.overlay {
if overlay.is_touched(rel) {
let mut out: Vec<ViewSymbol> = (0..overlay.symbol_count() as u32)
.filter(|&id| overlay.symbol(id).file == rel)
.map(|id| self.view_symbol(SymRef::Overlay(id)))
.collect();
out.sort_by_key(|s| s.start_line);
return out;
}
}
self.base
.graph()
.file_symbols(rel)
.into_iter()
.map(|n| ViewSymbol {
name: n.name.clone(),
kind: n.kind.clone(),
file: n.file.clone(),
start_line: n.start_line,
})
.collect()
}
fn view_symbol(&self, r: SymRef) -> ViewSymbol {
match r {
SymRef::Base(ix) => {
let n = &self.base.graph().graph[ix];
ViewSymbol {
name: n.name.clone(),
kind: n.kind.clone(),
file: n.file.clone(),
start_line: n.start_line,
}
}
SymRef::Overlay(id) => {
let s = self
.overlay
.expect("an overlay id implies an overlay")
.symbol(id);
ViewSymbol {
name: s.name.clone(),
kind: s.kind.clone(),
file: s.file.clone(),
start_line: s.start_line,
}
}
}
}
fn touched(&self, rel: &str) -> bool {
self.overlay.is_some_and(|o| o.is_touched(rel))
}
fn base_language(&self, ix: NodeIndex) -> Option<&'static str> {
let file = &self.base.graph().graph[ix].file;
std::path::Path::new(file)
.extension()
.and_then(std::ffi::OsStr::to_str)
.and_then(crate::extract::language_for_extension)
}
fn defs_of_name(&self, name: &str, language: Option<&'static str>) -> Vec<SymRef> {
let mut out = Vec::new();
if let Some(overlay) = self.overlay {
for &id in overlay.defs(name) {
if language.is_none_or(|l| overlay.symbol(id).language == l) {
out.push(SymRef::Overlay(id));
}
}
}
for &ix in self
.base
.graph()
.by_name
.get(name)
.map_or(&[][..], Vec::as_slice)
{
let node = &self.base.graph().graph[ix];
if !self.touched(&node.file)
&& language.is_none_or(|l| self.base_language(ix) == Some(l))
{
out.push(SymRef::Base(ix));
}
}
out
}
fn base_callers_of_name(&self, name: &str, language: &'static str) -> Vec<SymRef> {
let mut out = Vec::new();
for &caller in self.base.graph().callers_of_name(name) {
let file = self.base.graph().node_file(caller);
if !self.touched(file) && self.base_language(caller) == Some(language) {
out.push(SymRef::Base(caller));
}
}
out
}
}
impl Adjacency for TenantView<'_> {
type Node = SymRef;
fn seeds(&self, name: &str) -> Vec<SymRef> {
self.defs_of_name(name, None)
}
fn neighbors(&self, node: SymRef, dir: Dir) -> Vec<SymRef> {
let mut out = Vec::new();
match (node, dir) {
(SymRef::Base(ix), Dir::Callees) => {
let language = self.base_language(ix);
let mut remap: Vec<&str> = Vec::new();
for callee in self
.base
.graph()
.graph
.neighbors_directed(ix, PgDirection::Outgoing)
{
let n = &self.base.graph().graph[callee];
if self.touched(&n.file) {
if !remap.contains(&n.name.as_str()) {
remap.push(&n.name);
}
} else {
out.push(SymRef::Base(callee));
}
}
if let Some(overlay) = self.overlay {
for name in remap {
for &id in overlay.defs(name) {
if language.is_none_or(|l| overlay.symbol(id).language == l) {
out.push(SymRef::Overlay(id));
}
}
}
}
}
(SymRef::Base(ix), Dir::Callers) => {
for caller in self
.base
.graph()
.graph
.neighbors_directed(ix, PgDirection::Incoming)
{
let file = &self.base.graph().graph[caller].file;
if !self.touched(file) {
out.push(SymRef::Base(caller));
}
}
if let Some(overlay) = self.overlay {
let me = &self.base.graph().graph[ix];
let language = self.base_language(ix);
for &id in overlay.callers_of(&me.name) {
if language.is_none_or(|l| overlay.symbol(id).language == l) {
out.push(SymRef::Overlay(id));
}
}
}
}
(SymRef::Overlay(id), Dir::Callees) => {
let overlay = self.overlay.expect("an overlay id implies an overlay");
let me = overlay.symbol(id);
for name in overlay.callee_names(id) {
for target in self.defs_of_name(name, Some(me.language)) {
if target != node && !out.contains(&target) {
out.push(target);
}
}
}
}
(SymRef::Overlay(id), Dir::Callers) => {
let overlay = self.overlay.expect("an overlay id implies an overlay");
let me = overlay.symbol(id);
for &caller in overlay.callers_of(&me.name) {
if overlay.symbol(caller).language == me.language && caller != id {
out.push(SymRef::Overlay(caller));
}
}
out.extend(self.base_callers_of_name(&me.name, me.language));
}
}
out
}
fn meta(&self, node: SymRef) -> NodeMeta {
match node {
SymRef::Base(ix) => {
let n = &self.base.graph().graph[ix];
NodeMeta {
name: n.name.clone(),
file: n.file.clone(),
start_line: n.start_line,
}
}
SymRef::Overlay(id) => {
let s = self
.overlay
.expect("an overlay id implies an overlay")
.symbol(id);
NodeMeta {
name: s.name.clone(),
file: s.file.clone(),
start_line: s.start_line,
}
}
}
}
}