use std::collections::BTreeMap;
use syn::spanned::Spanned;
use syn::visit::Visit;
use super::FaceSyntaxError;
use super::text_edit::ReferencePlan;
pub fn plan_include_rewrites(
source: &str,
file_dir: &str,
from_dir: &str,
to_dir: &str,
) -> Result<ReferencePlan, FaceSyntaxError> {
let file = super::nesting::parse_file(source)?;
let mut planner = IncludePlanner {
file_dir: file_dir.to_owned(),
new_file_dir: relocate(file_dir, from_dir, to_dir),
from_dir: from_dir.to_owned(),
to_dir: to_dir.to_owned(),
edits: BTreeMap::new(),
unresolved: Vec::new(),
};
planner.visit_file(&file);
Ok(planner.finish())
}
fn relocate(directory: &str, from_dir: &str, to_dir: &str) -> String {
if from_dir.is_empty() {
return directory.to_owned();
}
if directory == from_dir {
return to_dir.to_owned();
}
match directory.strip_prefix(&format!("{from_dir}/")) {
Some(rest) => format!("{to_dir}/{rest}"),
None => directory.to_owned(),
}
}
struct IncludePlanner {
file_dir: String,
new_file_dir: String,
from_dir: String,
to_dir: String,
edits: BTreeMap<(usize, usize), String>,
unresolved: Vec<String>,
}
impl IncludePlanner {
fn finish(self) -> ReferencePlan {
let mut edits: Vec<super::text_edit::TextEdit> = self
.edits
.into_iter()
.map(|((start, end), replacement)| super::text_edit::TextEdit {
start,
end,
replacement,
})
.collect();
edits.sort_by_key(|edit| (edit.start, edit.end));
ReferencePlan {
edits,
unresolved: self.unresolved,
}
}
fn plan_include_macro(&mut self, mac: &syn::Macro) {
let Some(name) = mac
.path
.segments
.last()
.map(|segment| segment.ident.to_string())
else {
return;
};
if !matches!(name.as_str(), "include_str" | "include_bytes" | "include") {
return;
}
let Ok(literal) = syn::parse2::<syn::LitStr>(mac.tokens.clone()) else {
self.unresolved.push(format!(
"`{name}!` at line {} does not take a single string literal; its reference cannot \
be checked",
mac.span().start().line
));
return;
};
let value = literal.value();
if value.starts_with('/') {
return;
}
let Some(resolved) = join_relative(&self.file_dir, &value) else {
return;
};
let new_target = relocate(&resolved, &self.from_dir, &self.to_dir);
if new_target == resolved && self.new_file_dir == self.file_dir {
return;
}
let replacement = relative_path(&self.new_file_dir, &new_target);
if replacement == value {
return;
}
let range = literal.span().byte_range();
let literal_text = proc_macro2::Literal::string(&replacement).to_string();
self.edits.insert((range.start, range.end), literal_text);
}
}
impl<'ast> Visit<'ast> for IncludePlanner {
fn visit_macro(&mut self, item: &'ast syn::Macro) {
self.plan_include_macro(item);
}
}
fn join_relative(base: &str, value: &str) -> Option<String> {
let mut parts: Vec<&str> = if base.is_empty() {
Vec::new()
} else {
base.split('/').collect()
};
for component in value.split('/') {
match component {
"" | "." => {}
".." => {
parts.pop()?;
}
other => parts.push(other),
}
}
Some(parts.join("/"))
}
fn relative_path(from_dir: &str, target: &str) -> String {
let from: Vec<&str> = if from_dir.is_empty() {
Vec::new()
} else {
from_dir.split('/').collect()
};
let to: Vec<&str> = target.split('/').collect();
let common = from
.iter()
.zip(to.iter())
.take_while(|(left, right)| left == right)
.count();
let mut parts = vec![".."; from.len().saturating_sub(common)];
parts.extend(to[common..].iter().copied());
if parts.is_empty() {
".".to_owned()
} else {
parts.join("/")
}
}
#[cfg(test)]
#[path = "include_rewrite_tests.rs"]
mod include_rewrite_tests;