use std::collections::HashMap;
use std::path::PathBuf;
use crate::{Match, Reason};
use super::{Fragment, Namespace};
use vvv_core::{Address, ImportRef, ModulePath, Name, PathHead, Span};
pub struct Scope {
ns: Namespace,
file: PathBuf,
module: Option<Address>,
names: HashMap<Name, Address>,
opened: Vec<Address>,
paths: Vec<Resolved>,
unresolved: Vec<(Span, ModulePath)>,
}
struct Resolved {
span: Span,
path: ModulePath,
address: Address,
skipped: usize,
}
impl Resolved {
fn of(import: &ImportRef, address: Address) -> Self {
let skipped = import
.group
.as_ref()
.and_then(|g| import.path.strip_prefix(&g.prefix))
.map_or(0, |rest| import.path.segments.len() - rest.len());
Self {
span: import.span,
path: import.path.clone(),
address,
skipped,
}
}
fn named_at(&self, at: usize) -> Option<usize> {
let spelled = if self.skipped == 0 {
self.path.clone()
} else {
ModulePath::new(
self.path.syntax(),
PathHead::Named,
self.path.segments[self.skipped..].iter().cloned(),
)
};
spelled
.segment_at(at - self.span.start)
.map(|i| i + self.skipped)
.filter(|i| i + 1 < self.path.segments.len())
}
}
impl Scope {
pub fn of(ns: &Namespace, file: &std::path::Path, fragment: &Fragment) -> Self {
let semantics = ns.semantics();
let mut names = HashMap::new();
let mut opened = Vec::new();
let mut paths = Vec::new();
let mut unresolved = Vec::new();
for edge in &fragment.edges {
let import = &edge.import;
let Some(address) = &edge.address else {
unresolved.push((import.span, import.path.clone()));
continue;
};
if import.declares {
if import.glob || semantics.import_scopes_names {
opened.push(address.clone());
}
if let Some(bound) = import.binding() {
names.insert(bound.clone(), address.clone());
}
}
paths.push(Resolved::of(import, address.clone()));
}
Self {
ns: ns.clone(),
file: file.to_path_buf(),
module: fragment.module.clone(),
names,
opened,
paths,
unresolved,
}
}
pub fn classify(
&self,
token: &Match,
name: &str,
aliases: &[Address],
others: &[Address],
) -> Reason {
let target = &aliases[0];
let target_module = target.parent();
if let Some(resolved) = self.paths.iter().find(|r| r.span.contains(&token.span)) {
let Some(index) = resolved.named_at(token.span.start) else {
return self.compare(&resolved.address, aliases, others, Reason::Path);
};
let prefix = resolved.path.prefix(index);
let (address, reason) = match self.imported(&prefix) {
Some(address) if index == 0 => (address, Reason::Imported),
Some(address) => (address, Reason::Path),
None => match self.ns.resolve(&self.file, &prefix) {
Some(address) => (address, Reason::Path),
None => (resolved.address.clone(), Reason::Path),
},
};
return self.compare(&address, aliases, others, reason);
}
if let Some(reason) = self.qualified(token, aliases, others) {
return reason;
}
if self.module.is_some() && self.module == target_module {
return Reason::Declaring;
}
if self.module.as_ref().is_some_and(|m| others.contains(m)) {
return Reason::OtherDeclaration;
}
if let Some(address) = self.names.get(name) {
return self.compare(address, aliases, others, Reason::Imported);
}
if self
.opened
.iter()
.any(|m| Some(m) == target_module.as_ref())
{
return Reason::Opened;
}
if self
.opened
.iter()
.any(|m| aliases[1..].iter().any(|a| a.parent().as_ref() == Some(m)))
{
return Reason::ReExport;
}
if self.opened.iter().any(|m| others.contains(m)) {
return Reason::OtherDeclaration;
}
Reason::Unresolved
}
fn qualified(&self, token: &Match, aliases: &[Address], others: &[Address]) -> Option<Reason> {
let (_, path) = self.unresolved.iter().find(|(span, path)| {
span.end == token.span.end
&& span.start < token.span.start
&& path.last().is_some_and(|last| *last == token.text)
})?;
if path.head == PathHead::SelfType {
return None;
}
let Some(address) = self.imported(path) else {
return Some(Reason::Unresolved);
};
Some(self.compare(&address, aliases, others, Reason::Path))
}
fn imported(&self, path: &ModulePath) -> Option<Address> {
if path.head != PathHead::Named {
return None;
}
let base = self.names.get(path.first()?)?;
Some(base.extend(path.segments[1..].iter().cloned()))
}
fn compare(
&self,
address: &Address,
aliases: &[Address],
others: &[Address],
via: Reason,
) -> Reason {
let target = &aliases[0];
if address == target {
return via;
}
if aliases.contains(address) {
return Reason::ReExport;
}
let same_name = address.path().last() == target.path().last();
let known_other = address.parent().is_some_and(|m| others.contains(&m));
let external = address.package() != target.package()
&& !self.ns.project().packages.is_member(address.package());
match (same_name, known_other, external) {
(true, true, _) => Reason::OtherDeclaration,
(true, _, true) => Reason::External,
_ => Reason::Unresolved,
}
}
}