use proc_macro2::Span;
use syn::{
Attribute, ImplItem, Item, Meta, TraitItem,
punctuated::Punctuated,
spanned::Spanned,
token::Comma,
visit::{self, Visit},
};
use tokei::{Config, LanguageType};
use crate::model::LineStats;
pub fn inline_test_lines(source: &str) -> LineStats {
let Ok(file) = syn::parse_file(source) else {
return LineStats::default();
};
let mut visitor = TestSpanVisitor::default();
visitor.visit_file(&file);
let ranges = merge_ranges(visitor.ranges);
let lines = source.lines().collect::<Vec<_>>();
let mut total = LineStats::default();
for (start, end) in ranges {
let snippet = lines
.get(start.saturating_sub(1)..end.min(lines.len()))
.unwrap_or_default()
.join("\n");
let stats = LanguageType::Rust.parse_from_str(snippet, &Config::default());
total.add_assign(LineStats {
code: stats.code,
comments: stats.comments,
blanks: stats.blanks,
});
}
total
}
#[derive(Default)]
struct TestSpanVisitor {
ranges: Vec<(usize, usize)>,
}
impl TestSpanVisitor {
fn record_if_test_only(&mut self, attrs: &[Attribute], span: Span) -> bool {
if attrs.iter().any(is_test_only_attribute) {
let start = span.start().line;
let end = span.end().line.max(start);
self.ranges.push((start, end));
true
} else {
false
}
}
}
impl<'ast> Visit<'ast> for TestSpanVisitor {
fn visit_item(&mut self, node: &'ast Item) {
if !self.record_if_test_only(item_attrs(node), node.span()) {
visit::visit_item(self, node);
}
}
fn visit_impl_item(&mut self, node: &'ast ImplItem) {
if !self.record_if_test_only(impl_item_attrs(node), node.span()) {
visit::visit_impl_item(self, node);
}
}
fn visit_trait_item(&mut self, node: &'ast TraitItem) {
if !self.record_if_test_only(trait_item_attrs(node), node.span()) {
visit::visit_trait_item(self, node);
}
}
}
fn is_test_only_attribute(attribute: &Attribute) -> bool {
if attribute.path().is_ident("test") || attribute.path().is_ident("bench") {
return true;
}
if !attribute.path().is_ident("cfg") {
return false;
}
let Meta::List(list) = &attribute.meta else {
return false;
};
list.parse_args_with(Punctuated::<Meta, Comma>::parse_terminated)
.is_ok_and(|predicates| {
predicates.len() == 1 && predicates.first().is_some_and(cfg_implies_test)
})
}
fn cfg_implies_test(meta: &Meta) -> bool {
match meta {
Meta::Path(path) => path.is_ident("test"),
Meta::List(list) if list.path.is_ident("all") => {
parse_nested(list).is_some_and(|items| items.iter().any(cfg_implies_test))
}
Meta::List(list) if list.path.is_ident("any") => parse_nested(list)
.is_some_and(|items| !items.is_empty() && items.iter().all(cfg_implies_test)),
Meta::NameValue(_) | Meta::List(_) => false,
}
}
fn parse_nested(list: &syn::MetaList) -> Option<Punctuated<Meta, Comma>> {
list.parse_args_with(Punctuated::<Meta, Comma>::parse_terminated)
.ok()
}
fn merge_ranges(mut ranges: Vec<(usize, usize)>) -> Vec<(usize, usize)> {
ranges.sort_unstable();
let mut merged: Vec<(usize, usize)> = Vec::new();
for (start, end) in ranges {
if let Some(previous) = merged.last_mut()
&& start <= previous.1.saturating_add(1)
{
previous.1 = previous.1.max(end);
} else {
merged.push((start, end));
}
}
merged
}
macro_rules! attrs_match {
($value:expr, $($variant:path),+ $(,)?) => {
match $value {
$($variant(item) => &item.attrs,)+
_ => &[],
}
};
}
fn item_attrs(item: &Item) -> &[Attribute] {
attrs_match!(
item,
Item::Const,
Item::Enum,
Item::ExternCrate,
Item::Fn,
Item::ForeignMod,
Item::Impl,
Item::Macro,
Item::Mod,
Item::Static,
Item::Struct,
Item::Trait,
Item::TraitAlias,
Item::Type,
Item::Union,
Item::Use,
)
}
fn impl_item_attrs(item: &ImplItem) -> &[Attribute] {
attrs_match!(
item,
ImplItem::Const,
ImplItem::Fn,
ImplItem::Macro,
ImplItem::Type,
)
}
fn trait_item_attrs(item: &TraitItem) -> &[Attribute] {
attrs_match!(
item,
TraitItem::Const,
TraitItem::Fn,
TraitItem::Macro,
TraitItem::Type,
)
}
#[cfg(test)]
mod tests {
use super::inline_test_lines;
#[test]
fn counts_cfg_test_modules_and_test_functions() {
let source = r"
fn production() {}
#[cfg(test)]
mod tests {
fn helper() {}
#[test]
fn works() { assert!(true); }
}
#[test]
fn root_test() {}
";
let stats = inline_test_lines(source);
assert_eq!(stats.code, 8);
}
#[test]
fn does_not_count_optional_feature_as_test_only() {
let source = r#"
#[cfg(any(test, feature = "fixture"))]
fn shared_fixture() {}
"#;
assert_eq!(inline_test_lines(source).code, 0);
}
}