use std::collections::{BTreeMap, BTreeSet};
use proc_macro2::Span;
use syn::visit::Visit;
use super::FaceSyntaxError;
use super::text_edit::{ReferencePlan, TextEdit};
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ModuleMove {
pub from: String,
pub to: String,
}
#[derive(Clone)]
struct Segment {
name: String,
span: Span,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct PathContext {
pub crate_root: bool,
pub bare_root: bool,
pub crate_name: Option<String>,
}
impl PathContext {
pub fn at_crate_root(bare_root: bool) -> Self {
Self {
crate_root: true,
bare_root,
crate_name: None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Spelling {
Absolute,
Bare,
Named,
}
struct Variant {
from: Vec<String>,
to: Vec<String>,
spelling: String,
kind: Spelling,
}
pub fn plan_reference_rewrites(
source: &str,
moves: &[ModuleMove],
bare_root: bool,
) -> Result<ReferencePlan, FaceSyntaxError> {
plan_reference_rewrites_in(source, moves, &PathContext::at_crate_root(bare_root))
}
pub fn plan_reference_rewrites_in(
source: &str,
moves: &[ModuleMove],
context: &PathContext,
) -> Result<ReferencePlan, FaceSyntaxError> {
let file = super::nesting::parse_file(source)?;
let mut planner = ReferencePlanner {
variants: move_variants(moves, context),
moved_paths: moves
.iter()
.map(|module_move| split(&module_move.from))
.collect(),
context: context.clone(),
scopes: vec![Scope::default()],
edits: BTreeMap::new(),
unresolved: BTreeSet::new(),
};
planner.seed_items(&file.items);
planner.visit_file(&file);
Ok(planner.finish())
}
fn move_variants(moves: &[ModuleMove], context: &PathContext) -> Vec<Variant> {
let mut variants = Vec::new();
for module_move in moves {
let from = split(&module_move.from);
let to = split(&module_move.to);
if from.first().map(String::as_str) == Some("crate") {
variants.push(Variant {
from,
to,
spelling: module_move.from.clone(),
kind: Spelling::Absolute,
});
continue;
}
if context.crate_root {
let mut absolute_from = vec!["crate".to_owned()];
absolute_from.extend(from.clone());
let mut absolute_to = vec!["crate".to_owned()];
absolute_to.extend(to.clone());
variants.push(Variant {
from: absolute_from,
to: absolute_to,
spelling: format!("crate::{}", module_move.from),
kind: Spelling::Absolute,
});
}
if context.bare_root {
variants.push(Variant {
from: from.clone(),
to: to.clone(),
spelling: module_move.from.clone(),
kind: Spelling::Bare,
});
}
if let Some(name) = &context.crate_name {
let mut named_from = vec![name.clone()];
named_from.extend(from.clone());
let mut named_to = vec![name.clone()];
named_to.extend(to.clone());
variants.push(Variant {
from: named_from,
to: named_to,
spelling: format!("{name}::{}", module_move.from),
kind: Spelling::Named,
});
}
}
variants
}
fn split(path: &str) -> Vec<String> {
path.split("::").map(str::to_owned).collect()
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Binding {
Ancestor,
Other,
}
#[derive(Default)]
struct Scope {
names: BTreeMap<String, Binding>,
}
struct ReferencePlanner {
variants: Vec<Variant>,
moved_paths: Vec<Vec<String>>,
context: PathContext,
scopes: Vec<Scope>,
edits: BTreeMap<(usize, usize), String>,
unresolved: BTreeSet<String>,
}
impl ReferencePlanner {
fn finish(mut self) -> ReferencePlan {
let mut edits: Vec<TextEdit> = Vec::new();
for ((start, end), replacement) in std::mem::take(&mut self.edits) {
if let Some(previous) = edits.last()
&& previous.end > start
{
self.unresolved.insert(format!(
"two rewrites claim overlapping bytes {}..{} and {}..{}",
previous.start, previous.end, start, end
));
continue;
}
edits.push(TextEdit {
start,
end,
replacement,
});
}
edits.sort_by_key(|edit| (edit.start, edit.end));
ReferencePlan {
edits,
unresolved: self.unresolved.into_iter().collect(),
}
}
fn record(&mut self, start: usize, end: usize, replacement: String, spelling: &str) {
if let Some(existing) = self.edits.get(&(start, end)) {
if *existing != replacement {
self.unresolved.insert(format!(
"overlapping rewrites for `{spelling}` disagree at bytes {start}..{end}"
));
}
return;
}
self.edits.insert((start, end), replacement);
}
fn seed_items(&mut self, items: &[syn::Item]) {
for item in items {
if let syn::Item::Mod(module) = item {
let binding = self.module_binding(&module.ident.to_string());
self.declare(module.ident.to_string(), binding);
}
}
for item in items {
match item {
syn::Item::Use(item_use) => self.seed_use(&item_use.tree),
syn::Item::ExternCrate(extern_crate) => {
let name = extern_crate.rename.as_ref().map_or_else(
|| extern_crate.ident.to_string(),
|(_, alias)| alias.to_string(),
);
self.declare(name, Binding::Other);
}
syn::Item::Struct(item) => self.declare(item.ident.to_string(), Binding::Other),
syn::Item::Enum(item) => self.declare(item.ident.to_string(), Binding::Other),
syn::Item::Union(item) => self.declare(item.ident.to_string(), Binding::Other),
syn::Item::Trait(item) => self.declare(item.ident.to_string(), Binding::Other),
syn::Item::Type(item) => self.declare(item.ident.to_string(), Binding::Other),
_ => {}
}
}
}
fn declare(&mut self, name: String, binding: Binding) {
if let Some(scope) = self.scopes.last_mut() {
scope.names.entry(name).or_insert(binding);
}
}
fn module_binding(&self, name: &str) -> Binding {
let at_root = self.scopes.len() == 1;
if at_root && self.context.bare_root && self.bare_heads().contains(name) {
Binding::Ancestor
} else {
Binding::Other
}
}
fn bare_heads(&self) -> BTreeSet<String> {
self.variants
.iter()
.filter(|variant| variant.kind == Spelling::Bare)
.filter_map(|variant| variant.from.first().cloned())
.collect()
}
fn seed_use(&mut self, tree: &syn::UseTree) {
let mut chain = Vec::new();
self.declare_use_bindings(tree, &mut chain);
}
fn declare_use_bindings(&mut self, tree: &syn::UseTree, chain: &mut Vec<String>) {
match tree {
syn::UseTree::Path(path) => {
chain.push(path.ident.to_string());
self.declare_use_bindings(&path.tree, chain);
chain.pop();
}
syn::UseTree::Name(name) => {
chain.push(name.ident.to_string());
let binding = self.use_binding(chain);
self.declare(chain.last().cloned().unwrap_or_default(), binding);
chain.pop();
}
syn::UseTree::Rename(rename) => {
chain.push(rename.ident.to_string());
let binding = self.use_binding(chain);
self.declare(rename.rename.to_string(), binding);
chain.pop();
}
syn::UseTree::Glob(_) => {}
syn::UseTree::Group(group) => {
for item in &group.items {
self.declare_use_bindings(item, chain);
}
}
}
}
fn use_binding(&self, chain: &[String]) -> Binding {
let Some((leaf, prefix)) = chain.split_last() else {
return Binding::Other;
};
if !self.bare_heads().contains(leaf) {
return Binding::Other;
}
match prefix {
[root] if root == "crate" || root == "self" => Binding::Ancestor,
[] => {
if self.context.bare_root {
Binding::Ancestor
} else {
Binding::Other
}
}
_ => Binding::Other,
}
}
fn head_visible(&self, head: &str, kind: Spelling) -> bool {
match kind {
Spelling::Bare if !self.context.bare_root => false,
Spelling::Absolute => true,
_ => {
for scope in self.scopes.iter().rev() {
if let Some(binding) = scope.names.get(head) {
return *binding == Binding::Ancestor;
}
}
true
}
}
}
fn report_unknown_head(&mut self, segments: &[Segment], group_base: usize) {
if group_base != 0 || segments.len() < 2 {
return;
}
if self
.scopes
.iter()
.any(|scope| scope.names.contains_key(&segments[0].name))
{
return;
}
let tail = &segments[1..];
let matched = self.moved_paths.iter().any(|from| {
!from.is_empty()
&& tail.len() >= from.len()
&& from
.iter()
.zip(tail.iter())
.all(|(expected, segment)| *expected == segment.name)
});
if !matched {
return;
}
let head = &segments[0].name;
let line = segments[0].span.start().line;
self.unresolved.insert(format!(
"`{head}::…` at line {line} has a moved module as its tail, but `{head}` is not a name \
this planner can resolve here; relocate it explicitly"
));
}
fn consider(&mut self, segments: &[Segment], group_base: usize, absolute_leading: bool) {
let mut best: Option<(usize, Vec<String>, String)> = None;
for variant in &self.variants {
if variant.from.len() > segments.len() {
continue;
}
if !variant
.from
.iter()
.zip(segments.iter())
.all(|(expected, segment)| *expected == segment.name)
{
continue;
}
if absolute_leading && variant.kind == Spelling::Bare {
if let Some(head) = variant.from.first() {
self.unresolved.insert(format!(
"`::{head}::…` at byte {} could be an external crate or a 2015 crate-root \
path; this planner will not guess which",
segments[0].span.byte_range().start
));
}
return;
}
if let Some(head) = variant.from.first()
&& !self.head_visible(head, variant.kind)
{
continue;
}
if best
.as_ref()
.is_none_or(|(length, _, _)| variant.from.len() > *length)
{
best = Some((
variant.from.len(),
variant.to.clone(),
variant.spelling.clone(),
));
}
}
let Some((matched, to, spelling)) = best else {
self.report_unknown_head(segments, group_base);
return;
};
let (start_index, replacement) = if matched <= group_base {
(0usize, to.join("::"))
} else {
if to.len() < group_base
|| !segments[..group_base]
.iter()
.zip(to.iter())
.all(|(segment, expected)| segment.name == *expected)
{
self.unresolved.insert(format!(
"grouped import of `{spelling}` cannot be rewritten without its group base"
));
return;
}
let suffix = to[group_base..].join("::");
(group_base, suffix)
};
let first = &segments[start_index];
let last = &segments[matched - 1];
let start = first.span.byte_range().start;
let end = last.span.byte_range().end;
self.record(start, end, replacement, &spelling);
}
fn path_segments(path: &syn::Path) -> Vec<Segment> {
path.segments
.iter()
.map(|segment| Segment {
name: segment.ident.to_string(),
span: segment.ident.span(),
})
.collect()
}
fn relative_tail_hint(&mut self, tree: &syn::UseTree, prefix: &[Segment]) {
let Some(first) = prefix.first().map(|segment| segment.name.as_str()) else {
return;
};
if first != "self" && first != "super" {
return;
}
let tail: Vec<&str> = prefix.iter().map(|segment| segment.name.as_str()).collect();
let Some(leaf) = self
.variants
.first()
.and_then(|variant| variant.from.last())
else {
return;
};
if tail.contains(&leaf.as_str()) {
self.unresolved.insert(format!(
"a `{first}::…` import at {} may name moved module `{leaf}` and cannot be resolved \
lexically; relocate it explicitly",
tree_span_line(tree)
));
}
}
fn walk_use(&mut self, tree: &syn::UseTree, prefix: &mut Vec<Segment>, group_base: usize) {
match tree {
syn::UseTree::Path(path) => {
prefix.push(Segment {
name: path.ident.to_string(),
span: path.ident.span(),
});
self.walk_use(&path.tree, prefix, group_base);
prefix.pop();
}
syn::UseTree::Name(name) => {
prefix.push(Segment {
name: name.ident.to_string(),
span: name.ident.span(),
});
self.relative_tail_hint(tree, prefix);
self.consider(prefix, group_base, false);
prefix.pop();
}
syn::UseTree::Rename(rename) => {
prefix.push(Segment {
name: rename.ident.to_string(),
span: rename.ident.span(),
});
self.relative_tail_hint(tree, prefix);
self.consider(prefix, group_base, false);
prefix.pop();
}
syn::UseTree::Glob(_) => {
self.relative_tail_hint(tree, prefix);
self.consider(prefix, group_base, false);
}
syn::UseTree::Group(group) => {
let base = prefix.len();
for item in &group.items {
self.walk_use(item, prefix, base);
prefix.truncate(base);
}
}
}
}
}
impl<'ast> Visit<'ast> for ReferencePlanner {
fn visit_file(&mut self, file: &'ast syn::File) {
for item in &file.items {
self.visit_item(item);
}
}
fn visit_item_mod(&mut self, module: &'ast syn::ItemMod) {
if let Some((_, items)) = &module.content {
self.scopes.push(Scope::default());
self.seed_items(items);
for item in items {
self.visit_item(item);
}
self.scopes.pop();
}
}
fn visit_block(&mut self, block: &'ast syn::Block) {
self.scopes.push(Scope::default());
for statement in &block.stmts {
if let syn::Stmt::Item(item) = statement {
match item {
syn::Item::Use(item_use) => self.seed_use(&item_use.tree),
syn::Item::Mod(module) => {
let binding = Binding::Other;
self.declare(module.ident.to_string(), binding);
}
_ => {}
}
}
}
syn::visit::visit_block(self, block);
self.scopes.pop();
}
fn visit_item_use(&mut self, item: &'ast syn::ItemUse) {
if item.leading_colon.is_some() {
let mut heads = Vec::new();
visit_use_heads(&item.tree, &mut Vec::new(), &mut heads);
if heads
.iter()
.any(|head| self.bare_heads().contains(head) && self.context.bare_root)
{
self.unresolved.insert(format!(
"an absolute `::` import at {} cannot be relocated without guessing its root",
span_line(item)
));
}
return;
}
let mut prefix = Vec::new();
self.walk_use(&item.tree, &mut prefix, 0);
}
fn visit_expr_path(&mut self, expression: &'ast syn::ExprPath) {
let segments = Self::path_segments(&expression.path);
self.consider(&segments, 0, expression.path.leading_colon.is_some());
syn::visit::visit_expr_path(self, expression);
}
fn visit_type_path(&mut self, ty: &'ast syn::TypePath) {
let segments = Self::path_segments(&ty.path);
self.consider(&segments, 0, ty.path.leading_colon.is_some());
syn::visit::visit_type_path(self, ty);
}
fn visit_macro(&mut self, item: &'ast syn::Macro) {
let named = item
.path
.segments
.last()
.map(|segment| segment.ident.to_string())
.unwrap_or_default();
if matches!(named.as_str(), "include" | "include_str" | "include_bytes")
&& syn::parse2::<syn::LitStr>(item.tokens.clone()).is_err()
{
self.unresolved.insert(format!(
"`{named}!` at line {} builds its path at expansion time, so the reference cannot \
be checked",
span_line(item)
));
return;
}
let text = macro_path_text(&item.tokens);
for variant in &self.variants {
let spelling = variant.from.join("::");
let visible = variant
.from
.first()
.is_none_or(|head| self.head_visible(head, variant.kind));
if visible && text.contains(&spelling) {
self.unresolved.insert(format!(
"macro `{named}!` at line {} mentions `{spelling}`, whose expansion this \
planner cannot check; relocate it explicitly if the macro builds a path",
span_line(item)
));
break;
}
}
}
}
fn macro_path_text(tokens: &proc_macro2::TokenStream) -> String {
let mut text = String::new();
for tree in tokens.clone() {
match tree {
proc_macro2::TokenTree::Literal(_) => text.push(' '),
other => text.push_str(&other.to_string()),
}
}
text.chars()
.filter(|character| !character.is_whitespace())
.collect()
}
fn visit_use_heads(tree: &syn::UseTree, chain: &mut Vec<String>, heads: &mut Vec<String>) {
match tree {
syn::UseTree::Path(path) => {
chain.push(path.ident.to_string());
visit_use_heads(&path.tree, chain, heads);
chain.pop();
}
syn::UseTree::Name(name) => {
chain.push(name.ident.to_string());
heads.extend(chain.iter().cloned());
chain.pop();
}
syn::UseTree::Rename(rename) => {
chain.push(rename.ident.to_string());
heads.extend(chain.iter().cloned());
chain.pop();
}
syn::UseTree::Glob(_) => heads.extend(chain.iter().cloned()),
syn::UseTree::Group(group) => {
for item in &group.items {
visit_use_heads(item, chain, heads);
}
}
}
}
fn span_line(spanned: &impl syn::spanned::Spanned) -> usize {
spanned.span().start().line
}
fn tree_span_line(tree: &syn::UseTree) -> usize {
use syn::spanned::Spanned;
tree.span().start().line
}
#[cfg(test)]
#[path = "reference_rewrite_tests.rs"]
mod reference_rewrite_tests;