use std::collections::BTreeSet;
use syn::visit::Visit;
use syn::{GenericParam, ItemTrait, TraitItemConst, TraitItemFn, TraitItemType};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Track {
Shared,
All,
}
pub fn decide_track(
trait_: &ItemTrait, methods: &[&TraitItemFn], consts: &[&TraitItemConst],
types: &[&TraitItemType],
) -> Track {
let trait_params = generic_param_names(&trait_.generics);
let mut scanner =
Scanner { trait_params: &trait_params, method_params: &BTreeSet::new(), hit: false };
for param in &trait_.generics.params {
match param {
GenericParam::Type(tp) => {
for bound in &tp.bounds {
scanner.visit_type_param_bound(bound);
}
if let Some((_, default)) = &tp.default {
scanner.visit_type(default);
}
}
GenericParam::Lifetime(lp) => {
if !lp.bounds.is_empty() {
scanner.hit = true;
}
}
GenericParam::Const(_) => {}
}
}
if let Some(wc) = &trait_.generics.where_clause {
scanner.visit_where_clause(wc);
}
if scanner.hit {
return Track::Shared;
}
for f in methods {
if fn_references_generics(f, &trait_params) {
return Track::Shared;
}
}
for c in consts {
if const_references_generics(c, &trait_params) {
return Track::Shared;
}
}
for t in types {
if type_references_generics(t, &trait_params) {
return Track::Shared;
}
}
Track::All
}
fn fn_references_generics(f: &TraitItemFn, trait_params: &BTreeSet<String>) -> bool {
let method_params = generic_param_names(&f.sig.generics);
let mut scanner = Scanner { trait_params, method_params: &method_params, hit: false };
scanner.visit_signature(&f.sig);
scanner.hit
}
fn const_references_generics(c: &TraitItemConst, trait_params: &BTreeSet<String>) -> bool {
let mut scanner = Scanner { trait_params, method_params: &BTreeSet::new(), hit: false };
scanner.visit_type(&c.ty);
scanner.hit
}
fn type_references_generics(t: &TraitItemType, trait_params: &BTreeSet<String>) -> bool {
let mut scanner = Scanner { trait_params, method_params: &BTreeSet::new(), hit: false };
for bound in &t.bounds {
scanner.visit_type_param_bound(bound);
}
scanner.hit
}
fn generic_param_names(generics: &syn::Generics) -> BTreeSet<String> {
generics.params.iter().map(param_name).collect()
}
fn param_name(param: &GenericParam) -> String {
match param {
GenericParam::Type(p) => p.ident.to_string(),
GenericParam::Lifetime(p) => p.lifetime.ident.to_string(),
GenericParam::Const(p) => p.ident.to_string(),
}
}
struct Scanner<'a> {
trait_params: &'a BTreeSet<String>,
method_params: &'a BTreeSet<String>,
hit: bool,
}
impl<'ast> Visit<'ast> for Scanner<'_> {
fn visit_path(&mut self, node: &'ast syn::Path) {
if let Some(seg) = node.segments.first() {
let name = seg.ident.to_string();
if !self.method_params.contains(&name) && self.trait_params.contains(&name) {
self.hit = true;
}
}
syn::visit::visit_path(self, node);
}
fn visit_lifetime(&mut self, node: &'ast syn::Lifetime) {
let name = node.ident.to_string();
if !self.method_params.contains(&name) && self.trait_params.contains(&name) {
self.hit = true;
}
syn::visit::visit_lifetime(self, node);
}
}
#[cfg(test)]
mod tests {
use super::*;
use syn::TraitItem;
use syn::parse_quote;
fn select_one<'a>(trait_: &'a ItemTrait, name: &str) -> Vec<&'a TraitItem> {
trait_.items.iter().filter(|item| trait_item_name(item).as_deref() == Some(name)).collect()
}
fn trait_item_name(item: &TraitItem) -> Option<String> {
match item {
TraitItem::Fn(f) => Some(&f.sig.ident),
TraitItem::Const(c) => Some(&c.ident),
TraitItem::Type(t) => Some(&t.ident),
_ => None,
}
.map(|i| i.to_string())
}
fn decided(trait_: &ItemTrait, selected: &[&TraitItem]) -> Track {
let methods = selected
.iter()
.filter_map(|i| match i {
TraitItem::Fn(f) => Some(f),
_ => None,
})
.collect::<Vec<_>>();
let consts = selected
.iter()
.filter_map(|i| match i {
TraitItem::Const(c) => Some(c),
_ => None,
})
.collect::<Vec<_>>();
let types = selected
.iter()
.filter_map(|i| match i {
TraitItem::Type(t) => Some(t),
_ => None,
})
.collect::<Vec<_>>();
decide_track(trait_, &methods, &consts, &types)
}
#[test]
fn method_using_trait_param_is_shared() {
let trait_: ItemTrait = parse_quote! {
trait Tr<T> {
fn g(x: &T);
}
};
let selected = select_one(&trait_, "g");
assert_eq!(decided(&trait_, &selected), Track::Shared);
}
#[test]
fn method_generic_same_name_is_all() {
let trait_: ItemTrait = parse_quote! {
trait Tr<T> {
fn g<T>(x: T);
}
};
let selected = select_one(&trait_, "g");
assert_eq!(decided(&trait_, &selected), Track::All);
}
#[test]
fn method_without_trait_param_is_all() {
let trait_: ItemTrait = parse_quote! {
trait Tr<T> {
fn foo(&self) -> Box<Self>;
}
};
let selected = select_one(&trait_, "foo");
assert_eq!(decided(&trait_, &selected), Track::All);
}
#[test]
fn const_of_trait_param_type_is_shared() {
let trait_: ItemTrait = parse_quote! {
trait Tr<T> {
const X: T;
}
};
let selected = select_one(&trait_, "X");
assert_eq!(decided(&trait_, &selected), Track::Shared);
}
#[test]
fn assoc_type_bound_referencing_trait_param_is_shared() {
let trait_: ItemTrait = parse_quote! {
trait Tr<T> {
type Out: AsRef<T>;
}
};
let selected = select_one(&trait_, "Out");
assert_eq!(decided(&trait_, &selected), Track::Shared);
}
#[test]
fn trait_where_clause_referencing_param_is_shared() {
let trait_: ItemTrait = parse_quote! {
trait Tr<T>
where
T: Clone,
{
fn foo(&self) -> Box<Self>;
}
};
let selected = select_one(&trait_, "foo");
assert_eq!(decided(&trait_, &selected), Track::Shared);
}
#[test]
fn mixed_shadowed_and_referencing_is_shared() {
let trait_: ItemTrait = parse_quote! {
trait Tr<T> {
fn g<T>(x: T);
fn h(x: T);
}
};
let selected = vec![select_one(&trait_, "g").remove(0), select_one(&trait_, "h").remove(0)];
assert_eq!(decided(&trait_, &selected), Track::Shared);
}
#[test]
fn lifetime_reference_is_shared() {
let trait_: ItemTrait = parse_quote! {
trait Tr<'a> {
fn f(x: &'a str);
}
};
let selected = select_one(&trait_, "f");
assert_eq!(decided(&trait_, &selected), Track::Shared);
}
#[test]
fn method_local_lifetime_is_not_reference() {
let trait_: ItemTrait = parse_quote! {
trait Tr<'a> {
fn f<'b>(x: &'b str);
}
};
let selected = select_one(&trait_, "f");
assert_eq!(decided(&trait_, &selected), Track::All);
}
#[test]
fn const_generic_reference_is_shared() {
let trait_: ItemTrait = parse_quote! {
trait Tr<const N: usize> {
fn arr() -> [u8; N];
}
};
let selected = select_one(&trait_, "arr");
assert_eq!(decided(&trait_, &selected), Track::Shared);
}
#[test]
fn trait_without_generics_is_all_shape() {
let trait_: ItemTrait = parse_quote! {
trait Tr {
fn foo(&self);
}
};
let selected = select_one(&trait_, "foo");
assert_eq!(decided(&trait_, &selected), Track::All);
}
#[test]
fn multi_type_params_stay_all() {
let trait_: ItemTrait = parse_quote! {
trait Tr<X, Y> {
fn foo(&self);
}
};
let selected = select_one(&trait_, "foo");
assert_eq!(decided(&trait_, &selected), Track::All);
}
#[test]
fn const_param_stays_all() {
let trait_: ItemTrait = parse_quote! {
trait Tr<const N: usize> {
fn foo(&self);
}
};
let selected = select_one(&trait_, "foo");
assert_eq!(decided(&trait_, &selected), Track::All);
}
#[test]
fn lifetime_param_stays_all() {
let trait_: ItemTrait = parse_quote! {
trait Tr<'a> {
fn foo(&self);
}
};
let selected = select_one(&trait_, "foo");
assert_eq!(decided(&trait_, &selected), Track::All);
}
#[test]
fn single_type_param_stays_all() {
let trait_: ItemTrait = parse_quote! {
trait Tr<T> {
fn foo(&self);
}
};
let selected = select_one(&trait_, "foo");
assert_eq!(decided(&trait_, &selected), Track::All);
}
}