use std::path::{Path, PathBuf};
use antigen_macros::{antigen_tolerance, presents};
use serde::{Deserialize, Serialize};
use syn::parse::Parse;
use syn::visit::Visit;
use walkdir::WalkDir;
struct ScanAntigenArgs {
name: String,
fingerprint: Option<String>,
family: Option<String>,
summary: Option<String>,
category: Vec<String>,
}
impl Parse for ScanAntigenArgs {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
use syn::{Ident, LitStr, Token};
let mut name: Option<String> = None;
let mut fingerprint: Option<String> = None;
let mut family: Option<String> = None;
let mut summary: Option<String> = None;
let mut category: Vec<String> = Vec::new();
while !input.is_empty() {
let key: Ident = input.parse()?;
input.parse::<Token![=]>()?;
match key.to_string().as_str() {
"name" => {
let lit: LitStr = input.parse()?;
name = Some(lit.value());
}
"fingerprint" => {
let lit: LitStr = input.parse()?;
fingerprint = Some(lit.value());
}
"family" => {
let lit: LitStr = input.parse()?;
family = Some(lit.value());
}
"summary" => {
let lit: LitStr = input.parse()?;
summary = Some(lit.value());
}
"references" => {
let _arr: syn::ExprArray = input.parse()?;
}
"category" => {
fn path_to_string(expr: &syn::Expr) -> Option<String> {
if let syn::Expr::Path(p) = expr {
let segs: Vec<String> = p
.path
.segments
.iter()
.map(|s| s.ident.to_string())
.collect();
Some(segs.join("::"))
} else {
None
}
}
let val: syn::Expr = input.parse()?;
match &val {
syn::Expr::Array(arr) => {
for elem in &arr.elems {
if let Some(s) = path_to_string(elem) {
category.push(s);
}
}
}
single => {
if let Some(s) = path_to_string(single) {
category.push(s);
}
}
}
}
_ => {
let _: syn::Expr = input.parse()?;
}
}
if input.peek(Token![,]) {
input.parse::<Token![,]>()?;
}
}
Ok(Self {
name: name.unwrap_or_default(),
fingerprint,
family,
summary,
category,
})
}
}
struct ScanPresentsArgs {
antigen_type: String,
requires_predicate: Option<String>,
proof: Option<String>,
}
impl Parse for ScanPresentsArgs {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
use antigen_attestation::parser::RequiresExpr;
use quote::ToTokens;
use syn::{Ident, Path, Token};
let antigen_path: Path = input.parse()?;
let antigen_type = antigen_path
.segments
.last()
.map(|s| s.ident.to_string())
.unwrap_or_default();
let mut requires_predicate: Option<String> = None;
let mut proof: Option<String> = None;
while !input.is_empty() {
input.parse::<Token![,]>()?;
if input.is_empty() {
break;
}
let key: Ident = input.parse()?;
input.parse::<Token![=]>()?;
match key.to_string().as_str() {
"requires" => {
let pred: RequiresExpr = input.parse()?;
requires_predicate = Some(pred.to_json());
}
"proof" => {
let expr: syn::Expr = input.parse()?;
proof = Some(expr.to_token_stream().to_string());
}
_ => {
let _: syn::Expr = input.parse()?;
}
}
}
Ok(Self {
antigen_type,
requires_predicate,
proof,
})
}
}
struct ScanImmuneArgs {
antigen_type: String,
witness: String,
requires_predicate: Option<String>,
}
impl Parse for ScanImmuneArgs {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
use antigen_attestation::parser::RequiresExpr;
use syn::{Ident, Path, Token};
let antigen_path: Path = input.parse()?;
let antigen_type = antigen_path
.segments
.last()
.map(|s| s.ident.to_string())
.unwrap_or_default();
let mut witness = String::new();
let mut requires_predicate: Option<String> = None;
while !input.is_empty() {
input.parse::<Token![,]>()?;
if input.is_empty() {
break;
}
let key: Ident = input.parse()?;
input.parse::<Token![=]>()?;
match key.to_string().as_str() {
"witness" => {
use quote::ToTokens;
let val: syn::Expr = input.parse()?;
witness = val.to_token_stream().to_string();
}
"requires" => {
let pred: RequiresExpr = input.parse()?;
requires_predicate = Some(pred.to_json());
}
_ => {
let _: syn::Expr = input.parse()?;
}
}
}
Ok(Self {
antigen_type,
witness,
requires_predicate,
})
}
}
struct ScanToleranceArgs {
antigen_type: String,
rationale: String,
until: Option<String>,
see: Vec<String>,
requires_predicate: Option<String>,
}
impl Parse for ScanToleranceArgs {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
use antigen_attestation::parser::RequiresExpr;
use syn::{Expr, Ident, Lit, LitStr, Path, Token};
let antigen_path: Path = input.parse()?;
let antigen_type = antigen_path
.segments
.last()
.map(|s| s.ident.to_string())
.unwrap_or_default();
let mut rationale = String::new();
let mut until: Option<String> = None;
let mut see: Vec<String> = Vec::new();
let mut requires_predicate: Option<String> = None;
while !input.is_empty() {
input.parse::<Token![,]>()?;
if input.is_empty() {
break;
}
let key: Ident = input.parse()?;
input.parse::<Token![=]>()?;
match key.to_string().as_str() {
"rationale" => {
let lit: LitStr = input.parse()?;
rationale = lit.value();
}
"until" => {
let lit: LitStr = input.parse()?;
until = Some(lit.value());
}
"see" => {
let arr: syn::ExprArray = input.parse()?;
for elem in &arr.elems {
if let Expr::Lit(syn::ExprLit {
lit: Lit::Str(s), ..
}) = elem
{
see.push(s.value());
}
}
}
"requires" => {
let pred: RequiresExpr = input.parse()?;
requires_predicate = Some(pred.to_json());
}
_ => {
let _: Expr = input.parse()?;
}
}
}
Ok(Self {
antigen_type,
rationale,
until,
see,
requires_predicate,
})
}
}
struct ScanGeneratesArgs {
antigen_type: String,
rationale: String,
}
impl Parse for ScanGeneratesArgs {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
use syn::{Expr, Ident, LitStr, Path, Token};
let antigen_path: Path = input.parse()?;
let antigen_type = antigen_path
.segments
.last()
.map(|s| s.ident.to_string())
.unwrap_or_default();
let mut rationale = String::new();
while !input.is_empty() {
input.parse::<Token![,]>()?;
if input.is_empty() {
break;
}
let key: Ident = input.parse()?;
input.parse::<Token![=]>()?;
match key.to_string().as_str() {
"rationale" => {
let lit: LitStr = input.parse()?;
rationale = lit.value();
}
_ => {
let _: Expr = input.parse()?;
}
}
}
Ok(Self {
antigen_type,
rationale,
})
}
}
#[derive(Default)]
struct ScanRecurrentArgs {
name: Option<String>,
antigen_type: Option<String>,
description: Option<String>,
instances: Option<u64>,
since: Option<String>,
rationale: Option<String>,
from_itches: Vec<String>,
anchored_by: Vec<String>,
managed_by: Option<String>,
contributing_to: Option<String>,
}
impl Parse for ScanRecurrentArgs {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
use syn::{Expr, Ident, LitInt, LitStr, Path, Token};
let mut out = Self::default();
if !input.is_empty() && input.peek(Ident) && !input.peek2(Token![=]) {
let path: Path = input.parse()?;
out.antigen_type = path.segments.last().map(|s| s.ident.to_string());
if !input.is_empty() {
let _ = input.parse::<Token![,]>();
}
}
while !input.is_empty() {
let key: Ident = input.parse()?;
let _ = input.parse::<Token![=]>()?;
match key.to_string().as_str() {
"name" => {
let lit: LitStr = input.parse()?;
out.name = Some(lit.value());
}
"antigen" => {
let path: Path = input.parse()?;
out.antigen_type = path.segments.last().map(|s| s.ident.to_string());
}
"description" | "summary" => {
let lit: LitStr = input.parse()?;
out.description = Some(lit.value());
}
"instances" => {
let lit: LitInt = input.parse()?;
out.instances = lit.base10_parse::<u64>().ok();
}
"since" => {
let lit: LitStr = input.parse()?;
out.since = Some(lit.value());
}
"rationale" => {
let lit: LitStr = input.parse()?;
out.rationale = Some(lit.value());
}
"from_itches" => {
let arr: syn::ExprArray = input.parse()?;
for elem in &arr.elems {
if let Expr::Path(p) = elem {
if let Some(seg) = p.path.segments.last() {
out.from_itches.push(seg.ident.to_string());
}
}
}
}
"anchored_by" => {
let arr: syn::ExprArray = input.parse()?;
for elem in &arr.elems {
if let Expr::Path(p) = elem {
if let Some(seg) = p.path.segments.last() {
out.anchored_by.push(seg.ident.to_string());
}
}
}
}
"managed_by" => {
let lit: LitStr = input.parse()?;
out.managed_by = Some(lit.value());
}
"contributing_to" => {
let lit: LitStr = input.parse()?;
out.contributing_to = Some(lit.value());
}
_ => {
let _: Expr = input.parse()?;
}
}
if !input.is_empty() {
let _ = input.parse::<Token![,]>();
}
}
Ok(out)
}
}
#[derive(Default)]
struct ScanMucosalArgs {
boundary_kind: Option<String>,
rationale: Option<String>,
handled_by: Option<String>,
accepts: Option<String>,
reviewed_by: Option<String>,
until: Option<String>,
}
impl Parse for ScanMucosalArgs {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
use syn::{Expr, Ident, LitStr, Path, Token};
let mut out = Self::default();
while !input.is_empty() {
let key: Ident = input.parse()?;
let _ = input.parse::<Token![=]>()?;
match key.to_string().as_str() {
"kind" | "boundary" => {
let path: Path = input.parse()?;
out.boundary_kind = path.segments.last().map(|s| s.ident.to_string());
}
"rationale" => {
let lit: LitStr = input.parse()?;
out.rationale = Some(lit.value());
}
"handled_by" => {
let path: Path = input.parse()?;
out.handled_by = path.segments.last().map(|s| s.ident.to_string());
}
"accepts" => {
let lit: LitStr = input.parse()?;
out.accepts = Some(lit.value());
}
"reviewed_by" => {
let lit: LitStr = input.parse()?;
out.reviewed_by = Some(lit.value());
}
"until" => {
let lit: LitStr = input.parse()?;
out.until = Some(lit.value());
}
_ => {
let _: Expr = input.parse()?;
}
}
if !input.is_empty() {
let _ = input.parse::<Token![,]>();
}
}
Ok(out)
}
}
#[derive(Default)]
struct ScanPrescriptiveArgs {
items: Vec<String>,
filled_by: Vec<String>,
reviewed_by: Vec<String>,
ordered_by: Option<String>,
frame: Option<String>,
need_text: Option<String>,
label: Option<String>,
}
fn prescriptive_str_array(input: syn::parse::ParseStream) -> syn::Result<Vec<String>> {
let arr: syn::ExprArray = input.parse()?;
let mut v = Vec::new();
for elem in &arr.elems {
if let syn::Expr::Lit(syn::ExprLit {
lit: syn::Lit::Str(s),
..
}) = elem
{
v.push(s.value());
}
}
Ok(v)
}
impl Parse for ScanPrescriptiveArgs {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
use syn::{Expr, Ident, LitStr, Token};
let str_array = prescriptive_str_array;
let mut out = Self::default();
while !input.is_empty() {
let key: Ident = input.parse()?;
let _ = input.parse::<Token![=]>()?;
match key.to_string().as_str() {
"needs" | "rule_out" | "priority_order" => out.items = str_array(input)?,
"filled_by" => out.filled_by = str_array(input)?,
"to" | "deep_investigation_by" | "investigator" | "triaged_by" => {
let lit: LitStr = input.parse()?;
out.filled_by.push(lit.value());
}
"reviewed_by" => out.reviewed_by = str_array(input)?,
"reviewer" => {
let lit: LitStr = input.parse()?;
out.reviewed_by.push(lit.value());
}
"ordered_by" => {
let lit: LitStr = input.parse()?;
out.ordered_by = Some(lit.value());
}
"due" | "response_due" | "re_triage_due" | "runs_until" | "until" => {
let lit: LitStr = input.parse()?;
out.frame = Some(lit.value());
}
"treatment" | "request_text" | "symptom" | "test_kind" | "reason" => {
let lit: LitStr = input.parse()?;
out.need_text = Some(lit.value());
}
"diagnosis" | "location" | "scope" => {
let lit: LitStr = input.parse()?;
out.label = Some(lit.value());
}
_ => {
let _: Expr = input.parse()?;
}
}
if !input.is_empty() {
let _ = input.parse::<Token![,]>();
}
}
Ok(out)
}
}
struct ScanAnergyArgs {
antigen_type: Option<String>,
reason: String,
until: String,
expected_co_stimulation: Option<String>,
signed_by: Option<String>,
}
impl Parse for ScanAnergyArgs {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
use syn::{Expr, Ident, LitStr, Path, Token};
let mut antigen_type: Option<String> = None;
let mut reason = String::new();
let mut until = String::new();
let mut expected_co_stimulation: Option<String> = None;
let mut signed_by: Option<String> = None;
if !input.is_empty() && input.peek(Ident) && !input.peek2(Token![=]) {
let path: Path = input.parse()?;
antigen_type = path.segments.last().map(|s| s.ident.to_string());
if !input.is_empty() {
let _ = input.parse::<Token![,]>();
}
}
while !input.is_empty() {
let key: Ident = input.parse()?;
let _ = input.parse::<Token![=]>()?;
match key.to_string().as_str() {
"reason" => {
let lit: LitStr = input.parse()?;
reason = lit.value();
}
"until" => {
let lit: LitStr = input.parse()?;
until = lit.value();
}
"expected_co_stimulation" => {
let lit: LitStr = input.parse()?;
expected_co_stimulation = Some(lit.value());
}
"signed_by" => {
let lit: LitStr = input.parse()?;
signed_by = Some(lit.value());
}
_ => {
let _: Expr = input.parse()?;
}
}
if !input.is_empty() {
let _ = input.parse::<Token![,]>();
}
}
Ok(Self {
antigen_type,
reason,
until,
expected_co_stimulation,
signed_by,
})
}
}
struct ScanImmunosuppressArgs {
antigen_type: Option<String>,
rationale: String,
until: String,
since: Option<String>,
duration_cap: Option<u64>,
signed_by: Option<String>,
}
impl Parse for ScanImmunosuppressArgs {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
use syn::{Expr, Ident, LitInt, LitStr, Path, Token};
let mut antigen_type: Option<String> = None;
let mut rationale = String::new();
let mut until = String::new();
let mut since: Option<String> = None;
let mut duration_cap: Option<u64> = None;
let mut signed_by: Option<String> = None;
if !input.is_empty() && input.peek(Ident) && !input.peek2(Token![=]) {
let path: Path = input.parse()?;
antigen_type = path.segments.last().map(|s| s.ident.to_string());
if !input.is_empty() {
let _ = input.parse::<Token![,]>();
}
}
while !input.is_empty() {
let key: Ident = input.parse()?;
let _ = input.parse::<Token![=]>()?;
match key.to_string().as_str() {
"rationale" => {
let lit: LitStr = input.parse()?;
rationale = lit.value();
}
"until" => {
let lit: LitStr = input.parse()?;
until = lit.value();
}
"since" => {
let lit: LitStr = input.parse()?;
since = Some(lit.value());
}
"duration_cap" => {
let lit: LitInt = input.parse()?;
duration_cap = lit.base10_parse::<u64>().ok();
}
"signed_by" => {
let lit: LitStr = input.parse()?;
signed_by = Some(lit.value());
}
_ => {
let _: Expr = input.parse()?;
}
}
if !input.is_empty() {
let _ = input.parse::<Token![,]>();
}
}
Ok(Self {
antigen_type,
rationale,
until,
since,
duration_cap,
signed_by,
})
}
}
struct ScanPoxpartyArgs {
antigen_type: Option<String>,
exercise_type: String,
until: String,
name: Option<String>,
rationale: Option<String>,
signed_by: Option<String>,
}
impl Parse for ScanPoxpartyArgs {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
use syn::{Expr, Ident, LitStr, Path, Token};
let mut antigen_type: Option<String> = None;
let mut exercise_type = String::new();
let mut until = String::new();
let mut name: Option<String> = None;
let mut rationale: Option<String> = None;
let mut signed_by: Option<String> = None;
if !input.is_empty() && input.peek(Ident) && !input.peek2(Token![=]) {
let path: Path = input.parse()?;
antigen_type = path.segments.last().map(|s| s.ident.to_string());
if !input.is_empty() {
let _ = input.parse::<Token![,]>();
}
}
while !input.is_empty() {
let key: Ident = input.parse()?;
let _ = input.parse::<Token![=]>()?;
match key.to_string().as_str() {
"exercise_type" => {
let lit: LitStr = input.parse()?;
exercise_type = lit.value();
}
"until" => {
let lit: LitStr = input.parse()?;
until = lit.value();
}
"name" => {
let lit: LitStr = input.parse()?;
name = Some(lit.value());
}
"rationale" => {
let lit: LitStr = input.parse()?;
rationale = Some(lit.value());
}
"signed_by" => {
let lit: LitStr = input.parse()?;
signed_by = Some(lit.value());
}
_ => {
let _: Expr = input.parse()?;
}
}
if !input.is_empty() {
let _ = input.parse::<Token![,]>();
}
}
Ok(Self {
antigen_type,
exercise_type,
until,
name,
rationale,
signed_by,
})
}
}
struct ScanOrientArgs {
antigen_type: Option<String>,
see: Vec<String>,
adr: Option<String>,
#[allow(dead_code)]
attestation_optional: bool,
}
impl Parse for ScanOrientArgs {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
use syn::{Expr, Ident, Lit, LitStr, Path, Token};
let mut antigen_type: Option<String> = None;
let mut see: Vec<String> = Vec::new();
let mut adr: Option<String> = None;
let mut attestation_optional = false;
if !input.is_empty() && input.peek(Ident) && !input.peek2(Token![=]) {
let fork = input.fork();
let ident: Ident = fork
.parse()
.unwrap_or_else(|_| Ident::new("_", proc_macro2::Span::call_site()));
if ident == "attestation_optional" && (fork.is_empty() || fork.peek(Token![,])) {
let _: Ident = input.parse()?;
attestation_optional = true;
} else {
let path: Path = input.parse()?;
antigen_type = path.segments.last().map(|s| s.ident.to_string());
}
if !input.is_empty() {
let _ = input.parse::<Token![,]>();
}
}
while !input.is_empty() {
if input.peek(Ident) {
let fork = input.fork();
let ident: Ident = fork
.parse()
.unwrap_or_else(|_| Ident::new("_", proc_macro2::Span::call_site()));
if ident == "attestation_optional" && (fork.is_empty() || fork.peek(Token![,])) {
let _: Ident = input.parse()?;
attestation_optional = true;
if !input.is_empty() {
let _ = input.parse::<Token![,]>();
}
continue;
}
}
let key: Ident = input.parse()?;
let _ = input.parse::<Token![=]>()?;
match key.to_string().as_str() {
"see" => {
let arr: syn::ExprArray = input.parse()?;
for elem in &arr.elems {
if let Expr::Lit(syn::ExprLit {
lit: Lit::Str(s), ..
}) = elem
{
see.push(s.value());
}
}
}
"adr" => {
let lit: LitStr = input.parse()?;
adr = Some(lit.value());
}
"attestation_optional" => {
let lit: syn::LitBool = input.parse()?;
attestation_optional = lit.value();
}
_ => {
let _: Expr = input.parse()?;
}
}
if !input.is_empty() {
let _ = input.parse::<Token![,]>();
}
}
Ok(Self {
antigen_type,
see,
adr,
attestation_optional,
})
}
}
struct ScanDiagnosticArgs {
modality_classes: Vec<String>,
min_independent: Option<u64>,
}
impl Parse for ScanDiagnosticArgs {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
use syn::{Expr, Ident, LitInt, Token};
let mut modality_classes = Vec::new();
let mut min_independent: Option<u64> = None;
while !input.is_empty() {
let key: Ident = input.parse()?;
let _ = input.parse::<Token![=]>()?;
match key.to_string().as_str() {
"modalities" => {
let arr: syn::ExprArray = input.parse()?;
for elem in &arr.elems {
if let Expr::Path(p) = elem {
if let Some(seg) = p.path.segments.last() {
modality_classes.push(seg.ident.to_string());
}
}
}
}
"min_independent" => {
let lit: LitInt = input.parse()?;
min_independent = lit.base10_parse::<u64>().ok();
}
_ => {
let _: Expr = input.parse()?;
}
}
if !input.is_empty() {
let _ = input.parse::<Token![,]>();
}
}
Ok(Self {
modality_classes,
min_independent,
})
}
}
struct ScanClonalArgs {
witness: Option<String>,
iterations: Option<u64>,
seed_kind: Option<String>,
}
impl Parse for ScanClonalArgs {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
use quote::ToTokens;
use syn::{Expr, Ident, LitInt, Token};
let mut witness: Option<String> = None;
let mut iterations: Option<u64> = None;
let mut seed_kind: Option<String> = None;
while !input.is_empty() {
let key: Ident = input.parse()?;
let _ = input.parse::<Token![=]>()?;
match key.to_string().as_str() {
"witness" => {
let e: Expr = input.parse()?;
witness = Some(e.to_token_stream().to_string());
}
"iterations" => {
let lit: LitInt = input.parse()?;
iterations = lit.base10_parse::<u64>().ok();
}
"seed" => {
let e: Expr = input.parse()?;
if let Expr::Path(p) = &e {
if let Some(seg) = p.path.segments.last() {
seed_kind = Some(seg.ident.to_string());
}
} else if let Expr::Call(c) = &e {
if let Expr::Path(p) = &*c.func {
if let Some(seg) = p.path.segments.last() {
seed_kind = Some(seg.ident.to_string());
}
}
}
}
_ => {
let _: Expr = input.parse()?;
}
}
if !input.is_empty() {
let _ = input.parse::<Token![,]>();
}
}
Ok(Self {
witness,
iterations,
seed_kind,
})
}
}
struct ScanIggArgs {
witnesses: Vec<String>,
historical_span: Option<u64>,
min_reattestations: Option<u64>,
}
impl Parse for ScanIggArgs {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
use quote::ToTokens;
use syn::{Expr, Ident, LitInt, Token};
let mut witnesses = Vec::new();
let mut historical_span: Option<u64> = None;
let mut min_reattestations: Option<u64> = None;
while !input.is_empty() {
let key: Ident = input.parse()?;
let _ = input.parse::<Token![=]>()?;
match key.to_string().as_str() {
"witnesses" => {
let arr: syn::ExprArray = input.parse()?;
for elem in &arr.elems {
witnesses.push(elem.to_token_stream().to_string());
}
}
"historical_span" => {
let lit: LitInt = input.parse()?;
historical_span = lit.base10_parse::<u64>().ok();
}
"min_reattestations" => {
let lit: LitInt = input.parse()?;
min_reattestations = lit.base10_parse::<u64>().ok();
}
_ => {
let _: Expr = input.parse()?;
}
}
if !input.is_empty() {
let _ = input.parse::<Token![,]>();
}
}
Ok(Self {
witnesses,
historical_span,
min_reattestations,
})
}
}
struct ScanCrossreactiveArgs {
fingerprints: Vec<String>,
}
impl Parse for ScanCrossreactiveArgs {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
use syn::{Expr, Ident, Lit, LitStr, Token};
let mut fingerprints = Vec::new();
while !input.is_empty() {
let key: Ident = input.parse()?;
let _ = input.parse::<Token![=]>()?;
match key.to_string().as_str() {
"fingerprints" => {
let arr: syn::ExprArray = input.parse()?;
for elem in &arr.elems {
if let Expr::Lit(syn::ExprLit {
lit: Lit::Str(s), ..
}) = elem
{
fingerprints.push(s.value());
}
}
}
_ => {
if input.peek(LitStr) {
let _: LitStr = input.parse()?;
} else {
let _: Expr = input.parse()?;
}
}
}
if !input.is_empty() {
let _ = input.parse::<Token![,]>();
}
}
Ok(Self { fingerprints })
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[presents(VecCardinalityMasqueradingAsSet)]
#[antigen_tolerance(
VecCardinalityMasqueradingAsSet,
rationale = "Accepted: `category` is a Vec modeling a set (each AntigenCategory meaningful at \
most once), so it structurally presents the masquerade shape. The duplicate-injection \
risk is DEFENDED UPSTREAM at the declaration boundary — AntigenArgs::validate() in \
antigen-macros rejects duplicate category variants at parse-time (fixed 30e10e6, pinned \
by antigen_parser_duplicate_category_in_array_is_rejected). It cannot be marked \
#[immune] here because the defense + witness live in the proc-macro crate, which the \
scanned struct's crate cannot reference (dependency-cycle + proc-macro-self-application \
constraints — see MarkerStructDeadCodeInBinary). So this scanned representation tolerates \
the shape; the real guard is one layer up at macro-validate.",
until = "v0.3"
)]
pub struct AntigenDeclaration {
pub name: String,
pub type_name: String,
pub file: PathBuf,
pub line: usize,
pub family: Option<String>,
pub summary: Option<String>,
pub fingerprint: Option<String>,
#[serde(default)]
pub canonical_path: Option<String>,
#[serde(default)]
pub category: Vec<crate::category::AntigenCategory>,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ItemTarget {
Struct(String),
Enum(String),
Trait(String),
Fn(String),
TypeAlias(String),
Impl {
trait_path: Option<String>,
target_type: String,
},
ImplFn {
trait_path: Option<String>,
target_type: String,
fn_name: String,
},
TraitFn {
trait_name: String,
fn_name: String,
},
EnumVariant {
enum_name: String,
variant_name: String,
},
ImplConst {
trait_path: Option<String>,
target_type: String,
const_name: String,
},
Const(String),
Static(String),
Union(String),
Unknown {
line: usize,
},
}
impl ItemTarget {
#[must_use]
pub fn label(&self) -> String {
match self {
Self::Struct(n)
| Self::Enum(n)
| Self::Trait(n)
| Self::Fn(n)
| Self::TypeAlias(n)
| Self::Const(n)
| Self::Static(n)
| Self::Union(n) => n.clone(),
Self::Impl {
trait_path: Some(t),
target_type,
} => format!("impl {t} for {target_type}"),
Self::Impl {
trait_path: None,
target_type,
} => format!("impl {target_type}"),
Self::ImplFn {
trait_path: Some(t),
target_type,
fn_name,
} => format!("<{target_type} as {t}>::{fn_name}"),
Self::ImplFn {
trait_path: None,
target_type,
fn_name,
} => format!("{target_type}::{fn_name}"),
Self::TraitFn {
trait_name,
fn_name,
} => format!("trait {trait_name}::{fn_name}"),
Self::EnumVariant {
enum_name,
variant_name,
} => format!("{enum_name}::{variant_name}"),
Self::ImplConst {
trait_path: Some(t),
target_type,
const_name,
} => format!("<{target_type} as {t}>::{const_name}"),
Self::ImplConst {
trait_path: None,
target_type,
const_name,
} => format!("{target_type}::{const_name}"),
Self::Unknown { line } => format!("<unknown at line {line}>"),
}
}
#[must_use]
#[allow(
clippy::match_same_arms,
reason = "the explicit `Unknown` arm is the load-bearing invariant — \
Unknown items must NEVER match anything, including each other. \
Keeping it explicit (even though it duplicates the `_` wildcard's \
body) makes the invariant readable and refactor-safe."
)]
pub fn addresses(&self, other: &Self) -> bool {
match (self, other) {
(Self::Unknown { .. }, _) | (_, Self::Unknown { .. }) => false,
(Self::Struct(a), Self::Struct(b))
| (Self::Enum(a), Self::Enum(b))
| (Self::Trait(a), Self::Trait(b))
| (Self::Fn(a), Self::Fn(b))
| (Self::TypeAlias(a), Self::TypeAlias(b))
| (Self::Const(a), Self::Const(b))
| (Self::Static(a), Self::Static(b))
| (Self::Union(a), Self::Union(b)) => a == b,
(
Self::Impl {
target_type: t1, ..
},
Self::Impl {
target_type: t2, ..
},
) => normalize_type_name(t1) == normalize_type_name(t2),
(
Self::ImplFn {
target_type: t1,
fn_name: f1,
..
},
Self::ImplFn {
target_type: t2,
fn_name: f2,
..
},
) => normalize_type_name(t1) == normalize_type_name(t2) && f1 == f2,
(
Self::TraitFn {
trait_name,
fn_name: tf,
},
Self::ImplFn {
trait_path: Some(t),
fn_name: imf,
..
},
)
| (
Self::ImplFn {
trait_path: Some(t),
fn_name: imf,
..
},
Self::TraitFn {
trait_name,
fn_name: tf,
},
) => trait_name == t && tf == imf,
(
Self::TraitFn {
trait_name: t1,
fn_name: f1,
},
Self::TraitFn {
trait_name: t2,
fn_name: f2,
},
) => t1 == t2 && f1 == f2,
(
Self::EnumVariant {
enum_name: e1,
variant_name: v1,
},
Self::EnumVariant {
enum_name: e2,
variant_name: v2,
},
) => e1 == e2 && v1 == v2,
(
Self::ImplConst {
target_type: t1,
const_name: c1,
..
},
Self::ImplConst {
target_type: t2,
const_name: c2,
..
},
) => normalize_type_name(t1) == normalize_type_name(t2) && c1 == c2,
_ => false,
}
}
}
fn normalize_type_name(rendered: &str) -> String {
let s = rendered.trim();
s.find('<')
.map_or_else(|| s.to_string(), |idx| s[..idx].trim().to_string())
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum MatchKind {
#[default]
ExplicitMarker,
FingerprintMatch,
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
pub struct ProvenanceEntry {
pub antigen_type: String,
pub canonical_path: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Presentation {
pub antigen_type: String,
pub file: PathBuf,
pub line: usize,
pub item_kind: String,
pub item_target: ItemTarget,
#[serde(default)]
pub match_kind: MatchKind,
#[serde(default)]
pub canonical_path: Option<String>,
#[serde(default)]
pub inherited_from: Option<Vec<ProvenanceEntry>>,
#[serde(default)]
pub structural_fingerprint: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub requires_predicate: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub proof: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Immunity {
pub antigen_type: String,
pub witness: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub requires_predicate: Option<String>,
pub file: PathBuf,
pub line: usize,
pub item_kind: String,
pub item_target: ItemTarget,
#[serde(default)]
pub canonical_path: Option<String>,
#[serde(default)]
pub structural_fingerprint: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Defense {
pub antigen_type: String,
pub file: PathBuf,
pub line: usize,
pub item_kind: String,
pub item_target: ItemTarget,
#[serde(default)]
pub canonical_path: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GeneratesDeclaration {
pub antigen_type: String,
pub rationale: String,
pub macro_name: String,
pub file: PathBuf,
pub line: usize,
#[serde(default)]
pub canonical_path: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Toleration {
pub antigen_type: String,
pub rationale: String,
pub until: Option<String>,
pub see: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub requires_predicate: Option<String>,
pub file: PathBuf,
pub line: usize,
pub item_kind: String,
pub item_target: ItemTarget,
#[serde(default)]
pub canonical_path: Option<String>,
#[serde(default)]
pub structural_fingerprint: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum DeferredDefenseKind {
Anergy,
Immunosuppress,
Poxparty,
Orient,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DeferredDefense {
pub kind: DeferredDefenseKind,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub antigen_type: Option<String>,
pub text: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub until: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub expected_co_stimulation: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub signed_by: Option<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub see: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub since: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub duration_cap: Option<u64>,
pub file: PathBuf,
pub line: usize,
pub item_kind: String,
pub item_target: ItemTarget,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum ConvergentEvidenceKind {
Diagnostic,
Clonal,
Igg,
Crossreactive,
Polyclonal,
Monoclonal,
Adcc,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConvergentEvidence {
pub kind: ConvergentEvidenceKind,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub modality_classes: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub min_independent: Option<u64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub witness: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub iterations: Option<u64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub seed_kind: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub historical_span: Option<u64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub min_reattestations: Option<u64>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub witnesses: Vec<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub fingerprints: Vec<String>,
pub file: PathBuf,
pub line: usize,
pub item_kind: String,
pub item_target: ItemTarget,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum RecurrentKind {
Itch,
RecurrenceAnchor,
Crystallize,
Chronic,
Saturate,
Strand,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RecurrentDeclaration {
pub kind: RecurrentKind,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub antigen_type: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub instances: Option<u64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub since: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub rationale: Option<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub from_itches: Vec<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub anchored_by: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub managed_by: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub contributing_to: Option<String>,
pub file: PathBuf,
pub line: usize,
pub item_kind: String,
pub item_target: ItemTarget,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum MucosalKindTag {
Mucosal,
MucosalDelegate,
MucosalTolerant,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MucosalDeclaration {
pub tag: MucosalKindTag,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub boundary_kind: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub rationale: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub handled_by: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub accepts: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub reviewed_by: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub until: Option<String>,
pub file: PathBuf,
pub line: usize,
pub item_kind: String,
pub item_target: ItemTarget,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum PrescriptiveKind {
Panel,
Rx,
Refer,
Biopsy,
Ddx,
Triage,
Culture,
Quarantine,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum WorkShape {
RoleWorkflow,
Elimination,
Ordering,
FrameOnly,
}
impl PrescriptiveKind {
#[must_use]
pub const fn shape(self) -> WorkShape {
match self {
Self::Panel | Self::Rx | Self::Refer | Self::Biopsy => WorkShape::RoleWorkflow,
Self::Ddx => WorkShape::Elimination,
Self::Triage => WorkShape::Ordering,
Self::Culture | Self::Quarantine => WorkShape::FrameOnly,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PrescriptiveDeclaration {
pub kind: PrescriptiveKind,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub items: Vec<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub filled_by: Vec<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub reviewed_by: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub ordered_by: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub frame: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub need_text: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub label: Option<String>,
pub file: PathBuf,
pub line: usize,
pub item_kind: String,
pub item_target: ItemTarget,
#[serde(default)]
pub structural_fingerprint: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ParseFailure {
pub file: PathBuf,
pub error: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LineageEdge {
pub child: String,
pub parent: String,
pub file: PathBuf,
pub line: usize,
#[serde(default)]
pub parent_canonical_path: Option<String>,
#[serde(default)]
pub child_canonical_path: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ScanReport {
pub antigens: Vec<AntigenDeclaration>,
pub presentations: Vec<Presentation>,
pub immunities: Vec<Immunity>,
#[serde(default)]
pub tolerances: Vec<Toleration>,
#[serde(default)]
pub lineage_edges: Vec<LineageEdge>,
#[serde(default)]
pub deferred_defenses: Vec<DeferredDefense>,
#[serde(default)]
pub convergent_evidences: Vec<ConvergentEvidence>,
#[serde(default)]
pub recurrent_declarations: Vec<RecurrentDeclaration>,
#[serde(default)]
pub mucosal_declarations: Vec<MucosalDeclaration>,
#[serde(default)]
pub prescriptive_declarations: Vec<PrescriptiveDeclaration>,
#[serde(default)]
pub defenses: Vec<Defense>,
#[serde(default)]
pub generates_declarations: Vec<GeneratesDeclaration>,
pub files_scanned: usize,
pub parse_failures: Vec<ParseFailure>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub scan_coverage: Option<ScanCoverage>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ScanCoverage {
pub enumerated_members: Vec<String>,
pub scanned_members: Vec<String>,
}
impl ScanCoverage {
#[must_use]
pub fn unscanned_members(&self) -> Vec<&str> {
let scanned: std::collections::HashSet<&str> =
self.scanned_members.iter().map(String::as_str).collect();
let mut seen: std::collections::HashSet<&str> = std::collections::HashSet::new();
self.enumerated_members
.iter()
.map(String::as_str)
.filter(|m| !scanned.contains(m) && seen.insert(m))
.collect()
}
#[must_use]
pub fn is_complete(&self) -> bool {
self.unscanned_members().is_empty()
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UnaddressedPresentation {
pub presentation: Presentation,
pub antigen_known: bool,
}
#[derive(Debug, Clone, Default)]
pub struct PartitionedPresentations {
pub explicit: Vec<UnaddressedPresentation>,
pub inferred: Vec<UnaddressedPresentation>,
}
impl ScanReport {
#[must_use]
pub fn unaddressed_presentations(&self) -> Vec<UnaddressedPresentation> {
let known_antigens: std::collections::HashSet<(&str, Option<&str>)> = self
.antigens
.iter()
.map(|a| (a.type_name.as_str(), a.canonical_path.as_deref()))
.collect();
let mut result = Vec::new();
for p in &self.presentations {
let has_matching_immunity =
self.immunities.iter().any(|i| addresses_for_immunity(i, p));
let has_matching_tolerance = self
.tolerances
.iter()
.any(|t| addresses_for_tolerance(t, p));
let has_matching_defense = self.defenses.iter().any(|d| defense_addresses(d, p));
if !has_matching_immunity && !has_matching_tolerance && !has_matching_defense {
result.push(UnaddressedPresentation {
presentation: p.clone(),
antigen_known: known_antigens
.contains(&(p.antigen_type.as_str(), p.canonical_path.as_deref())),
});
}
}
result
}
#[must_use]
pub fn partitioned_presentations(&self) -> PartitionedPresentations {
let mut out = PartitionedPresentations::default();
for up in self.unaddressed_presentations() {
match up.presentation.match_kind {
MatchKind::ExplicitMarker => out.explicit.push(up),
MatchKind::FingerprintMatch => out.inferred.push(up),
}
}
out
}
#[must_use]
pub fn orphaned_tolerances(&self) -> Vec<&Toleration> {
let known: std::collections::HashSet<(&str, Option<&str>)> = self
.antigens
.iter()
.map(|a| (a.type_name.as_str(), a.canonical_path.as_deref()))
.collect();
self.tolerances
.iter()
.filter(|t| !known.contains(&(t.antigen_type.as_str(), t.canonical_path.as_deref())))
.collect()
}
#[must_use]
pub fn orphaned_lineage_edges(&self) -> Vec<&LineageEdge> {
let known: std::collections::HashSet<(&str, Option<&str>)> = self
.antigens
.iter()
.map(|a| (a.type_name.as_str(), a.canonical_path.as_deref()))
.collect();
self.lineage_edges
.iter()
.filter(|e| !known.contains(&(e.parent.as_str(), e.parent_canonical_path.as_deref())))
.collect()
}
#[must_use]
pub fn dangling_child_lineage_edges(&self) -> Vec<&LineageEdge> {
let known: std::collections::HashSet<(&str, Option<&str>)> = self
.antigens
.iter()
.map(|a| (a.type_name.as_str(), a.canonical_path.as_deref()))
.collect();
self.lineage_edges
.iter()
.filter(|e| !known.contains(&(e.child.as_str(), e.child_canonical_path.as_deref())))
.collect()
}
pub fn stamp_canonical_path(&mut self, crate_id: &str) {
for a in &mut self.antigens {
if a.canonical_path.is_none() {
a.canonical_path = Some(crate_id.to_string());
}
}
for p in &mut self.presentations {
if p.canonical_path.is_none() {
p.canonical_path = Some(crate_id.to_string());
}
}
for i in &mut self.immunities {
if i.canonical_path.is_none() {
i.canonical_path = Some(crate_id.to_string());
}
}
for t in &mut self.tolerances {
if t.canonical_path.is_none() {
t.canonical_path = Some(crate_id.to_string());
}
}
for d in &mut self.defenses {
if d.canonical_path.is_none() {
d.canonical_path = Some(crate_id.to_string());
}
}
for g in &mut self.generates_declarations {
if g.canonical_path.is_none() {
g.canonical_path = Some(crate_id.to_string());
}
}
for e in &mut self.lineage_edges {
if e.parent_canonical_path.is_none() {
e.parent_canonical_path = Some(crate_id.to_string());
}
if e.child_canonical_path.is_none() {
e.child_canonical_path = Some(crate_id.to_string());
}
}
}
#[must_use]
pub fn total_declarations(&self) -> usize {
self.antigens.len()
+ self.presentations.len()
+ self.immunities.len()
+ self.tolerances.len()
}
}
fn locus_matches(
a_path: &std::path::Path,
a_canonical: Option<&str>,
b_path: &std::path::Path,
b_canonical: Option<&str>,
) -> bool {
match (a_canonical, b_canonical) {
(None, None) => a_path == b_path,
(Some(x), Some(y)) => x == y,
_ => false,
}
}
fn addresses_for_immunity(i: &Immunity, p: &Presentation) -> bool {
i.antigen_type == p.antigen_type
&& canonical_paths_match(i.canonical_path.as_deref(), p.canonical_path.as_deref())
&& i.item_target.addresses(&p.item_target)
&& locus_matches(
i.file.as_path(),
i.canonical_path.as_deref(),
p.file.as_path(),
p.canonical_path.as_deref(),
)
}
fn addresses_for_tolerance(t: &Toleration, p: &Presentation) -> bool {
t.antigen_type == p.antigen_type
&& canonical_paths_match(t.canonical_path.as_deref(), p.canonical_path.as_deref())
&& t.item_target.addresses(&p.item_target)
&& locus_matches(
t.file.as_path(),
t.canonical_path.as_deref(),
p.file.as_path(),
p.canonical_path.as_deref(),
)
}
#[must_use]
pub(crate) fn defense_addresses(d: &Defense, p: &Presentation) -> bool {
d.antigen_type == p.antigen_type
&& canonical_paths_match(d.canonical_path.as_deref(), p.canonical_path.as_deref())
}
#[must_use]
pub(crate) fn canonical_paths_match(
item_canonical_path: Option<&str>,
decl_canonical_path: Option<&str>,
) -> bool {
item_canonical_path == decl_canonical_path
}
pub(crate) const MAX_LINEAGE_DEPTH: usize = 64;
fn dedupe_lineage_edges(edges: &[LineageEdge]) -> (Vec<LineageEdge>, Vec<ParseFailure>) {
use std::collections::{HashMap, HashSet};
type DedupKey<'a> = (&'a str, &'a str, Option<&'a str>, Option<&'a str>);
fn key_of(edge: &LineageEdge) -> DedupKey<'_> {
(
edge.child.as_str(),
edge.parent.as_str(),
edge.child_canonical_path.as_deref(),
edge.parent_canonical_path.as_deref(),
)
}
let mut counts: HashMap<DedupKey<'_>, usize> = HashMap::new();
for edge in edges {
*counts.entry(key_of(edge)).or_insert(0) += 1;
}
let mut emitted: HashSet<DedupKey<'_>> = HashSet::new();
let mut deduped: Vec<LineageEdge> = Vec::with_capacity(edges.len());
let mut failures: Vec<ParseFailure> = Vec::new();
for edge in edges {
let key = key_of(edge);
let count = counts.get(&key).copied().unwrap_or(0);
if emitted.insert(key) {
deduped.push(edge.clone());
if count > 1 {
failures.push(ParseFailure {
file: edge.file.clone(),
error: format!(
"duplicate #[descended_from({})] declarations on `{}` \
(first at line {}); structural lies surface as \
diagnostics rather than being silently collapsed \
(ADR-004 implicit-to-explicit elevation)",
edge.parent, edge.child, edge.line
),
});
}
}
}
(deduped, failures)
}
fn detect_lineage_failures(edges: &[LineageEdge], max_depth: usize) -> Vec<ParseFailure> {
use std::collections::HashMap;
let mut failures: Vec<ParseFailure> = Vec::new();
let mut adjacency: HashMap<&str, Vec<(&str, usize)>> = HashMap::new();
for (idx, edge) in edges.iter().enumerate() {
adjacency
.entry(edge.child.as_str())
.or_default()
.push((edge.parent.as_str(), idx));
}
let mut color: HashMap<&str, u8> = HashMap::new();
let mut reported_cycles: std::collections::HashSet<Vec<String>> =
std::collections::HashSet::new();
let mut roots_in_order: Vec<&str> = Vec::new();
let mut seen_roots: std::collections::HashSet<&str> = std::collections::HashSet::new();
for edge in edges {
let c = edge.child.as_str();
if seen_roots.insert(c) {
roots_in_order.push(c);
}
}
for &root in &roots_in_order {
if color.contains_key(root) {
continue;
}
let mut stack: Vec<(&str, usize)> = Vec::new();
let mut path: Vec<&str> = Vec::new();
color.insert(root, 1);
stack.push((root, 0));
path.push(root);
while let Some(&mut (node, ref mut idx)) = stack.last_mut() {
if path.len() > max_depth {
let leaf = *path.last().unwrap_or(&node);
let anchor = adjacency
.get(leaf)
.and_then(|v| v.first())
.and_then(|(_, edge_idx)| edges.get(*edge_idx))
.map_or_else(PathBuf::new, |e| e.file.clone());
failures.push(ParseFailure {
file: anchor,
error: format!(
"#[descended_from] chain exceeds maximum depth ({max_depth}) at \
`{leaf}`; chain: {}",
path.join(" -> ")
),
});
color.insert(node, 2);
stack.pop();
path.pop();
continue;
}
let children = adjacency.get(node).map_or(&[][..], Vec::as_slice);
if *idx >= children.len() {
color.insert(node, 2);
stack.pop();
path.pop();
continue;
}
let (child, edge_idx) = children[*idx];
*idx += 1;
match color.get(child).copied().unwrap_or(0) {
0 => {
color.insert(child, 1);
path.push(child);
stack.push((child, 0));
}
1 => {
let cycle_start = path.iter().position(|n| *n == child).unwrap_or(0);
let bare_refs: Vec<&str> = path[cycle_start..].to_vec();
let mut cycle_chain: Vec<String> =
bare_refs.iter().map(|s| (*s).to_string()).collect();
cycle_chain.push(child.to_string());
let canonical = canonicalise_cycle(&bare_refs);
if reported_cycles.insert(canonical) {
let edge = edges.get(edge_idx);
let file = edge.map_or_else(PathBuf::new, |e| e.file.clone());
let line = edge.map_or(0, |e| e.line);
failures.push(ParseFailure {
file,
error: format!(
"#[descended_from] forms a cycle (closing edge at line \
{line}): {}",
cycle_chain.join(" -> ")
),
});
}
}
_ => {
}
}
}
}
failures
}
fn canonicalise_cycle(bare: &[&str]) -> Vec<String> {
if bare.is_empty() {
return Vec::new();
}
let n = bare.len();
let mut best_start = 0;
for start in 1..n {
for i in 0..n {
let a = bare[(start + i) % n];
let b = bare[(best_start + i) % n];
if a < b {
best_start = start;
break;
} else if a > b {
break;
}
}
}
(0..n)
.map(|i| bare[(best_start + i) % n].to_string())
.collect()
}
#[presents(ScannerBoundaryFalseNegative)]
#[antigen_tolerance(
ScannerBoundaryFalseNegative,
rationale = "Accepted v0.2 limitation: the scan is a static-heuristic walk that surfaces only \
explicitly-declared #[mucosal]/#[presents] sites — it cannot infer implicit trust \
boundaries from parameter types or call sites, by design (ADR-006 recognition-not-design: \
the scan recognizes declared structure, it does not guess). Adopters mark boundaries \
explicitly; the false-negative on unmarked sites is the honest cost of not guessing.",
until = "v0.3"
)]
pub fn scan_workspace(root: &Path, excluded_dirs: Option<&[&str]>) -> std::io::Result<ScanReport> {
let default_exclusions = ["target", ".git", "node_modules"];
let exclusions = excluded_dirs.unwrap_or(&default_exclusions);
let mut report = ScanReport::default();
let mut parsed_files: Vec<(PathBuf, syn::File)> = Vec::new();
for entry in WalkDir::new(root)
.follow_links(false)
.into_iter()
.filter_entry(|e| {
if e.file_type().is_dir() {
let name = e.file_name().to_string_lossy();
!exclusions.iter().any(|x| *x == name)
} else {
true
}
})
{
let Ok(entry) = entry else { continue };
if !entry.file_type().is_file() {
continue;
}
if entry.path().extension().and_then(|e| e.to_str()) != Some("rs") {
continue;
}
let Ok(content) = std::fs::read_to_string(entry.path()) else {
continue;
};
match syn::parse_file(&content) {
Ok(file) => {
let file_path = entry.path().to_path_buf();
let mut visitor = ScanVisitor {
file_path: file_path.clone(),
report: &mut report,
impl_stack: Vec::new(),
trait_stack: Vec::new(),
current_item_digest: String::new(),
};
visitor.visit_file(&file);
report.files_scanned += 1;
parsed_files.push((file_path, file));
}
Err(e) => {
report.parse_failures.push(ParseFailure {
file: entry.path().to_path_buf(),
error: e.to_string(),
});
}
}
}
let (deduped_edges, dedup_failures) = dedupe_lineage_edges(&report.lineage_edges);
report.lineage_edges = deduped_edges;
report.parse_failures.extend(dedup_failures);
let lineage_failures = detect_lineage_failures(&report.lineage_edges, MAX_LINEAGE_DEPTH);
report.parse_failures.extend(lineage_failures);
finalize_report(&mut report, &parsed_files);
Ok(report)
}
fn finalize_report(report: &mut ScanReport, parsed_files: &[(PathBuf, syn::File)]) {
let mut fp_parse_failures: Vec<ParseFailure> = Vec::new();
let fingerprints: Vec<(String, antigen_fingerprint::Fingerprint)> = report
.antigens
.iter()
.filter_map(|ag| {
let raw = ag.fingerprint.as_deref()?;
match antigen_fingerprint::Fingerprint::parse(raw) {
Ok(fp) => Some((ag.type_name.clone(), fp)),
Err(e) => {
fp_parse_failures.push(ParseFailure {
file: ag.file.clone(),
error: format!(
"antigen `{}`: fingerprint failed to re-parse during synthesis: {e}",
ag.type_name
),
});
None
}
}
})
.collect();
report.parse_failures.extend(fp_parse_failures);
if !fingerprints.is_empty() {
let declaration_sites: std::collections::HashSet<(String, PathBuf)> = report
.antigens
.iter()
.map(|ag| (ag.type_name.clone(), ag.file.clone()))
.collect();
synthesis_pass(parsed_files, &fingerprints, &declaration_sites, report);
}
if !report.generates_declarations.is_empty() {
generates_synthesis_pass(parsed_files, report);
}
synthesize_inherited_presentations(report);
}
fn synthesize_inherited_presentations(report: &mut ScanReport) {
use std::collections::HashMap;
let antigen_by_key: HashMap<AntigenKey, AntigenDeclaration> = report
.antigens
.iter()
.map(|a| ((a.type_name.clone(), a.canonical_path.clone()), a.clone()))
.collect();
let mut adjacency: LineageAdjacency = LineageAdjacency::new();
for e in &report.lineage_edges {
let child_key = (e.child.clone(), e.child_canonical_path.clone());
let parent_key = (e.parent.clone(), e.parent_canonical_path.clone());
if !antigen_by_key.contains_key(&child_key) || !antigen_by_key.contains_key(&parent_key) {
continue;
}
adjacency.entry(child_key).or_default().push(parent_key);
}
let presentations_snapshot: Vec<Presentation> = report.presentations.clone();
let mut presentations_by_antigen: HashMap<AntigenKey, Vec<usize>> = HashMap::new();
for (idx, p) in presentations_snapshot.iter().enumerate() {
presentations_by_antigen
.entry((p.antigen_type.clone(), p.canonical_path.clone()))
.or_default()
.push(idx);
}
for child_decl in report.antigens.clone() {
let child_key = (
child_decl.type_name.clone(),
child_decl.canonical_path.clone(),
);
if !adjacency.contains_key(&child_key) {
continue;
}
let ancestors_in_order = transitive_ancestors_dfs(&adjacency, &child_key);
propagate_ancestors_to_descendant(
report,
&child_decl,
&ancestors_in_order,
&presentations_snapshot,
&presentations_by_antigen,
);
}
}
type AntigenKey = (String, Option<String>);
type LineageAdjacency = std::collections::HashMap<AntigenKey, Vec<AntigenKey>>;
fn transitive_ancestors_dfs(
adjacency: &LineageAdjacency,
child_key: &AntigenKey,
) -> Vec<AntigenKey> {
use std::collections::HashSet;
let mut visited: HashSet<AntigenKey> = HashSet::new();
let mut stack: Vec<AntigenKey> = adjacency.get(child_key).cloned().unwrap_or_default();
let mut ancestors_in_order: Vec<AntigenKey> = Vec::new();
while let Some(node) = stack.pop() {
if !visited.insert(node.clone()) {
continue;
}
ancestors_in_order.push(node.clone());
if let Some(parents) = adjacency.get(&node) {
for parent in parents.iter().rev() {
if !visited.contains(parent) {
stack.push(parent.clone());
}
}
}
}
ancestors_in_order
}
fn propagate_ancestors_to_descendant(
report: &mut ScanReport,
child_decl: &AntigenDeclaration,
ancestors_in_order: &[AntigenKey],
presentations_snapshot: &[Presentation],
presentations_by_antigen: &std::collections::HashMap<AntigenKey, Vec<usize>>,
) {
use std::collections::BTreeSet;
let descendant_item_target = ItemTarget::Struct(child_decl.type_name.clone());
let descendant_item_kind = "struct".to_string();
for ancestor_key in ancestors_in_order {
let provenance = ProvenanceEntry {
antigen_type: ancestor_key.0.clone(),
canonical_path: ancestor_key.1.clone(),
};
let Some(ancestor_pres_indices) = presentations_by_antigen.get(ancestor_key) else {
continue;
};
for &ancestor_pres_idx in ancestor_pres_indices {
let ancestor_pres = &presentations_snapshot[ancestor_pres_idx];
let existing_idx = report.presentations.iter().position(|p| {
p.antigen_type == ancestor_pres.antigen_type
&& p.canonical_path == ancestor_pres.canonical_path
&& p.item_target.addresses(&descendant_item_target)
&& locus_matches(
p.file.as_path(),
p.canonical_path.as_deref(),
child_decl.file.as_path(),
child_decl.canonical_path.as_deref(),
)
});
if let Some(idx) = existing_idx {
let existing = &mut report.presentations[idx];
let mut chain: BTreeSet<ProvenanceEntry> = existing
.inherited_from
.take()
.unwrap_or_default()
.into_iter()
.collect();
chain.insert(provenance.clone());
existing.inherited_from = Some(chain.into_iter().collect());
} else {
report.presentations.push(Presentation {
antigen_type: ancestor_pres.antigen_type.clone(),
file: child_decl.file.clone(),
line: child_decl.line,
item_kind: descendant_item_kind.clone(),
item_target: descendant_item_target.clone(),
match_kind: ancestor_pres.match_kind.clone(),
canonical_path: ancestor_pres.canonical_path.clone(),
inherited_from: Some(vec![provenance.clone()]),
structural_fingerprint: ancestor_pres.structural_fingerprint.clone(),
requires_predicate: ancestor_pres.requires_predicate.clone(),
proof: ancestor_pres.proof.clone(),
});
}
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum CrateOrigin {
PathOrWorkspace,
Registry,
Git,
Other(String),
}
impl CrateOrigin {
fn from_source(source: Option<&str>) -> Self {
match source {
None => Self::PathOrWorkspace,
Some(s) if s.starts_with("registry+") => Self::Registry,
Some(s) if s.starts_with("git+") => Self::Git,
Some(s) => Self::Other(s.to_string()),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DepCrateRoot {
pub package_name: String,
pub version: String,
pub crate_root: PathBuf,
pub origin: CrateOrigin,
}
pub fn enumerate_dep_crate_roots(
workspace_root: &Path,
include_path_workspace: bool,
) -> std::io::Result<Vec<DepCrateRoot>> {
use std::process::Command;
let manifest_path = workspace_root.join("Cargo.toml");
let output = Command::new("cargo")
.arg("metadata")
.arg("--format-version")
.arg("1")
.arg("--manifest-path")
.arg(&manifest_path)
.output()
.map_err(|e| {
std::io::Error::new(
e.kind(),
format!(
"failed to invoke `cargo metadata` at `{}`: {e} \
(is cargo on PATH?)",
manifest_path.display()
),
)
})?;
if !output.status.success() {
return Err(std::io::Error::other(format!(
"`cargo metadata` exited with status {} for manifest `{}`: {}",
output.status,
manifest_path.display(),
String::from_utf8_lossy(&output.stderr).trim()
)));
}
let metadata: serde_json::Value = serde_json::from_slice(&output.stdout).map_err(|e| {
std::io::Error::other(format!("failed to parse `cargo metadata` JSON output: {e}"))
})?;
let workspace_members: std::collections::HashSet<String> = metadata
.get("workspace_members")
.and_then(|v| v.as_array())
.map(|arr| {
arr.iter()
.filter_map(|v| v.as_str().map(str::to_string))
.collect()
})
.unwrap_or_default();
let packages = metadata
.get("packages")
.and_then(|v| v.as_array())
.ok_or_else(|| {
std::io::Error::other(
"`cargo metadata` output missing `packages` array — unexpected schema",
)
})?;
let mut roots: Vec<DepCrateRoot> = Vec::new();
for pkg in packages {
let id = pkg.get("id").and_then(|v| v.as_str()).unwrap_or_default();
if workspace_members.contains(id) {
continue;
}
let package_name = pkg
.get("name")
.and_then(|v| v.as_str())
.unwrap_or_default()
.to_string();
let version = pkg
.get("version")
.and_then(|v| v.as_str())
.unwrap_or_default()
.to_string();
let source = pkg.get("source").and_then(|v| v.as_str());
let manifest_str = pkg.get("manifest_path").and_then(|v| v.as_str());
let Some(manifest_str) = manifest_str else {
continue;
};
let manifest = PathBuf::from(manifest_str);
let Some(crate_root) = manifest.parent().map(Path::to_path_buf) else {
continue;
};
let origin = CrateOrigin::from_source(source);
if matches!(origin, CrateOrigin::PathOrWorkspace) && !include_path_workspace {
continue;
}
roots.push(DepCrateRoot {
package_name,
version,
crate_root,
origin,
});
}
Ok(roots)
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct WorkspaceMemberRoot {
pub package_name: String,
pub version: String,
pub crate_root: PathBuf,
}
impl WorkspaceMemberRoot {
#[must_use]
pub fn canonical_path(&self) -> String {
format!("{}@{}", self.package_name, self.version)
}
}
pub fn enumerate_workspace_member_roots(
workspace_root: &Path,
) -> std::io::Result<Vec<WorkspaceMemberRoot>> {
use std::process::Command;
let manifest_path = workspace_root.join("Cargo.toml");
let output = Command::new("cargo")
.arg("metadata")
.arg("--no-deps")
.arg("--format-version")
.arg("1")
.arg("--manifest-path")
.arg(&manifest_path)
.output()
.map_err(|e| {
std::io::Error::new(
e.kind(),
format!(
"failed to invoke `cargo metadata` at `{}`: {e} (is cargo on PATH?)",
manifest_path.display()
),
)
})?;
if !output.status.success() {
return Err(std::io::Error::other(format!(
"`cargo metadata --no-deps` exited with status {} for manifest `{}`: {}",
output.status,
manifest_path.display(),
String::from_utf8_lossy(&output.stderr).trim()
)));
}
let metadata: serde_json::Value = serde_json::from_slice(&output.stdout).map_err(|e| {
std::io::Error::other(format!("failed to parse `cargo metadata` JSON output: {e}"))
})?;
let member_ids: std::collections::HashSet<String> = metadata
.get("workspace_members")
.and_then(|v| v.as_array())
.map(|arr| {
arr.iter()
.filter_map(|v| v.as_str().map(str::to_string))
.collect()
})
.unwrap_or_default();
let packages = metadata
.get("packages")
.and_then(|v| v.as_array())
.ok_or_else(|| {
std::io::Error::other(
"`cargo metadata` output missing `packages` array — unexpected schema",
)
})?;
let mut roots: Vec<WorkspaceMemberRoot> = Vec::new();
for pkg in packages {
let id = pkg.get("id").and_then(|v| v.as_str()).unwrap_or_default();
if !member_ids.is_empty() && !member_ids.contains(id) {
continue;
}
let package_name = pkg
.get("name")
.and_then(|v| v.as_str())
.unwrap_or_default()
.to_string();
let version = pkg
.get("version")
.and_then(|v| v.as_str())
.unwrap_or_default()
.to_string();
let manifest_str = pkg.get("manifest_path").and_then(|v| v.as_str());
let Some(manifest_str) = manifest_str else {
continue;
};
let Some(crate_root) = PathBuf::from(manifest_str).parent().map(Path::to_path_buf) else {
continue;
};
roots.push(WorkspaceMemberRoot {
package_name,
version,
crate_root,
});
}
roots.sort_by(|a, b| a.package_name.cmp(&b.package_name));
Ok(roots)
}
impl ScanReport {
fn merge(&mut self, mut other: Self) {
self.antigens.append(&mut other.antigens);
self.presentations.append(&mut other.presentations);
self.immunities.append(&mut other.immunities);
self.tolerances.append(&mut other.tolerances);
self.lineage_edges.append(&mut other.lineage_edges);
self.deferred_defenses.append(&mut other.deferred_defenses);
self.convergent_evidences
.append(&mut other.convergent_evidences);
self.recurrent_declarations
.append(&mut other.recurrent_declarations);
self.mucosal_declarations
.append(&mut other.mucosal_declarations);
self.prescriptive_declarations
.append(&mut other.prescriptive_declarations);
self.defenses.append(&mut other.defenses);
self.generates_declarations
.append(&mut other.generates_declarations);
self.files_scanned += other.files_scanned;
self.parse_failures.append(&mut other.parse_failures);
}
}
fn resolve_cross_member_lineage_parents(report: &mut ScanReport) {
use std::collections::HashMap;
let mut decl_members: HashMap<String, std::collections::BTreeSet<String>> = HashMap::new();
for a in &report.antigens {
if let Some(cp) = a.canonical_path.as_deref() {
decl_members
.entry(a.type_name.clone())
.or_default()
.insert(cp.to_string());
}
}
let mut ambiguity_failures: Vec<ParseFailure> = Vec::new();
for e in &mut report.lineage_edges {
let Some(members) = decl_members.get(&e.parent) else {
continue;
};
match members.len() {
0 => {}
1 => {
let target = members.iter().next().expect("len==1");
if e.parent_canonical_path.as_deref() != Some(target.as_str()) {
e.parent_canonical_path = Some(target.clone());
}
}
_ => {
ambiguity_failures.push(ParseFailure {
file: e.file.clone(),
error: format!(
"#[descended_from({parent})] on `{child}` is ambiguous across the \
workspace: `{parent}` is declared in {n} members ({members}); \
cross-member lineage parent left unresolved (qualify the parent path \
to disambiguate)",
parent = e.parent,
child = e.child,
n = members.len(),
members = members.iter().cloned().collect::<Vec<_>>().join(", "),
),
});
}
}
}
report.parse_failures.extend(ambiguity_failures);
}
fn resolve_cross_member_addresses(report: &mut ScanReport) {
use std::collections::{BTreeMap, BTreeSet};
let mut decl_members: BTreeMap<&str, BTreeSet<&str>> = BTreeMap::new();
for a in &report.antigens {
if let Some(cp) = a.canonical_path.as_deref() {
decl_members
.entry(a.type_name.as_str())
.or_default()
.insert(cp);
}
}
let mut collisions: BTreeMap<&str, String> = BTreeMap::new();
macro_rules! restamp_family {
($field:ident) => {
for rec in &mut report.$field {
let Some(members) = decl_members.get(rec.antigen_type.as_str()) else {
continue; };
let mut it = members.iter();
match (it.next(), it.next()) {
(Some(&target), None) => {
if rec.canonical_path.as_deref() != Some(target) {
rec.canonical_path = Some(target.to_owned());
}
}
(Some(_), Some(_)) => {
let name = rec.antigen_type.as_str();
collisions.entry(name).or_insert_with(|| {
format!(
"cross-crate addresses() for `{name}` is ambiguous across the \
workspace: `{name}` is declared in {n} members ({members}); the \
reference is left keyed to its own member and reads as \
out-of-frame (qualify the antigen path to disambiguate)",
n = members.len(),
members = members.iter().copied().collect::<Vec<_>>().join(", "),
)
});
}
(None, _) => {}
}
}
};
}
restamp_family!(presentations);
restamp_family!(defenses);
restamp_family!(immunities);
restamp_family!(tolerances);
for error in collisions.into_values() {
report.parse_failures.push(ParseFailure {
file: PathBuf::from("<workspace>"),
error,
});
}
}
pub fn scan_workspace_multi_crate(workspace_root: &Path) -> std::io::Result<ScanReport> {
let members = enumerate_workspace_member_roots(workspace_root)?;
let mut enumerated_members: Vec<String> = members
.iter()
.map(WorkspaceMemberRoot::canonical_path)
.collect();
let mut scanned_members: Vec<String> = Vec::with_capacity(members.len());
let mut merged = ScanReport::default();
for member in &members {
let mut member_report = match scan_workspace(&member.crate_root, None) {
Ok(r) => r,
Err(e) => {
merged.parse_failures.push(ParseFailure {
file: member.crate_root.clone(),
error: format!(
"member `{}` could not be scanned ({e}); its sites are UNSEEN \
(ignorance frontier), not defended",
member.canonical_path()
),
});
continue;
}
};
member_report.stamp_canonical_path(&member.canonical_path());
merged.merge(member_report);
scanned_members.push(member.canonical_path());
}
enumerated_members.sort();
scanned_members.sort();
merged.scan_coverage = Some(ScanCoverage {
enumerated_members,
scanned_members,
});
resolve_cross_member_lineage_parents(&mut merged);
resolve_cross_member_addresses(&mut merged);
let (deduped_edges, dedup_failures) = dedupe_lineage_edges(&merged.lineage_edges);
merged.lineage_edges = deduped_edges;
merged.parse_failures.extend(dedup_failures);
let lineage_failures = detect_lineage_failures(&merged.lineage_edges, MAX_LINEAGE_DEPTH);
merged.parse_failures.extend(lineage_failures);
synthesize_inherited_presentations(&mut merged);
Ok(merged)
}
fn synthesis_pass(
parsed_files: &[(PathBuf, syn::File)],
fingerprints: &[(String, antigen_fingerprint::Fingerprint)],
declaration_sites: &std::collections::HashSet<(String, PathBuf)>,
report: &mut ScanReport,
) {
for (file_path, parsed) in parsed_files {
for syn_item in &parsed.items {
let Some((kind_str, item_target)) = item_kind_and_target(syn_item) else {
continue;
};
let item_kind_for_dispatch = match syn_item {
syn::Item::Struct(_) => Some(antigen_fingerprint::ItemKind::Struct),
syn::Item::Enum(_) => Some(antigen_fingerprint::ItemKind::Enum),
syn::Item::Trait(_) => Some(antigen_fingerprint::ItemKind::Trait),
syn::Item::Fn(_) => Some(antigen_fingerprint::ItemKind::Fn),
syn::Item::Impl(_) => Some(antigen_fingerprint::ItemKind::Impl),
syn::Item::Type(_) => Some(antigen_fingerprint::ItemKind::Type),
syn::Item::Mod(_) => Some(antigen_fingerprint::ItemKind::Mod),
syn::Item::Const(_) => Some(antigen_fingerprint::ItemKind::Const),
syn::Item::Static(_) => Some(antigen_fingerprint::ItemKind::Static),
syn::Item::Union(_) => Some(antigen_fingerprint::ItemKind::Union),
_ => None,
};
for (antigen_type, fp) in fingerprints {
if let Some(required_kind) = fp.node_kind() {
if item_kind_for_dispatch != Some(required_kind) {
continue;
}
}
if !fp.matches(syn_item) {
continue;
}
let is_self_decl = matches!(&item_target, ItemTarget::Struct(s) if s == antigen_type)
&& declaration_sites.contains(&(antigen_type.clone(), file_path.clone()));
if is_self_decl {
continue;
}
let already_covered = report.presentations.iter().any(|p| {
p.match_kind == MatchKind::ExplicitMarker
&& p.antigen_type == *antigen_type
&& p.file == *file_path
&& p.item_target.addresses(&item_target)
}) || report.tolerances.iter().any(|t| {
t.antigen_type == *antigen_type
&& t.file == *file_path
&& t.item_target.addresses(&item_target)
});
if already_covered {
continue;
}
let duplicate_emitted = report.presentations.iter().any(|p| {
p.match_kind == MatchKind::FingerprintMatch
&& p.antigen_type == *antigen_type
&& p.file == *file_path
&& p.item_target == item_target
});
if duplicate_emitted {
continue;
}
let line = item_line(syn_item);
let structural_fingerprint = match syn_item {
syn::Item::Struct(i) => antigen_fingerprint::structural_digest(i),
syn::Item::Enum(i) => antigen_fingerprint::structural_digest(i),
syn::Item::Trait(i) => antigen_fingerprint::structural_digest(i),
syn::Item::Fn(i) => antigen_fingerprint::structural_digest(i),
syn::Item::Type(i) => antigen_fingerprint::structural_digest(i),
syn::Item::Impl(i) => antigen_fingerprint::structural_digest(i),
syn::Item::Const(i) => antigen_fingerprint::structural_digest(i),
syn::Item::Static(i) => antigen_fingerprint::structural_digest(i),
syn::Item::Union(i) => antigen_fingerprint::structural_digest(i),
_ => String::new(),
};
report.presentations.push(Presentation {
antigen_type: antigen_type.clone(),
file: file_path.clone(),
line,
item_kind: kind_str.to_string(),
item_target: item_target.clone(),
match_kind: MatchKind::FingerprintMatch,
canonical_path: None,
inherited_from: None,
structural_fingerprint,
requires_predicate: None,
proof: None,
});
}
}
}
}
struct MacroInvocation {
macro_name: String,
line: usize,
item_target: ItemTarget,
}
struct GeneratesInvocationVisitor<'a> {
generators: &'a std::collections::HashSet<String>,
found: Vec<MacroInvocation>,
}
impl GeneratesInvocationVisitor<'_> {
fn scan_attrs(&mut self, attrs: &[syn::Attribute], target: &ItemTarget) {
for attr in attrs {
if attr_is(attr, "derive") {
if let syn::Meta::List(list) = &attr.meta {
let parsed = list.parse_args_with(
syn::punctuated::Punctuated::<syn::Path, syn::Token![,]>::parse_terminated,
);
if let Ok(paths) = parsed {
for p in paths {
if let Some(seg) = p.segments.last() {
let name = seg.ident.to_string();
if self.generators.contains(&name) {
self.found.push(MacroInvocation {
macro_name: name,
line: ScanVisitor::line_of_attr(attr),
item_target: target.clone(),
});
}
}
}
}
}
continue;
}
if let Some(seg) = attr.path().segments.last() {
let name = seg.ident.to_string();
if self.generators.contains(&name) {
self.found.push(MacroInvocation {
macro_name: name,
line: ScanVisitor::line_of_attr(attr),
item_target: target.clone(),
});
}
}
}
}
}
impl<'ast> Visit<'ast> for GeneratesInvocationVisitor<'_> {
fn visit_item(&mut self, item: &'ast syn::Item) {
if let Some((_, target)) = item_kind_and_target(item) {
let attrs: &[syn::Attribute] = match item {
syn::Item::Struct(i) => &i.attrs,
syn::Item::Enum(i) => &i.attrs,
syn::Item::Union(i) => &i.attrs,
syn::Item::Fn(i) => &i.attrs,
syn::Item::Trait(i) => &i.attrs,
syn::Item::Type(i) => &i.attrs,
syn::Item::Const(i) => &i.attrs,
syn::Item::Static(i) => &i.attrs,
syn::Item::Impl(i) => &i.attrs,
syn::Item::Mod(i) => &i.attrs,
_ => &[],
};
self.scan_attrs(attrs, &target);
}
syn::visit::visit_item(self, item);
}
fn visit_macro(&mut self, mac: &'ast syn::Macro) {
if let Some(seg) = mac.path.segments.last() {
let name = seg.ident.to_string();
if self.generators.contains(&name) {
let line = seg.ident.span().start().line;
self.found.push(MacroInvocation {
macro_name: name,
line,
item_target: ItemTarget::Unknown { line },
});
}
}
syn::visit::visit_macro(self, mac);
}
}
fn generates_synthesis_pass(parsed_files: &[(PathBuf, syn::File)], report: &mut ScanReport) {
use std::collections::{HashMap, HashSet};
let mut by_macro: HashMap<String, Vec<String>> = HashMap::new();
for g in &report.generates_declarations {
by_macro
.entry(g.macro_name.clone())
.or_default()
.push(g.antigen_type.clone());
}
let generator_names: HashSet<String> = by_macro.keys().cloned().collect();
if generator_names.is_empty() {
return;
}
for (file_path, parsed) in parsed_files {
let mut visitor = GeneratesInvocationVisitor {
generators: &generator_names,
found: Vec::new(),
};
visitor.visit_file(parsed);
for inv in visitor.found {
let Some(antigen_types) = by_macro.get(&inv.macro_name) else {
continue;
};
let item_kind = format!("generated_{}", inv.macro_name);
for antigen_type in antigen_types {
let already = report.presentations.iter().any(|p| {
p.antigen_type == *antigen_type
&& p.file == *file_path
&& p.item_target == inv.item_target
});
if already {
continue;
}
report.presentations.push(Presentation {
antigen_type: antigen_type.clone(),
file: file_path.clone(),
line: inv.line,
item_kind: item_kind.clone(),
item_target: inv.item_target.clone(),
match_kind: MatchKind::ExplicitMarker,
canonical_path: None,
inherited_from: None,
structural_fingerprint: String::new(),
requires_predicate: None,
proof: None,
});
}
}
}
}
fn item_kind_and_target(item: &syn::Item) -> Option<(&'static str, ItemTarget)> {
match item {
syn::Item::Struct(s) => Some(("struct", ItemTarget::Struct(s.ident.to_string()))),
syn::Item::Enum(e) => Some(("enum", ItemTarget::Enum(e.ident.to_string()))),
syn::Item::Trait(t) => Some(("trait", ItemTarget::Trait(t.ident.to_string()))),
syn::Item::Fn(f) => Some(("fn", ItemTarget::Fn(f.sig.ident.to_string()))),
syn::Item::Type(t) => Some(("type", ItemTarget::TypeAlias(t.ident.to_string()))),
syn::Item::Impl(i) => {
let trait_path = i.trait_.as_ref().map(|(_, path, _)| render_path(path));
let target_type = render_type(&i.self_ty);
Some((
"impl",
ItemTarget::Impl {
trait_path,
target_type,
},
))
}
syn::Item::Const(c) => Some(("const", ItemTarget::Const(c.ident.to_string()))),
syn::Item::Static(s) => Some(("static", ItemTarget::Static(s.ident.to_string()))),
syn::Item::Union(u) => Some(("union", ItemTarget::Union(u.ident.to_string()))),
_ => None,
}
}
fn item_line(item: &syn::Item) -> usize {
use syn::spanned::Spanned;
item.span().start().line
}
#[presents(ScanVisitorDigestAssignmentOmission)]
struct ScanVisitor<'a> {
file_path: PathBuf,
report: &'a mut ScanReport,
impl_stack: Vec<(Option<String>, String)>,
trait_stack: Vec<String>,
current_item_digest: String,
}
impl ScanVisitor<'_> {
fn line_of_attr(attr: &syn::Attribute) -> usize {
use syn::spanned::Spanned;
attr.span().start().line
}
fn extract_antigen(&mut self, item: &syn::ItemStruct, attr: &syn::Attribute) {
let type_name = item.ident.to_string();
let line = Self::line_of_attr(attr);
if let syn::Meta::List(list) = &attr.meta {
match syn::parse2::<ScanAntigenArgs>(list.tokens.clone()) {
Ok(args) => {
let category: Vec<crate::category::AntigenCategory> = args
.category
.iter()
.filter_map(|s| crate::category::AntigenCategory::parse_category(s))
.collect();
self.report.antigens.push(AntigenDeclaration {
name: args.name,
type_name,
file: self.file_path.clone(),
line,
family: args.family,
summary: args.summary,
fingerprint: args.fingerprint,
canonical_path: None,
category,
});
}
Err(_) => {
self.report.antigens.push(AntigenDeclaration {
name: String::new(),
type_name,
file: self.file_path.clone(),
line,
family: None,
summary: None,
fingerprint: None,
canonical_path: None,
category: Vec::new(),
});
}
}
}
}
fn extract_presents(
&mut self,
attr: &syn::Attribute,
all_attrs: &[syn::Attribute],
item_kind: &str,
item_target: ItemTarget,
) {
let (antigen_type, requires_predicate, proof) = if let syn::Meta::List(list) = &attr.meta {
match syn::parse2::<ScanPresentsArgs>(list.tokens.clone()) {
Ok(args) => (args.antigen_type, args.requires_predicate, args.proof),
Err(e) => {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: format!("malformed #[presents] attribute: {e}"),
});
return;
}
}
} else {
return;
};
let requires_predicate =
requires_predicate.or_else(|| extract_requires_predicate_from_attrs(all_attrs));
let line = Self::line_of_attr(attr);
self.report.presentations.push(Presentation {
antigen_type,
file: self.file_path.clone(),
line,
item_kind: item_kind.to_string(),
item_target,
match_kind: MatchKind::ExplicitMarker,
canonical_path: None,
inherited_from: None,
structural_fingerprint: self.current_item_digest.clone(),
requires_predicate,
proof,
});
}
fn extract_immune(
&mut self,
attr: &syn::Attribute,
all_attrs: &[syn::Attribute],
item_kind: &str,
item_target: ItemTarget,
) {
if let syn::Meta::List(list) = &attr.meta {
let args = match syn::parse2::<ScanImmuneArgs>(list.tokens.clone()) {
Ok(args) => args,
Err(e) => {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: format!("malformed #[immune] attribute: {e}"),
});
return;
}
};
let requires_predicate = args
.requires_predicate
.clone()
.or_else(|| extract_requires_predicate_from_attrs(all_attrs));
let line = Self::line_of_attr(attr);
self.report.immunities.push(Immunity {
antigen_type: args.antigen_type,
witness: args.witness,
requires_predicate,
file: self.file_path.clone(),
line,
item_kind: item_kind.to_string(),
item_target,
canonical_path: None,
structural_fingerprint: self.current_item_digest.clone(),
});
}
}
fn extract_defended_by(
&mut self,
attr: &syn::Attribute,
item_kind: &str,
item_target: ItemTarget,
) {
let antigen_type = if let syn::Meta::List(list) = &attr.meta {
match syn::parse2::<syn::Path>(list.tokens.clone()) {
Ok(path) => path
.segments
.last()
.map(|s| s.ident.to_string())
.unwrap_or_default(),
Err(e) => {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: format!("malformed #[defended_by] attribute: {e}"),
});
return;
}
}
} else {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: "#[defended_by] requires an antigen type argument, \
e.g. #[defended_by(ParallelStateTrackersDiverge)]"
.to_string(),
});
return;
};
if antigen_type.is_empty() {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: "#[defended_by] antigen type resolved to an empty path".to_string(),
});
return;
}
let line = Self::line_of_attr(attr);
self.report.defenses.push(Defense {
antigen_type,
file: self.file_path.clone(),
line,
item_kind: item_kind.to_string(),
item_target,
canonical_path: None,
});
}
fn extract_generates(
&mut self,
attr: &syn::Attribute,
all_attrs: &[syn::Attribute],
item_target: &ItemTarget,
) {
let syn::Meta::List(list) = &attr.meta else {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: "#[antigen_generates] requires arguments, e.g. \
#[antigen_generates(PanickingInDrop, rationale = \"...\")]"
.to_string(),
});
return;
};
let args = match syn::parse2::<ScanGeneratesArgs>(list.tokens.clone()) {
Ok(a) => a,
Err(e) => {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: format!("malformed #[antigen_generates] attribute: {e}"),
});
return;
}
};
if args.antigen_type.is_empty() {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: "#[antigen_generates] antigen type resolved to an empty path".to_string(),
});
return;
}
if args.rationale.trim().is_empty() {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: format!(
"#[antigen_generates({})] requires a non-empty `rationale = \"...\"` \
— the macro author must justify what the expansion presents",
args.antigen_type
),
});
return;
}
let macro_name = Self::macro_name_for_generates(all_attrs, item_target);
if macro_name.is_empty() {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: format!(
"#[antigen_generates({})] could not resolve a macro name to register \
— apply it to a #[proc_macro_derive(Name)] / #[proc_macro_attribute] fn \
or a `macro_rules!` definition",
args.antigen_type
),
});
return;
}
let line = Self::line_of_attr(attr);
self.report
.generates_declarations
.push(GeneratesDeclaration {
antigen_type: args.antigen_type,
rationale: args.rationale,
macro_name,
file: self.file_path.clone(),
line,
canonical_path: None,
});
}
fn macro_name_for_generates(all_attrs: &[syn::Attribute], item_target: &ItemTarget) -> String {
for a in all_attrs {
if attr_is(a, "proc_macro_derive") {
if let syn::Meta::List(list) = &a.meta {
if let Ok(path) = syn::parse2::<syn::Path>(list.tokens.clone()) {
if let Some(seg) = path.segments.last() {
return seg.ident.to_string();
}
}
if let Some(proc_macro2::TokenTree::Ident(id)) =
list.tokens.clone().into_iter().next()
{
return id.to_string();
}
}
}
}
match item_target {
ItemTarget::Fn(name) => name.clone(),
_ => String::new(),
}
}
fn extract_tolerance(
&mut self,
attr: &syn::Attribute,
all_attrs: &[syn::Attribute],
item_kind: &str,
item_target: ItemTarget,
) {
if let syn::Meta::List(list) = &attr.meta {
let args = match syn::parse2::<ScanToleranceArgs>(list.tokens.clone()) {
Ok(args) => args,
Err(e) => {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: format!("malformed #[antigen_tolerance] attribute: {e}"),
});
return;
}
};
if args.rationale.is_empty() {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: "#[antigen_tolerance] requires non-empty rationale".to_string(),
});
return;
}
let requires_predicate = args
.requires_predicate
.clone()
.or_else(|| extract_requires_predicate_from_attrs(all_attrs));
let line = Self::line_of_attr(attr);
self.report.tolerances.push(Toleration {
antigen_type: args.antigen_type,
rationale: args.rationale,
until: args.until,
see: args.see,
requires_predicate,
file: self.file_path.clone(),
line,
item_kind: item_kind.to_string(),
item_target,
canonical_path: None,
structural_fingerprint: self.current_item_digest.clone(),
});
}
}
fn extract_anergy(&mut self, attr: &syn::Attribute, item_kind: &str, item_target: ItemTarget) {
if let syn::Meta::List(list) = &attr.meta {
let args = match syn::parse2::<ScanAnergyArgs>(list.tokens.clone()) {
Ok(a) => a,
Err(e) => {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: format!("malformed #[anergy] attribute: {e}"),
});
return;
}
};
let line = Self::line_of_attr(attr);
self.report.deferred_defenses.push(DeferredDefense {
kind: DeferredDefenseKind::Anergy,
antigen_type: args.antigen_type,
text: args.reason,
until: if args.until.is_empty() {
None
} else {
Some(args.until)
},
expected_co_stimulation: args.expected_co_stimulation,
signed_by: args.signed_by,
see: Vec::new(),
since: None,
duration_cap: None,
file: self.file_path.clone(),
line,
item_kind: item_kind.to_string(),
item_target,
});
}
}
fn extract_immunosuppress(
&mut self,
attr: &syn::Attribute,
item_kind: &str,
item_target: ItemTarget,
) {
if let syn::Meta::List(list) = &attr.meta {
let args = match syn::parse2::<ScanImmunosuppressArgs>(list.tokens.clone()) {
Ok(a) => a,
Err(e) => {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: format!("malformed #[immunosuppress] attribute: {e}"),
});
return;
}
};
let line = Self::line_of_attr(attr);
self.report.deferred_defenses.push(DeferredDefense {
kind: DeferredDefenseKind::Immunosuppress,
antigen_type: args.antigen_type,
text: args.rationale,
until: if args.until.is_empty() {
None
} else {
Some(args.until)
},
expected_co_stimulation: None,
signed_by: args.signed_by,
see: Vec::new(),
since: args.since.clone(),
duration_cap: args.duration_cap,
file: self.file_path.clone(),
line,
item_kind: item_kind.to_string(),
item_target,
});
}
}
fn extract_poxparty(
&mut self,
attr: &syn::Attribute,
item_kind: &str,
item_target: ItemTarget,
) {
if let syn::Meta::List(list) = &attr.meta {
let args = match syn::parse2::<ScanPoxpartyArgs>(list.tokens.clone()) {
Ok(a) => a,
Err(e) => {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: format!("malformed #[poxparty] attribute: {e}"),
});
return;
}
};
let mut see = Vec::new();
if let Some(name) = &args.name {
see.push(format!("exercise:{name}"));
}
if let Some(rationale) = &args.rationale {
see.push(format!("rationale:{rationale}"));
}
let line = Self::line_of_attr(attr);
self.report.deferred_defenses.push(DeferredDefense {
kind: DeferredDefenseKind::Poxparty,
antigen_type: args.antigen_type,
text: args.exercise_type,
until: if args.until.is_empty() {
None
} else {
Some(args.until)
},
expected_co_stimulation: None,
signed_by: args.signed_by,
see,
since: None,
duration_cap: None,
file: self.file_path.clone(),
line,
item_kind: item_kind.to_string(),
item_target,
});
}
}
fn extract_orient(&mut self, attr: &syn::Attribute, item_kind: &str, item_target: ItemTarget) {
match &attr.meta {
syn::Meta::List(list) => {
let args = match syn::parse2::<ScanOrientArgs>(list.tokens.clone()) {
Ok(a) => a,
Err(e) => {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: format!("malformed #[orient] attribute: {e}"),
});
return;
}
};
let line = Self::line_of_attr(attr);
let mut adr_see = args.see.clone();
if let Some(adr) = &args.adr {
adr_see.push(format!("adr:{adr}"));
}
self.report.deferred_defenses.push(DeferredDefense {
kind: DeferredDefenseKind::Orient,
antigen_type: args.antigen_type,
text: String::new(),
until: None,
expected_co_stimulation: None,
signed_by: None,
see: adr_see,
since: None,
duration_cap: None,
file: self.file_path.clone(),
line,
item_kind: item_kind.to_string(),
item_target,
});
}
syn::Meta::Path(_) => {
let line = Self::line_of_attr(attr);
self.report.deferred_defenses.push(DeferredDefense {
kind: DeferredDefenseKind::Orient,
antigen_type: None,
text: String::new(),
until: None,
expected_co_stimulation: None,
signed_by: None,
see: Vec::new(),
since: None,
duration_cap: None,
file: self.file_path.clone(),
line,
item_kind: item_kind.to_string(),
item_target,
});
}
syn::Meta::NameValue(_) => {
}
}
}
fn extract_descended_from(&mut self, attr: &syn::Attribute, item_target: &ItemTarget) {
let child = match item_target {
ItemTarget::Struct(name) | ItemTarget::Enum(name) => name.clone(),
other => {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: format!(
"#[descended_from] on `{}` is not a type declaration; \
this attribute is meaningful only on `struct` and `enum` \
antigen declarations",
other.label()
),
});
return;
}
};
let syn::Meta::List(list) = &attr.meta else {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: "malformed #[descended_from] attribute: expected `(parent)`".to_string(),
});
return;
};
let parent = match syn::parse2::<syn::Path>(list.tokens.clone()) {
Ok(path) => path
.segments
.last()
.map(|s| s.ident.to_string())
.unwrap_or_default(),
Err(e) => {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: format!("malformed #[descended_from] attribute: {e}"),
});
return;
}
};
if parent.is_empty() {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: "#[descended_from] requires a parent path argument".to_string(),
});
return;
}
let line = Self::line_of_attr(attr);
self.report.lineage_edges.push(LineageEdge {
child,
parent,
file: self.file_path.clone(),
line,
parent_canonical_path: None,
child_canonical_path: None,
});
}
fn check_attrs(&mut self, attrs: &[syn::Attribute], item_kind: &str, item_target: &ItemTarget) {
for attr in attrs {
if attr_is(attr, "presents") {
self.extract_presents(attr, attrs, item_kind, item_target.clone());
} else if attr_is(attr, "immune") {
self.extract_immune(attr, attrs, item_kind, item_target.clone());
} else if attr_is(attr, "antigen_tolerance") {
self.extract_tolerance(attr, attrs, item_kind, item_target.clone());
} else if attr_is(attr, "descended_from") {
self.extract_descended_from(attr, item_target);
} else if attr_is(attr, "defended_by") {
self.extract_defended_by(attr, item_kind, item_target.clone());
} else if attr_is(attr, "antigen_generates") {
self.extract_generates(attr, attrs, item_target);
} else if attr_is(attr, "anergy") {
self.extract_anergy(attr, item_kind, item_target.clone());
} else if attr_is(attr, "immunosuppress") {
self.extract_immunosuppress(attr, item_kind, item_target.clone());
} else if attr_is(attr, "poxparty") {
self.extract_poxparty(attr, item_kind, item_target.clone());
} else if attr_is(attr, "orient") {
self.extract_orient(attr, item_kind, item_target.clone());
} else if attr_is(attr, "diagnostic") {
self.extract_diagnostic(attr, item_kind, item_target.clone());
} else if attr_is(attr, "clonal") {
self.extract_clonal(attr, item_kind, item_target.clone());
} else if attr_is(attr, "igg") {
self.extract_igg(attr, item_kind, item_target.clone());
} else if attr_is(attr, "crossreactive") {
self.extract_crossreactive(attr, item_kind, item_target.clone());
} else if attr_is(attr, "polyclonal") {
self.extract_convergent_marker(
attr,
item_kind,
item_target.clone(),
ConvergentEvidenceKind::Polyclonal,
);
} else if attr_is(attr, "monoclonal") {
self.extract_convergent_marker(
attr,
item_kind,
item_target.clone(),
ConvergentEvidenceKind::Monoclonal,
);
} else if attr_is(attr, "adcc") {
self.extract_convergent_marker(
attr,
item_kind,
item_target.clone(),
ConvergentEvidenceKind::Adcc,
);
} else {
self.check_v02_family_attr(attr, item_kind, item_target);
}
}
}
fn check_v02_family_attr(
&mut self,
attr: &syn::Attribute,
item_kind: &str,
item_target: &ItemTarget,
) {
if attr_is(attr, "itch") {
self.extract_recurrent(attr, item_kind, item_target.clone(), RecurrentKind::Itch);
} else if attr_is(attr, "recurrence_anchor") {
self.extract_recurrent(
attr,
item_kind,
item_target.clone(),
RecurrentKind::RecurrenceAnchor,
);
} else if attr_is(attr, "crystallize") {
self.extract_recurrent(
attr,
item_kind,
item_target.clone(),
RecurrentKind::Crystallize,
);
} else if attr_is(attr, "chronic") {
self.extract_recurrent(attr, item_kind, item_target.clone(), RecurrentKind::Chronic);
} else if attr_is(attr, "saturate") {
self.extract_recurrent(
attr,
item_kind,
item_target.clone(),
RecurrentKind::Saturate,
);
} else if attr_is(attr, "strand") {
self.extract_recurrent(attr, item_kind, item_target.clone(), RecurrentKind::Strand);
} else if attr_is(attr, "mucosal") {
self.extract_mucosal(
attr,
item_kind,
item_target.clone(),
MucosalKindTag::Mucosal,
);
} else if attr_is(attr, "mucosal_delegate") {
self.extract_mucosal(
attr,
item_kind,
item_target.clone(),
MucosalKindTag::MucosalDelegate,
);
} else if attr_is(attr, "mucosal_tolerant") {
self.extract_mucosal(
attr,
item_kind,
item_target.clone(),
MucosalKindTag::MucosalTolerant,
);
} else if attr_is(attr, "panel") {
self.extract_prescriptive(
attr,
item_kind,
item_target.clone(),
PrescriptiveKind::Panel,
);
} else if attr_is(attr, "rx") {
self.extract_prescriptive(attr, item_kind, item_target.clone(), PrescriptiveKind::Rx);
} else if attr_is(attr, "refer") {
self.extract_prescriptive(
attr,
item_kind,
item_target.clone(),
PrescriptiveKind::Refer,
);
} else if attr_is(attr, "biopsy") {
self.extract_prescriptive(
attr,
item_kind,
item_target.clone(),
PrescriptiveKind::Biopsy,
);
} else if attr_is(attr, "ddx") {
self.extract_prescriptive(attr, item_kind, item_target.clone(), PrescriptiveKind::Ddx);
} else if attr_is(attr, "triage") {
self.extract_prescriptive(
attr,
item_kind,
item_target.clone(),
PrescriptiveKind::Triage,
);
} else if attr_is(attr, "culture") {
self.extract_prescriptive(
attr,
item_kind,
item_target.clone(),
PrescriptiveKind::Culture,
);
} else if attr_is(attr, "quarantine") {
self.extract_prescriptive(
attr,
item_kind,
item_target.clone(),
PrescriptiveKind::Quarantine,
);
}
}
fn extract_mucosal(
&mut self,
attr: &syn::Attribute,
item_kind: &str,
item_target: ItemTarget,
tag: MucosalKindTag,
) {
let line = Self::line_of_attr(attr);
let args = match &attr.meta {
syn::Meta::List(list) => match syn::parse2::<ScanMucosalArgs>(list.tokens.clone()) {
Ok(a) => a,
Err(e) => {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: format!("malformed mucosal-boundary attribute: {e}"),
});
return;
}
},
syn::Meta::Path(_) => ScanMucosalArgs::default(),
syn::Meta::NameValue(_) => return,
};
self.report.mucosal_declarations.push(MucosalDeclaration {
tag,
boundary_kind: args.boundary_kind,
rationale: args.rationale,
handled_by: args.handled_by,
accepts: args.accepts,
reviewed_by: args.reviewed_by,
until: args.until,
file: self.file_path.clone(),
line,
item_kind: item_kind.to_string(),
item_target,
});
}
fn extract_recurrent(
&mut self,
attr: &syn::Attribute,
item_kind: &str,
item_target: ItemTarget,
kind: RecurrentKind,
) {
let line = Self::line_of_attr(attr);
let args = match &attr.meta {
syn::Meta::List(list) => match syn::parse2::<ScanRecurrentArgs>(list.tokens.clone()) {
Ok(a) => a,
Err(e) => {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: format!("malformed recurrent-emergence attribute: {e}"),
});
return;
}
},
syn::Meta::Path(_) => ScanRecurrentArgs::default(),
syn::Meta::NameValue(_) => return,
};
self.report
.recurrent_declarations
.push(RecurrentDeclaration {
kind,
name: args.name,
antigen_type: args.antigen_type,
description: args.description,
instances: args.instances,
since: args.since,
rationale: args.rationale,
from_itches: args.from_itches,
anchored_by: args.anchored_by,
managed_by: args.managed_by,
contributing_to: args.contributing_to,
file: self.file_path.clone(),
line,
item_kind: item_kind.to_string(),
item_target,
});
}
fn extract_prescriptive(
&mut self,
attr: &syn::Attribute,
item_kind: &str,
item_target: ItemTarget,
kind: PrescriptiveKind,
) {
let line = Self::line_of_attr(attr);
let args = match &attr.meta {
syn::Meta::List(list) => {
match syn::parse2::<ScanPrescriptiveArgs>(list.tokens.clone()) {
Ok(a) => a,
Err(e) => {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: format!("malformed prescriptive attribute: {e}"),
});
return;
}
}
}
syn::Meta::Path(_) => ScanPrescriptiveArgs::default(),
syn::Meta::NameValue(_) => return,
};
self.report
.prescriptive_declarations
.push(PrescriptiveDeclaration {
kind,
items: args.items,
filled_by: args.filled_by,
reviewed_by: args.reviewed_by,
ordered_by: args.ordered_by,
frame: args.frame,
need_text: args.need_text,
label: args.label,
file: self.file_path.clone(),
line,
item_kind: item_kind.to_string(),
item_target,
structural_fingerprint: self.current_item_digest.clone(),
});
}
fn extract_diagnostic(
&mut self,
attr: &syn::Attribute,
item_kind: &str,
item_target: ItemTarget,
) {
if let syn::Meta::List(list) = &attr.meta {
let args = match syn::parse2::<ScanDiagnosticArgs>(list.tokens.clone()) {
Ok(a) => a,
Err(e) => {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: format!("malformed #[diagnostic] attribute: {e}"),
});
return;
}
};
let line = Self::line_of_attr(attr);
self.report.convergent_evidences.push(ConvergentEvidence {
kind: ConvergentEvidenceKind::Diagnostic,
modality_classes: args.modality_classes,
min_independent: args.min_independent,
witness: None,
iterations: None,
seed_kind: None,
historical_span: None,
min_reattestations: None,
witnesses: Vec::new(),
fingerprints: Vec::new(),
file: self.file_path.clone(),
line,
item_kind: item_kind.to_string(),
item_target,
});
}
}
fn extract_clonal(&mut self, attr: &syn::Attribute, item_kind: &str, item_target: ItemTarget) {
if let syn::Meta::List(list) = &attr.meta {
let args = match syn::parse2::<ScanClonalArgs>(list.tokens.clone()) {
Ok(a) => a,
Err(e) => {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: format!("malformed #[clonal] attribute: {e}"),
});
return;
}
};
let line = Self::line_of_attr(attr);
self.report.convergent_evidences.push(ConvergentEvidence {
kind: ConvergentEvidenceKind::Clonal,
modality_classes: Vec::new(),
min_independent: None,
witness: args.witness,
iterations: args.iterations,
seed_kind: args.seed_kind,
historical_span: None,
min_reattestations: None,
witnesses: Vec::new(),
fingerprints: Vec::new(),
file: self.file_path.clone(),
line,
item_kind: item_kind.to_string(),
item_target,
});
}
}
fn extract_igg(&mut self, attr: &syn::Attribute, item_kind: &str, item_target: ItemTarget) {
if let syn::Meta::List(list) = &attr.meta {
let args = match syn::parse2::<ScanIggArgs>(list.tokens.clone()) {
Ok(a) => a,
Err(e) => {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: format!("malformed #[igg] attribute: {e}"),
});
return;
}
};
let line = Self::line_of_attr(attr);
self.report.convergent_evidences.push(ConvergentEvidence {
kind: ConvergentEvidenceKind::Igg,
modality_classes: Vec::new(),
min_independent: None,
witness: None,
iterations: None,
seed_kind: None,
historical_span: args.historical_span,
min_reattestations: args.min_reattestations,
witnesses: args.witnesses,
fingerprints: Vec::new(),
file: self.file_path.clone(),
line,
item_kind: item_kind.to_string(),
item_target,
});
}
}
fn extract_crossreactive(
&mut self,
attr: &syn::Attribute,
item_kind: &str,
item_target: ItemTarget,
) {
if let syn::Meta::List(list) = &attr.meta {
let args = match syn::parse2::<ScanCrossreactiveArgs>(list.tokens.clone()) {
Ok(a) => a,
Err(e) => {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: format!("malformed #[crossreactive] attribute: {e}"),
});
return;
}
};
let line = Self::line_of_attr(attr);
self.report.convergent_evidences.push(ConvergentEvidence {
kind: ConvergentEvidenceKind::Crossreactive,
modality_classes: Vec::new(),
min_independent: None,
witness: None,
iterations: None,
seed_kind: None,
historical_span: None,
min_reattestations: None,
witnesses: Vec::new(),
fingerprints: args.fingerprints,
file: self.file_path.clone(),
line,
item_kind: item_kind.to_string(),
item_target,
});
}
}
fn extract_convergent_marker(
&mut self,
attr: &syn::Attribute,
item_kind: &str,
item_target: ItemTarget,
kind: ConvergentEvidenceKind,
) {
let line = Self::line_of_attr(attr);
self.report.convergent_evidences.push(ConvergentEvidence {
kind,
modality_classes: Vec::new(),
min_independent: None,
witness: None,
iterations: None,
seed_kind: None,
historical_span: None,
min_reattestations: None,
witnesses: Vec::new(),
fingerprints: Vec::new(),
file: self.file_path.clone(),
line,
item_kind: item_kind.to_string(),
item_target,
});
}
}
fn render_type(ty: &syn::Type) -> String {
use quote::ToTokens;
ty.to_token_stream().to_string()
}
fn attr_is(attr: &syn::Attribute, name: &str) -> bool {
let path = attr.path();
path.is_ident(name) || path.segments.last().is_some_and(|s| s.ident == name)
}
fn extract_requires_predicate_from_attrs(attrs: &[syn::Attribute]) -> Option<String> {
const MARKER_PREFIX: &str = "antigen:requires:v1:";
for attr in attrs {
if !attr.path().is_ident("doc") {
continue;
}
if let syn::Meta::NameValue(nv) = &attr.meta {
if let syn::Expr::Lit(syn::ExprLit {
lit: syn::Lit::Str(s),
..
}) = &nv.value
{
let val = s.value();
let trimmed = val.trim();
if let Some(json) = trimmed.strip_prefix(MARKER_PREFIX) {
return Some(json.to_string());
}
}
}
}
None
}
fn render_path(path: &syn::Path) -> String {
use quote::ToTokens;
path.to_token_stream().to_string()
}
impl<'ast> Visit<'ast> for ScanVisitor<'_> {
fn visit_item_struct(&mut self, item: &'ast syn::ItemStruct) {
for attr in &item.attrs {
if attr_is(attr, "antigen") {
self.extract_antigen(item, attr);
}
}
let target = ItemTarget::Struct(item.ident.to_string());
self.current_item_digest = antigen_fingerprint::structural_digest(item);
self.check_attrs(&item.attrs, "struct", &target);
syn::visit::visit_item_struct(self, item);
}
fn visit_item_impl(&mut self, item: &'ast syn::ItemImpl) {
let trait_path = item.trait_.as_ref().map(|(_, path, _)| render_path(path));
let target_type = render_type(&item.self_ty);
let target = ItemTarget::Impl {
trait_path: trait_path.clone(),
target_type: target_type.clone(),
};
self.current_item_digest = antigen_fingerprint::structural_digest(item);
self.check_attrs(&item.attrs, "impl", &target);
self.impl_stack.push((trait_path, target_type));
syn::visit::visit_item_impl(self, item);
self.impl_stack.pop();
}
fn visit_item_const(&mut self, item: &'ast syn::ItemConst) {
let target = ItemTarget::Const(item.ident.to_string());
self.current_item_digest = antigen_fingerprint::structural_digest(item);
self.check_attrs(&item.attrs, "const", &target);
syn::visit::visit_item_const(self, item);
}
fn visit_item_static(&mut self, item: &'ast syn::ItemStatic) {
let target = ItemTarget::Static(item.ident.to_string());
self.current_item_digest = antigen_fingerprint::structural_digest(item);
self.check_attrs(&item.attrs, "static", &target);
syn::visit::visit_item_static(self, item);
}
fn visit_item_fn(&mut self, item: &'ast syn::ItemFn) {
let target = ItemTarget::Fn(item.sig.ident.to_string());
self.current_item_digest = antigen_fingerprint::structural_digest(item);
self.check_attrs(&item.attrs, "fn", &target);
syn::visit::visit_item_fn(self, item);
}
fn visit_impl_item_fn(&mut self, item: &'ast syn::ImplItemFn) {
let target = self.impl_stack.last().map_or_else(
|| ItemTarget::Fn(item.sig.ident.to_string()),
|(trait_path, target_type)| ItemTarget::ImplFn {
trait_path: trait_path.clone(),
target_type: target_type.clone(),
fn_name: item.sig.ident.to_string(),
},
);
self.current_item_digest = antigen_fingerprint::structural_digest(item);
self.check_attrs(&item.attrs, "impl_fn", &target);
syn::visit::visit_impl_item_fn(self, item);
}
fn visit_impl_item_const(&mut self, item: &'ast syn::ImplItemConst) {
let target = self.impl_stack.last().map_or_else(
|| ItemTarget::Fn(item.ident.to_string()),
|(trait_path, target_type)| ItemTarget::ImplConst {
trait_path: trait_path.clone(),
target_type: target_type.clone(),
const_name: item.ident.to_string(),
},
);
self.current_item_digest = antigen_fingerprint::structural_digest(item);
self.check_attrs(&item.attrs, "impl_const", &target);
syn::visit::visit_impl_item_const(self, item);
}
fn visit_impl_item_type(&mut self, item: &'ast syn::ImplItemType) {
let target = ItemTarget::TypeAlias(item.ident.to_string());
self.current_item_digest = antigen_fingerprint::structural_digest(item);
self.check_attrs(&item.attrs, "impl_type", &target);
syn::visit::visit_impl_item_type(self, item);
}
fn visit_impl_item_macro(&mut self, item: &'ast syn::ImplItemMacro) {
let mac_name = item
.mac
.path
.segments
.last()
.map_or_else(|| "(macro)".to_string(), |s| s.ident.to_string());
let target = self.impl_stack.last().map_or_else(
|| ItemTarget::Fn(mac_name.clone()),
|(trait_path, target_type)| ItemTarget::ImplConst {
trait_path: trait_path.clone(),
target_type: target_type.clone(),
const_name: mac_name.clone(),
},
);
self.current_item_digest = antigen_fingerprint::structural_digest(item);
self.check_attrs(&item.attrs, "impl_macro", &target);
syn::visit::visit_impl_item_macro(self, item);
}
fn visit_item_trait(&mut self, item: &'ast syn::ItemTrait) {
let target = ItemTarget::Trait(item.ident.to_string());
self.current_item_digest = antigen_fingerprint::structural_digest(item);
self.check_attrs(&item.attrs, "trait", &target);
self.trait_stack.push(item.ident.to_string());
syn::visit::visit_item_trait(self, item);
self.trait_stack.pop();
}
fn visit_trait_item_fn(&mut self, item: &'ast syn::TraitItemFn) {
let target = self.trait_stack.last().map_or_else(
|| ItemTarget::Fn(item.sig.ident.to_string()),
|trait_name| ItemTarget::TraitFn {
trait_name: trait_name.clone(),
fn_name: item.sig.ident.to_string(),
},
);
self.current_item_digest = antigen_fingerprint::structural_digest(item);
self.check_attrs(&item.attrs, "trait_fn", &target);
syn::visit::visit_trait_item_fn(self, item);
}
fn visit_trait_item_const(&mut self, item: &'ast syn::TraitItemConst) {
let target = self.trait_stack.last().map_or_else(
|| ItemTarget::Const(item.ident.to_string()),
|trait_name| ItemTarget::ImplConst {
trait_path: None,
target_type: trait_name.clone(),
const_name: item.ident.to_string(),
},
);
self.current_item_digest = antigen_fingerprint::structural_digest(item);
self.check_attrs(&item.attrs, "trait_const", &target);
syn::visit::visit_trait_item_const(self, item);
}
fn visit_trait_item_type(&mut self, item: &'ast syn::TraitItemType) {
let target = ItemTarget::TypeAlias(item.ident.to_string());
self.current_item_digest = antigen_fingerprint::structural_digest(item);
self.check_attrs(&item.attrs, "trait_type", &target);
syn::visit::visit_trait_item_type(self, item);
}
fn visit_trait_item_macro(&mut self, item: &'ast syn::TraitItemMacro) {
let mac_name = item
.mac
.path
.segments
.last()
.map_or_else(|| "(macro)".to_string(), |s| s.ident.to_string());
let target = self.trait_stack.last().map_or_else(
|| ItemTarget::Fn(mac_name.clone()),
|trait_name| ItemTarget::TraitFn {
trait_name: trait_name.clone(),
fn_name: mac_name.clone(),
},
);
self.current_item_digest = antigen_fingerprint::structural_digest(item);
self.check_attrs(&item.attrs, "trait_macro", &target);
syn::visit::visit_trait_item_macro(self, item);
}
fn visit_item_type(&mut self, item: &'ast syn::ItemType) {
let target = ItemTarget::TypeAlias(item.ident.to_string());
self.current_item_digest = antigen_fingerprint::structural_digest(item);
self.check_attrs(&item.attrs, "type_alias", &target);
syn::visit::visit_item_type(self, item);
}
fn visit_item_enum(&mut self, item: &'ast syn::ItemEnum) {
for attr in &item.attrs {
if attr_is(attr, "antigen") {
self.report.parse_failures.push(ParseFailure {
file: self.file_path.clone(),
error: format!(
"#[antigen] on enum `{}` is not supported in v0.1; \
antigen declarations must be unit structs (e.g., \
`pub struct {};`). Enum-shaped failure-classes are \
tracked by ADR-010 Amendment 1's class-enum operator \
in a future grammar version.",
item.ident, item.ident
),
});
}
}
let target = ItemTarget::Enum(item.ident.to_string());
self.current_item_digest = antigen_fingerprint::structural_digest(item);
self.check_attrs(&item.attrs, "enum", &target);
let enum_name = item.ident.to_string();
for variant in &item.variants {
let variant_target = ItemTarget::EnumVariant {
enum_name: enum_name.clone(),
variant_name: variant.ident.to_string(),
};
self.check_attrs(&variant.attrs, "enum_variant", &variant_target);
}
syn::visit::visit_item_enum(self, item);
}
fn visit_item_macro(&mut self, item: &'ast syn::ItemMacro) {
let name = item
.ident
.as_ref()
.map_or_else(|| "(anonymous)".to_string(), ToString::to_string);
let target = ItemTarget::Const(name);
self.current_item_digest = antigen_fingerprint::structural_digest(item);
self.check_attrs(&item.attrs, "macro", &target);
syn::visit::visit_item_macro(self, item);
}
fn visit_item_use(&mut self, item: &'ast syn::ItemUse) {
use quote::ToTokens;
let path_str = item.tree.to_token_stream().to_string();
let target = ItemTarget::Const(path_str);
self.current_item_digest = antigen_fingerprint::structural_digest(item);
self.check_attrs(&item.attrs, "use", &target);
syn::visit::visit_item_use(self, item);
}
fn visit_item_extern_crate(&mut self, item: &'ast syn::ItemExternCrate) {
let name = item.ident.to_string();
let target = ItemTarget::Const(name);
self.current_item_digest = antigen_fingerprint::structural_digest(item);
self.check_attrs(&item.attrs, "extern crate", &target);
syn::visit::visit_item_extern_crate(self, item);
}
fn visit_item_foreign_mod(&mut self, item: &'ast syn::ItemForeignMod) {
use quote::ToTokens;
let abi_str = item.abi.to_token_stream().to_string();
let target = ItemTarget::Const(abi_str);
self.current_item_digest = antigen_fingerprint::structural_digest(item);
self.check_attrs(&item.attrs, "foreign mod", &target);
syn::visit::visit_item_foreign_mod(self, item);
}
fn visit_item_mod(&mut self, item: &'ast syn::ItemMod) {
let name = item.ident.to_string();
let target = ItemTarget::Const(name);
self.current_item_digest = antigen_fingerprint::structural_digest(item);
self.check_attrs(&item.attrs, "mod", &target);
syn::visit::visit_item_mod(self, item);
}
fn visit_item_trait_alias(&mut self, item: &'ast syn::ItemTraitAlias) {
let name = item.ident.to_string();
let target = ItemTarget::Const(name);
self.current_item_digest = antigen_fingerprint::structural_digest(item);
self.check_attrs(&item.attrs, "trait alias", &target);
syn::visit::visit_item_trait_alias(self, item);
}
fn visit_item_union(&mut self, item: &'ast syn::ItemUnion) {
let name = item.ident.to_string();
let target = ItemTarget::Const(name);
self.current_item_digest = antigen_fingerprint::structural_digest(item);
self.check_attrs(&item.attrs, "union", &target);
syn::visit::visit_item_union(self, item);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn empty_scan_report_has_no_unaddressed() {
let report = ScanReport::default();
assert!(report.unaddressed_presentations().is_empty());
}
#[test]
fn antigen_args_parses_name_and_fingerprint() {
let tokens: proc_macro2::TokenStream = r#"
name = "frame-translation",
fingerprint = "item: enum, has_method(\"meet\", \"(Self, Self) -> Self\")"
"#
.parse()
.unwrap();
let args = syn::parse2::<ScanAntigenArgs>(tokens).unwrap();
assert_eq!(args.name, "frame-translation");
let fp = args.fingerprint.unwrap();
assert!(
fp.contains("has_method(\"meet\""),
"fingerprint should contain unescaped double-quotes, got: {fp:?}"
);
assert!(
!fp.contains(r#"\""#),
"fingerprint must not contain raw backslash-quote escape sequences, got: {fp:?}"
);
}
#[test]
fn antigen_args_parses_optional_fields() {
let tokens: proc_macro2::TokenStream =
r#"name = "panicking-in-drop", fingerprint = "impl Drop", family = "boundary-violation", summary = "Drop impl can panic""#
.parse()
.unwrap();
let args = syn::parse2::<ScanAntigenArgs>(tokens).unwrap();
assert_eq!(args.name, "panicking-in-drop");
assert_eq!(args.family.as_deref(), Some("boundary-violation"));
assert_eq!(args.summary.as_deref(), Some("Drop impl can panic"));
}
#[test]
fn immune_args_parses_antigen_type_and_witness() {
let tokens: proc_macro2::TokenStream = r"PanickingInDrop, witness = no_panic_in_drop_test"
.parse()
.unwrap();
let args = syn::parse2::<ScanImmuneArgs>(tokens).unwrap();
assert_eq!(args.antigen_type, "PanickingInDrop");
assert_eq!(args.witness, "no_panic_in_drop_test");
}
#[test]
fn immune_args_parses_path_witness() {
let tokens: proc_macro2::TokenStream =
r"FrameTranslation, witness = clippy :: no_panic_in_drop"
.parse()
.unwrap();
let args = syn::parse2::<ScanImmuneArgs>(tokens).unwrap();
assert_eq!(args.antigen_type, "FrameTranslation");
assert!(args.witness.contains("no_panic_in_drop"));
}
type ScanFixture = (
&'static str,
&'static str,
&'static str,
Option<&'static str>,
Option<&'static str>,
);
const SCAN_PARSER_FIXTURES: &[ScanFixture] = &[
(
r#"name = "panicking-in-drop", fingerprint = "impl Drop with panic""#,
"panicking-in-drop",
"impl Drop with panic",
None,
None,
),
(
r#"name = "frame-translation", fingerprint = "class enum + meet", family = "semantic-drift", summary = "Polarity inverts at the frame boundary""#,
"frame-translation",
"class enum + meet",
Some("semantic-drift"),
Some("Polarity inverts at the frame boundary"),
),
(
r#"name = "x", fingerprint = "item: enum, has_method(\"meet\", \"(Self, Self) -> Self\")""#,
"x",
r#"item: enum, has_method("meet", "(Self, Self) -> Self")"#,
None,
None,
),
(
r#"summary = "S", family = "F", fingerprint = "FP", name = "n""#,
"n",
"FP",
Some("F"),
Some("S"),
),
(
r#"name = "x", fingerprint = "y", references = ["GAP-1", "DEC-2"]"#,
"x",
"y",
None,
None,
),
(
"name = \"multi-line\",\n\tfingerprint = \"shape\",\n\tfamily = \"family\"",
"multi-line",
"shape",
Some("family"),
None,
),
];
#[test]
fn scan_parser_accepts_all_macro_fixtures() {
for (input, exp_name, exp_fp, exp_family, exp_summary) in SCAN_PARSER_FIXTURES {
let tokens: proc_macro2::TokenStream = input
.parse()
.unwrap_or_else(|e| panic!("fixture failed to tokenize: {input:?}: {e}"));
let args = syn::parse2::<ScanAntigenArgs>(tokens)
.unwrap_or_else(|e| panic!("scan parser rejected fixture {input:?}: {e}"));
assert_eq!(&args.name, exp_name, "name mismatch for fixture: {input:?}");
assert_eq!(
args.fingerprint.as_deref(),
Some(*exp_fp),
"fingerprint mismatch for fixture: {input:?}"
);
assert_eq!(
args.family.as_deref(),
*exp_family,
"family mismatch for fixture: {input:?}"
);
assert_eq!(
args.summary.as_deref(),
*exp_summary,
"summary mismatch for fixture: {input:?}"
);
}
}
#[test]
fn scan_parser_tolerates_unknown_fields() {
let tokens: proc_macro2::TokenStream =
r#"name = "x", fingerprint = "y", future_field = "irrelevant""#
.parse()
.unwrap();
let args = syn::parse2::<ScanAntigenArgs>(tokens).unwrap();
assert_eq!(args.name, "x");
assert_eq!(args.fingerprint.as_deref(), Some("y"));
}
#[test]
fn scan_parser_tolerates_missing_required_fields() {
let tokens: proc_macro2::TokenStream = r#"name = "only-name""#.parse().unwrap();
let args = syn::parse2::<ScanAntigenArgs>(tokens).unwrap();
assert_eq!(args.name, "only-name");
assert_eq!(args.fingerprint, None);
}
mod parser_props {
use super::super::*;
use proc_macro2::TokenStream;
use proptest::prelude::*;
const RUST_KEYWORDS: &[&str] = &[
"as", "async", "await", "box", "break", "const", "continue", "crate", "do", "dyn",
"else", "enum", "extern", "false", "fn", "for", "if", "impl", "in", "let", "loop",
"macro", "match", "mod", "move", "mut", "pub", "ref", "return", "self", "static",
"struct", "super", "trait", "true", "type", "union", "unsafe", "use", "where", "while",
"yield", "abstract", "become", "final", "override", "priv", "try",
];
fn valid_kebab() -> impl Strategy<Value = String> {
proptest::collection::vec(
(
proptest::char::range('a', 'z'),
proptest::collection::vec(
prop_oneof![
proptest::char::range('a', 'z'),
proptest::char::range('0', '9'),
],
0..8usize,
),
)
.prop_map(|(first, rest)| {
let mut s = String::with_capacity(rest.len() + 1);
s.push(first);
for c in rest {
s.push(c);
}
s
}),
1..5usize,
)
.prop_map(|segments| segments.join("-"))
}
fn valid_text(max_len: usize) -> impl Strategy<Value = String> {
proptest::collection::vec(
prop_oneof![
proptest::char::range(' ', '~').prop_filter("excluded chars", |c| {
*c != '\\' && *c != '"' && *c != '\0'
}),
],
1..=max_len,
)
.prop_map(|chars| chars.into_iter().collect())
}
fn lit(s: &str) -> String {
format!("{s:?}")
}
fn render_antigen_body(
name: &str,
fingerprint: &str,
family: Option<&str>,
summary: Option<&str>,
) -> String {
let mut parts = vec![
format!("name = {}", lit(name)),
format!("fingerprint = {}", lit(fingerprint)),
];
if let Some(f) = family {
parts.push(format!("family = {}", lit(f)));
}
if let Some(s) = summary {
parts.push(format!("summary = {}", lit(s)));
}
parts.join(", ")
}
proptest! {
#[test]
fn scan_parser_round_trip_on_macro_inputs(
name in valid_kebab(),
fingerprint in valid_text(64),
family in proptest::option::of(valid_text(32)),
summary in proptest::option::of(valid_text(64)),
) {
let body = render_antigen_body(&name, &fingerprint, family.as_deref(), summary.as_deref());
let tokens: TokenStream = body.parse().expect("body must tokenize");
let args = syn::parse2::<ScanAntigenArgs>(tokens).expect("scan must accept macro-acceptable input");
prop_assert_eq!(&args.name, &name);
prop_assert_eq!(args.fingerprint.as_deref(), Some(fingerprint.as_str()));
prop_assert_eq!(args.family.as_deref(), family.as_deref());
prop_assert_eq!(args.summary.as_deref(), summary.as_deref());
}
#[test]
fn scan_parser_order_invariant(
name in valid_kebab(),
fingerprint in valid_text(48),
family in valid_text(24),
summary in valid_text(48),
) {
let canonical = format!(
"name = {}, fingerprint = {}, family = {}, summary = {}",
lit(&name), lit(&fingerprint), lit(&family), lit(&summary),
);
let reversed = format!(
"summary = {}, family = {}, fingerprint = {}, name = {}",
lit(&summary), lit(&family), lit(&fingerprint), lit(&name),
);
let a: ScanAntigenArgs = syn::parse2(canonical.parse::<TokenStream>().unwrap()).unwrap();
let b: ScanAntigenArgs = syn::parse2(reversed.parse::<TokenStream>().unwrap()).unwrap();
prop_assert_eq!(&a.name, &b.name);
prop_assert_eq!(&a.fingerprint, &b.fingerprint);
prop_assert_eq!(&a.family, &b.family);
prop_assert_eq!(&a.summary, &b.summary);
}
#[test]
fn scan_parser_tolerates_arbitrary_unknown_field(
name in valid_kebab(),
fingerprint in valid_text(32),
unknown in "[a-z][a-z_]{2,12}".prop_filter(
"must not collide with known fields or Rust keywords",
|s| {
!matches!(s.as_str(), "name" | "fingerprint" | "family" | "summary" | "references")
&& !RUST_KEYWORDS.contains(&s.as_str())
},
),
unknown_val in valid_text(16),
) {
let body = format!(
"name = {}, fingerprint = {}, {} = {}",
lit(&name), lit(&fingerprint), unknown, lit(&unknown_val),
);
let tokens: TokenStream = body.parse().expect("body tokenizes");
let args = syn::parse2::<ScanAntigenArgs>(tokens).expect("scan tolerates unknown fields");
prop_assert_eq!(&args.name, &name);
prop_assert_eq!(args.fingerprint.as_deref(), Some(fingerprint.as_str()));
}
#[test]
fn scan_parser_tolerates_missing_fingerprint(
name in valid_kebab(),
) {
let body = format!("name = {}", lit(&name));
let tokens: TokenStream = body.parse().expect("body tokenizes");
let args = syn::parse2::<ScanAntigenArgs>(tokens).expect("scan tolerates missing fingerprint");
prop_assert_eq!(&args.name, &name);
prop_assert_eq!(args.fingerprint, None);
}
#[test]
fn scan_parser_consumes_references_array(
name in valid_kebab(),
fingerprint in valid_text(32),
refs in proptest::collection::vec(valid_text(24), 0..6usize),
) {
let refs_lit: Vec<String> = refs.iter().map(|s| lit(s)).collect();
let body = format!(
"name = {}, fingerprint = {}, references = [{}]",
lit(&name), lit(&fingerprint), refs_lit.join(", "),
);
let tokens: TokenStream = body.parse().expect("body tokenizes");
let args = syn::parse2::<ScanAntigenArgs>(tokens).expect("scan parses references");
prop_assert_eq!(&args.name, &name);
prop_assert_eq!(args.fingerprint.as_deref(), Some(fingerprint.as_str()));
}
#[test]
fn scan_immune_extracts_last_path_segment(
antigen in "[A-Z][A-Za-z0-9]{0,16}",
witness_segments in proptest::collection::vec(
"[a-z][a-z_0-9]{0,8}".prop_filter(
"must not be a Rust keyword",
|s| !RUST_KEYWORDS.contains(&s.as_str()),
),
1..4usize,
),
) {
let witness = witness_segments.join("::");
let body = format!("{antigen}, witness = {witness}");
let tokens: TokenStream = body.parse().expect("body tokenizes");
let args = syn::parse2::<ScanImmuneArgs>(tokens).expect("body parses");
prop_assert_eq!(args.antigen_type.as_str(), antigen.as_str());
let last = witness_segments.last().unwrap();
prop_assert!(args.witness.contains(last.as_str()),
"rendered witness {:?} should contain trailing segment {:?}", args.witness, last);
}
#[test]
fn scan_immune_qualified_antigen_path_extracts_last_segment(
module_segs in proptest::collection::vec(
"[a-z][a-z_0-9]{0,6}".prop_filter(
"must not be a Rust keyword",
|s| !RUST_KEYWORDS.contains(&s.as_str()),
),
1..3usize,
),
antigen in "[A-Z][A-Za-z0-9]{0,12}",
witness in "[a-z][a-z_0-9]{0,12}".prop_filter(
"must not be a Rust keyword",
|s| !RUST_KEYWORDS.contains(&s.as_str()),
),
) {
let qualified = format!("{}::{}", module_segs.join("::"), antigen);
let body = format!("{qualified}, witness = {witness}");
let tokens: TokenStream = body.parse().expect("body tokenizes");
let args = syn::parse2::<ScanImmuneArgs>(tokens).expect("body parses");
prop_assert_eq!(args.antigen_type.as_str(), antigen.as_str(),
"qualified antigen path {:?} must yield bare last-segment antigen_type", qualified);
}
}
}
#[test]
fn scan_recurrent_itch_captures_name_and_description() {
let tokens: proc_macro2::TokenStream =
r#"name = "drop-rhyme", description = "noticed Drop panics rhyme with unwrap-in-cleanup""#
.parse()
.unwrap();
let args = syn::parse2::<ScanRecurrentArgs>(tokens).unwrap();
assert_eq!(args.name.as_deref(), Some("drop-rhyme"));
assert!(args.description.as_deref().unwrap().contains("Drop panics"));
}
#[test]
fn scan_recurrent_anchor_captures_positional_antigen_and_instances() {
let tokens: proc_macro2::TokenStream = r#"MsrvCreep, instances = 3, since = "v0.1.0", rationale = "MSRV crept thrice across major bumps""#
.parse()
.unwrap();
let args = syn::parse2::<ScanRecurrentArgs>(tokens).unwrap();
assert_eq!(args.antigen_type.as_deref(), Some("MsrvCreep"));
assert_eq!(args.instances, Some(3));
assert_eq!(args.since.as_deref(), Some("v0.1.0"));
}
#[test]
fn scan_recurrent_anchor_extracts_qualified_antigen_last_segment() {
let tokens: proc_macro2::TokenStream = r#"antigen = crate::antigens::MsrvCreep, instances = 2, since = "v1", rationale = "twenty-char rationale text""#
.parse()
.unwrap();
let args = syn::parse2::<ScanRecurrentArgs>(tokens).unwrap();
assert_eq!(args.antigen_type.as_deref(), Some("MsrvCreep"));
}
#[test]
fn scan_recurrent_crystallize_captures_from_itches_idents() {
let tokens: proc_macro2::TokenStream =
r#"name = "x", from_itches = [DropPanicItch, CleanupUnwrapItch], summary = "crystallized from two""#
.parse()
.unwrap();
let args = syn::parse2::<ScanRecurrentArgs>(tokens).unwrap();
assert_eq!(args.from_itches, vec!["DropPanicItch", "CleanupUnwrapItch"]);
assert!(args
.description
.as_deref()
.unwrap()
.contains("crystallized"));
}
#[test]
fn scan_recurrent_chronic_captures_managed_by() {
let tokens: proc_macro2::TokenStream =
r#"FlakeyStep, since = "v0.2.0", managed_by = "ci-team""#
.parse()
.unwrap();
let args = syn::parse2::<ScanRecurrentArgs>(tokens).unwrap();
assert_eq!(args.antigen_type.as_deref(), Some("FlakeyStep"));
assert_eq!(args.managed_by.as_deref(), Some("ci-team"));
}
#[test]
fn scan_recurrent_strand_captures_anchored_by() {
let tokens: proc_macro2::TokenStream = r#"name = "vcs-thread", anchored_by = [ForcePushItch, SquashItch], description = "history-loss thread""#
.parse()
.unwrap();
let args = syn::parse2::<ScanRecurrentArgs>(tokens).unwrap();
assert_eq!(args.anchored_by, vec!["ForcePushItch", "SquashItch"]);
}
#[test]
fn scan_recurrent_tolerates_unknown_and_missing_fields() {
let tokens: proc_macro2::TokenStream =
r#"name = "x", threshold = "5", bogus_future_field = "ignored""#
.parse()
.unwrap();
let args = syn::parse2::<ScanRecurrentArgs>(tokens).unwrap();
assert_eq!(args.name.as_deref(), Some("x"));
}
#[test]
fn scan_recurrent_saturate_captures_contributing_to() {
let tokens: proc_macro2::TokenStream =
r#"description = "evidence accumulating", contributing_to = "msrv-creep-anchor""#
.parse()
.unwrap();
let args = syn::parse2::<ScanRecurrentArgs>(tokens).unwrap();
assert_eq!(args.contributing_to.as_deref(), Some("msrv-creep-anchor"));
}
#[test]
fn scan_mucosal_captures_kind_and_rationale() {
let tokens: proc_macro2::TokenStream =
r#"kind = MucosalKind::UserInput, rationale = "public form; sanitized at render""#
.parse()
.unwrap();
let args = syn::parse2::<ScanMucosalArgs>(tokens).unwrap();
assert_eq!(args.boundary_kind.as_deref(), Some("UserInput"));
assert!(args.rationale.as_deref().unwrap().contains("sanitized"));
}
#[test]
fn scan_mucosal_delegate_captures_boundary_and_handled_by_last_segment() {
let tokens: proc_macro2::TokenStream =
r#"boundary = MucosalKind::UserInput, handled_by = crate::sanitize::user_input, rationale = "delegated to central sanitizer""#
.parse()
.unwrap();
let args = syn::parse2::<ScanMucosalArgs>(tokens).unwrap();
assert_eq!(args.boundary_kind.as_deref(), Some("UserInput"));
assert_eq!(args.handled_by.as_deref(), Some("user_input"));
}
#[test]
fn scan_mucosal_tolerant_captures_accepts_reviewed_until() {
let tokens: proc_macro2::TokenStream = r#"kind = MucosalKind::ApiRequest, rationale = "internal admin endpoint behind VPN; trusted network", accepts = "admin form posts", reviewed_by = "security-team", until = "2026-12-31""#
.parse()
.unwrap();
let args = syn::parse2::<ScanMucosalArgs>(tokens).unwrap();
assert_eq!(args.boundary_kind.as_deref(), Some("ApiRequest"));
assert_eq!(args.accepts.as_deref(), Some("admin form posts"));
assert_eq!(args.reviewed_by.as_deref(), Some("security-team"));
assert_eq!(args.until.as_deref(), Some("2026-12-31"));
}
#[test]
fn scan_mucosal_tolerates_unknown_fields() {
let tokens: proc_macro2::TokenStream =
r#"kind = MucosalKind::Iframe, rationale = "embedded trusted widget context", future_field = "ignored""#
.parse()
.unwrap();
let args = syn::parse2::<ScanMucosalArgs>(tokens).unwrap();
assert_eq!(args.boundary_kind.as_deref(), Some("Iframe"));
}
fn edge(child: &str, parent: &str) -> LineageEdge {
LineageEdge {
child: child.to_string(),
parent: parent.to_string(),
file: PathBuf::from("test.rs"),
line: 1,
parent_canonical_path: None,
child_canonical_path: None,
}
}
#[test]
fn lineage_no_edges_no_failures() {
let failures = detect_lineage_failures(&[], MAX_LINEAGE_DEPTH);
assert!(failures.is_empty());
}
#[test]
fn lineage_acyclic_chain_no_failures() {
let edges = vec![edge("C", "B"), edge("B", "A")];
let failures = detect_lineage_failures(&edges, MAX_LINEAGE_DEPTH);
assert!(
failures.is_empty(),
"acyclic chain must produce no failures, got: {failures:?}"
);
}
#[test]
fn lineage_self_loop_detected() {
let edges = vec![edge("A", "A")];
let failures = detect_lineage_failures(&edges, MAX_LINEAGE_DEPTH);
assert_eq!(
failures.len(),
1,
"self-loop must report exactly one failure"
);
assert!(
failures[0].error.contains("cycle"),
"self-loop error must mention cycle, got: {}",
failures[0].error
);
assert!(
failures[0].error.contains("A -> A"),
"self-loop error must contain chain `A -> A`, got: {}",
failures[0].error
);
}
#[test]
fn lineage_two_node_cycle_detected() {
let edges = vec![edge("A", "B"), edge("B", "A")];
let failures = detect_lineage_failures(&edges, MAX_LINEAGE_DEPTH);
assert_eq!(
failures.len(),
1,
"2-cycle must report one failure, got: {failures:?}"
);
let err = &failures[0].error;
assert!(err.contains("cycle"), "must mention cycle, got: {err}");
assert!(
err.contains("A -> B -> A") || err.contains("B -> A -> B"),
"must contain full cycle chain, got: {err}"
);
}
#[test]
fn lineage_three_node_cycle_detected() {
let edges = vec![edge("A", "B"), edge("B", "C"), edge("C", "A")];
let failures = detect_lineage_failures(&edges, MAX_LINEAGE_DEPTH);
assert_eq!(
failures.len(),
1,
"3-cycle must report exactly one failure, got: {failures:?}"
);
}
#[test]
fn lineage_cycle_dedup_across_entry_points() {
let edges = vec![
edge("A", "B"),
edge("B", "C"),
edge("C", "A"),
edge("D", "B"), edge("E", "C"), ];
let failures = detect_lineage_failures(&edges, MAX_LINEAGE_DEPTH);
assert_eq!(
failures.len(),
1,
"same cycle entered from multiple roots must dedup, got: {failures:?}"
);
}
#[test]
fn lineage_two_disjoint_cycles_both_reported() {
let edges = vec![
edge("A", "B"),
edge("B", "A"),
edge("X", "Y"),
edge("Y", "X"),
];
let failures = detect_lineage_failures(&edges, MAX_LINEAGE_DEPTH);
assert_eq!(
failures.len(),
2,
"two disjoint cycles must produce two failures, got: {failures:?}"
);
}
#[test]
fn lineage_diamond_no_cycle() {
let edges = vec![
edge("A", "B"),
edge("A", "C"),
edge("B", "D"),
edge("C", "D"),
];
let failures = detect_lineage_failures(&edges, MAX_LINEAGE_DEPTH);
assert!(
failures.is_empty(),
"DAG diamond must not be reported as cycle, got: {failures:?}"
);
}
#[test]
fn lineage_depth_limit_fires_on_long_linear_chain() {
let edges: Vec<LineageEdge> = (0..10)
.map(|i| edge(&format!("N{i}"), &format!("N{}", i + 1)))
.collect();
let failures = detect_lineage_failures(&edges, 5);
assert!(
failures.iter().any(|f| f.error.contains("maximum depth")),
"depth limit must fire on long linear chain, got: {failures:?}"
);
}
#[test]
fn lineage_depth_limit_boundary_exactly_at_max() {
let accepted_edges: Vec<LineageEdge> = (0..MAX_LINEAGE_DEPTH - 1)
.map(|i| edge(&format!("N{i}"), &format!("N{}", i + 1)))
.collect();
let failures = detect_lineage_failures(&accepted_edges, MAX_LINEAGE_DEPTH);
assert!(
failures.is_empty(),
"ATK-LINEAGE-BOUNDARY: a chain of {}-1={} edges ({} nodes) must be \
accepted by the depth limit (path.len()={} is NOT > {}). \
Got failures: {failures:?}",
MAX_LINEAGE_DEPTH,
MAX_LINEAGE_DEPTH - 1,
MAX_LINEAGE_DEPTH,
MAX_LINEAGE_DEPTH,
MAX_LINEAGE_DEPTH,
);
let rejected_edges: Vec<LineageEdge> = (0..MAX_LINEAGE_DEPTH)
.map(|i| edge(&format!("M{i}"), &format!("M{}", i + 1)))
.collect();
let failures = detect_lineage_failures(&rejected_edges, MAX_LINEAGE_DEPTH);
assert!(
failures.iter().any(|f| f.error.contains("maximum depth")),
"ATK-LINEAGE-BOUNDARY: a chain of {} edges ({} nodes) must fire the \
depth limit (path.len()={} IS > {}). \
Got: {failures:?}",
MAX_LINEAGE_DEPTH,
MAX_LINEAGE_DEPTH + 1,
MAX_LINEAGE_DEPTH + 1,
MAX_LINEAGE_DEPTH,
);
}
#[test]
fn lineage_canonicalise_cycle_basic() {
let a = canonicalise_cycle(&["A", "B", "C"]);
let b = canonicalise_cycle(&["B", "C", "A"]);
let c = canonicalise_cycle(&["C", "A", "B"]);
assert_eq!(a, b);
assert_eq!(b, c);
}
#[test]
fn lineage_canonicalise_cycle_distinguishes_distinct() {
let a = canonicalise_cycle(&["A", "B"]);
let b = canonicalise_cycle(&["A", "C"]);
assert_ne!(a, b);
}
fn antigen_decl(type_name: &str) -> AntigenDeclaration {
AntigenDeclaration {
name: type_name.to_lowercase(),
type_name: type_name.to_string(),
file: PathBuf::from("test.rs"),
line: 1,
family: None,
summary: None,
fingerprint: None,
canonical_path: None,
category: Vec::new(),
}
}
#[test]
fn orphaned_lineage_edges_empty_report_returns_empty() {
let report = ScanReport::default();
assert!(report.orphaned_lineage_edges().is_empty());
}
#[test]
fn orphaned_lineage_edges_known_parent_not_orphan() {
let mut report = ScanReport::default();
report.antigens.push(antigen_decl("Parent"));
report.antigens.push(antigen_decl("Child"));
report.lineage_edges.push(edge("Child", "Parent"));
assert!(report.orphaned_lineage_edges().is_empty());
}
#[test]
fn orphaned_lineage_edges_unknown_parent_is_orphan() {
let mut report = ScanReport::default();
report.antigens.push(antigen_decl("Child"));
report.lineage_edges.push(edge("Child", "MissingParent"));
let orphans = report.orphaned_lineage_edges();
assert_eq!(orphans.len(), 1);
assert_eq!(orphans[0].parent, "MissingParent");
}
fn antigen_decl_in(type_name: &str, crate_id: &str) -> AntigenDeclaration {
let mut a = antigen_decl(type_name);
a.canonical_path = Some(crate_id.to_string());
a
}
#[test]
fn member_root_canonical_path_is_name_at_version() {
let m = WorkspaceMemberRoot {
package_name: "antigen-fingerprint".to_string(),
version: "0.3.0-alpha.1".to_string(),
crate_root: PathBuf::from("/ws/antigen-fingerprint"),
};
assert_eq!(m.canonical_path(), "antigen-fingerprint@0.3.0-alpha.1");
}
#[test]
fn merge_unions_all_record_vectors_and_sums_counts() {
let mut a = ScanReport {
files_scanned: 3,
..ScanReport::default()
};
a.antigens.push(antigen_decl_in("AlphaA", "crate-a@1.0.0"));
a.lineage_edges.push(edge("ChildA", "AlphaA"));
let mut b = ScanReport {
files_scanned: 5,
..ScanReport::default()
};
b.antigens.push(antigen_decl_in("BetaB", "crate-b@1.0.0"));
b.parse_failures.push(ParseFailure {
file: PathBuf::from("b.rs"),
error: "boom".to_string(),
});
a.merge(b);
assert_eq!(a.antigens.len(), 2, "antigen vectors union");
assert_eq!(a.lineage_edges.len(), 1, "edges carry over");
assert_eq!(a.parse_failures.len(), 1, "parse failures union");
assert_eq!(a.files_scanned, 8, "file counts sum");
}
#[test]
fn cross_member_parent_reresolves_to_declaring_member() {
let mut report = ScanReport::default();
report
.antigens
.push(antigen_decl_in("Child", "crate-a@1.0.0"));
report
.antigens
.push(antigen_decl_in("Shared", "crate-b@1.0.0"));
let mut e = edge("Child", "Shared");
e.child_canonical_path = Some("crate-a@1.0.0".to_string());
e.parent_canonical_path = Some("crate-a@1.0.0".to_string()); report.lineage_edges.push(e);
resolve_cross_member_lineage_parents(&mut report);
assert_eq!(
report.lineage_edges[0].parent_canonical_path.as_deref(),
Some("crate-b@1.0.0"),
"parent endpoint must re-resolve to the member that declares `Shared`"
);
assert!(
report
.parse_failures
.iter()
.all(|f| !f.error.contains("ambiguous")),
"unambiguous cross-member parent must not produce an ambiguity diagnostic"
);
assert!(
report.orphaned_lineage_edges().is_empty(),
"re-resolved cross-member edge must not be orphaned"
);
}
#[test]
fn cross_member_parent_ambiguous_name_collision_is_diagnosed_not_guessed() {
let mut report = ScanReport::default();
report
.antigens
.push(antigen_decl_in("Dup", "crate-a@1.0.0"));
report
.antigens
.push(antigen_decl_in("Dup", "crate-b@1.0.0"));
report
.antigens
.push(antigen_decl_in("Child", "crate-c@1.0.0"));
let mut e = edge("Child", "Dup");
e.child_canonical_path = Some("crate-c@1.0.0".to_string());
e.parent_canonical_path = Some("crate-c@1.0.0".to_string());
report.lineage_edges.push(e);
resolve_cross_member_lineage_parents(&mut report);
assert_eq!(
report.lineage_edges[0].parent_canonical_path.as_deref(),
Some("crate-c@1.0.0"),
"ambiguous parent must NOT be silently re-stamped to one member"
);
let ambiguity: Vec<_> = report
.parse_failures
.iter()
.filter(|f| f.error.contains("ambiguous across the workspace"))
.collect();
assert_eq!(
ambiguity.len(),
1,
"ambiguous cross-member name must produce exactly one diagnostic; got: {:?}",
report.parse_failures
);
assert!(
ambiguity[0].error.contains("crate-a@1.0.0")
&& ambiguity[0].error.contains("crate-b@1.0.0"),
"ambiguity diagnostic must name both colliding members"
);
}
#[test]
fn cross_member_parent_unknown_name_left_orphan() {
let mut report = ScanReport::default();
report
.antigens
.push(antigen_decl_in("Child", "crate-a@1.0.0"));
let mut e = edge("Child", "Ghost");
e.child_canonical_path = Some("crate-a@1.0.0".to_string());
e.parent_canonical_path = Some("crate-a@1.0.0".to_string());
report.lineage_edges.push(e);
resolve_cross_member_lineage_parents(&mut report);
assert_eq!(
report.lineage_edges[0].parent_canonical_path.as_deref(),
Some("crate-a@1.0.0"),
"unknown parent edge is left unchanged"
);
assert!(
report.parse_failures.is_empty(),
"unknown parent is not an ambiguity — no diagnostic from this pass"
);
let orphans = report.orphaned_lineage_edges();
assert_eq!(orphans.len(), 1, "unknown parent surfaces as orphan");
assert_eq!(orphans[0].parent, "Ghost");
}
fn presentation_in(antigen_type: &str, crate_id: &str) -> Presentation {
Presentation {
antigen_type: antigen_type.to_string(),
file: PathBuf::from("src/lib.rs"),
line: 1,
item_kind: "fn".to_string(),
item_target: ItemTarget::Fn(format!("site_in_{}", crate_id.replace('@', "_"))),
match_kind: MatchKind::ExplicitMarker,
canonical_path: Some(crate_id.to_string()),
inherited_from: None,
structural_fingerprint: String::new(),
requires_predicate: None,
proof: None,
}
}
#[test]
fn cross_member_addresses_ambiguous_name_is_diagnosed_not_guessed() {
let mut report = ScanReport::default();
report
.antigens
.push(antigen_decl_in("Shared", "crate-a@1.0.0"));
report
.antigens
.push(antigen_decl_in("Shared", "crate-b@1.0.0"));
report
.presentations
.push(presentation_in("Shared", "crate-c@1.0.0"));
resolve_cross_member_addresses(&mut report);
assert_eq!(
report.presentations[0].canonical_path.as_deref(),
Some("crate-c@1.0.0"),
"ambiguous addresses() must NOT re-stamp to either declaring member; \
got {:?}",
report.presentations[0].canonical_path
);
let ambiguity: Vec<_> = report
.parse_failures
.iter()
.filter(|f| f.error.contains("ambiguous across the workspace"))
.collect();
assert_eq!(
ambiguity.len(),
1,
"ambiguous same-name cross-member addresses() must produce exactly one \
diagnostic; got: {:?}",
report.parse_failures
);
assert!(
ambiguity[0].error.contains("crate-a@1.0.0")
&& ambiguity[0].error.contains("crate-b@1.0.0"),
"ambiguity diagnostic must name both colliding members; got: {}",
ambiguity[0].error
);
}
#[test]
fn cross_member_addresses_unknown_antigen_is_left_unchanged() {
let mut report = ScanReport::default();
report
.antigens
.push(antigen_decl_in("Other", "crate-a@1.0.0"));
report
.presentations
.push(presentation_in("Ghost", "crate-b@1.0.0"));
resolve_cross_member_addresses(&mut report);
assert_eq!(
report.presentations[0].canonical_path.as_deref(),
Some("crate-b@1.0.0"),
"unknown antigen must leave the presentation keyed to its own member"
);
assert!(
report.parse_failures.is_empty(),
"unknown antigen is not an ambiguity — no diagnostic from this pass; \
got: {:?}",
report.parse_failures
);
}
fn coverage(enumerated: &[&str], scanned: &[&str]) -> ScanCoverage {
ScanCoverage {
enumerated_members: enumerated.iter().map(|s| (*s).to_string()).collect(),
scanned_members: scanned.iter().map(|s| (*s).to_string()).collect(),
}
}
#[test]
fn coverage_complete_when_all_enumerated_are_scanned() {
let c = coverage(&["a@1", "b@1"], &["a@1", "b@1"]);
assert!(
c.is_complete(),
"every enumerated member scanned ⇒ complete"
);
assert!(
c.unscanned_members().is_empty(),
"complete coverage has an empty ignorance frontier"
);
}
#[test]
fn coverage_unscanned_member_is_the_ignorance_frontier() {
let c = coverage(&["a@1", "b@1", "c@1"], &["a@1", "b@1"]);
assert!(
!c.is_complete(),
"an unscanned member ⇒ incomplete coverage"
);
assert_eq!(
c.unscanned_members(),
vec!["c@1"],
"the frontier is exactly the enumerated-minus-scanned set"
);
}
#[test]
fn coverage_empty_workspace_is_vacuously_complete() {
let c = coverage(&[], &[]);
assert!(c.is_complete());
assert!(c.unscanned_members().is_empty());
}
#[test]
fn atk_a3_dup_duplicate_lineage_edge_is_diagnosed_not_silent() {
let edges = vec![
edge("A", "B"),
edge("A", "B"), ];
let (deduped, failures) = dedupe_lineage_edges(&edges);
assert_eq!(
deduped.len(),
1,
"duplicate edges must collapse to one in the deduped output"
);
assert!(
!failures.is_empty(),
"duplicate lineage edge (A->B twice) must produce at least one \
diagnostic; got: {failures:?}"
);
}
#[test]
fn dedupe_distinguishes_edges_by_canonical_path() {
let edge_v1 = LineageEdge {
child: "Child".to_string(),
parent: "Parent".to_string(),
file: PathBuf::from("test.rs"),
line: 1,
parent_canonical_path: Some("foo@1.0.0".to_string()),
child_canonical_path: None,
};
let edge_v2 = LineageEdge {
child: "Child".to_string(),
parent: "Parent".to_string(),
file: PathBuf::from("test.rs"),
line: 2,
parent_canonical_path: Some("foo@2.0.0".to_string()),
child_canonical_path: None,
};
let (deduped, failures) = dedupe_lineage_edges(&[edge_v1, edge_v2]);
assert_eq!(
deduped.len(),
2,
"edges differing in parent_canonical_path are distinct identities, \
not duplicates"
);
assert!(
failures.is_empty(),
"no dedup failure should fire for cross-version edges; got: {failures:?}"
);
}
#[test]
fn atk_a3_shared_two_cycles_sharing_a_node_both_reported() {
let edges = vec![
edge("A", "B"),
edge("B", "A"),
edge("A", "C"),
edge("C", "A"),
];
let failures = detect_lineage_failures(&edges, MAX_LINEAGE_DEPTH);
assert_eq!(
failures.len(),
2,
"two distinct cycles sharing node A must both be reported; \
got: {failures:?}"
);
let texts: Vec<&str> = failures.iter().map(|f| f.error.as_str()).collect();
assert!(
texts.iter().any(|t| t.contains('A') && t.contains('B')),
"one failure must name the A-B cycle; texts: {texts:?}"
);
assert!(
texts.iter().any(|t| t.contains('A') && t.contains('C')),
"one failure must name the A-C cycle; texts: {texts:?}"
);
}
#[test]
fn atk_a3_combined_cycle_and_depth_exceeded_both_reported() {
let depth = 3_usize;
let mut edges = vec![edge("X", "Y"), edge("Y", "X")];
for i in 0..=(depth + 2) {
edges.push(edge(&format!("N{i}"), &format!("N{}", i + 1)));
}
let failures = detect_lineage_failures(&edges, depth);
assert!(
failures.iter().any(|f| f.error.contains("cycle")),
"cycle X->Y->X must be detected even when long chain is also present; \
all failures: {failures:?}"
);
assert!(
failures.iter().any(|f| f.error.contains("maximum depth")),
"depth limit must fire on long chain even when cycle is also present; \
all failures: {failures:?}"
);
}
#[test]
fn atk_a3_orphan_child_without_antigen_declaration_is_surfaced() {
let mut report = ScanReport::default();
report.antigens.push(antigen_decl("Parent"));
report.lineage_edges.push(edge("OrphanChild", "Parent"));
let orphans = report.orphaned_lineage_edges();
let dangling = report.dangling_child_lineage_edges();
assert!(
!orphans.is_empty() || !dangling.is_empty() || !report.parse_failures.is_empty(),
"lineage edge whose child has no #[antigen] declaration must be \
surfaced via orphaned_lineage_edges, dangling_child_lineage_edges, or \
parse_failures; got orphans: {orphans:?}, dangling: {dangling:?}"
);
assert!(
orphans.is_empty(),
"child-missing case must NOT appear in orphaned_lineage_edges \
(that channel is for parent-missing); got: {orphans:?}"
);
assert_eq!(
dangling.len(),
1,
"child-missing must appear in dangling_child_lineage_edges, exactly one"
);
assert_eq!(dangling[0].child, "OrphanChild");
assert_eq!(dangling[0].parent, "Parent");
}
#[test]
fn stamp_canonical_path_sets_none_to_some() {
let mut report = ScanReport::default();
report.antigens.push(antigen_decl("Foo"));
report.lineage_edges.push(edge("Child", "Parent"));
report.stamp_canonical_path("crate-a@1.0.0");
assert_eq!(
report.antigens[0].canonical_path.as_deref(),
Some("crate-a@1.0.0"),
"antigens with canonical_path: None must be stamped"
);
assert_eq!(
report.lineage_edges[0].parent_canonical_path.as_deref(),
Some("crate-a@1.0.0")
);
assert_eq!(
report.lineage_edges[0].child_canonical_path.as_deref(),
Some("crate-a@1.0.0")
);
}
#[test]
fn stamp_canonical_path_does_not_overwrite_some() {
let mut a = antigen_decl("Foo");
a.canonical_path = Some("crate-a@1.0.0".to_string());
let mut report = ScanReport::default();
report.antigens.push(a);
report.stamp_canonical_path("crate-b@2.0.0");
assert_eq!(
report.antigens[0].canonical_path.as_deref(),
Some("crate-a@1.0.0"),
"pre-stamped Some(_) must NOT be overwritten by a later stamp call"
);
}
#[test]
fn stamp_canonical_path_is_idempotent() {
let mut report = ScanReport::default();
report.antigens.push(antigen_decl("Foo"));
report.stamp_canonical_path("crate-a@1.0.0");
let after_first = report.clone();
report.stamp_canonical_path("crate-a@1.0.0");
assert_eq!(
report.antigens[0].canonical_path, after_first.antigens[0].canonical_path,
"stamping with same crate_id twice must be idempotent"
);
}
fn scan_source(src: &str) -> ScanReport {
let file = syn::parse_file(src).expect("test source parses");
let mut report = ScanReport::default();
let mut visitor = ScanVisitor {
file_path: std::path::PathBuf::from("test.rs"),
report: &mut report,
impl_stack: Vec::new(),
trait_stack: Vec::new(),
current_item_digest: String::new(),
};
visitor.visit_file(&file);
report
}
#[test]
fn scan_discovers_defended_by_registration() {
let report = scan_source(
r"
#[test]
#[defended_by(ParallelStateTrackersDiverge)]
fn bijection_audit_hints_const_matches_enum() {}
",
);
assert_eq!(
report.defenses.len(),
1,
"exactly one #[defended_by] registration expected; got: {:?}",
report.defenses
);
let d = &report.defenses[0];
assert_eq!(d.antigen_type, "ParallelStateTrackersDiverge");
assert_eq!(d.item_kind, "fn");
assert_eq!(
d.item_target,
ItemTarget::Fn("bijection_audit_hints_const_matches_enum".to_string())
);
}
#[test]
fn scan_defended_by_accepts_qualified_path_uses_last_segment() {
let report = scan_source(
r"
#[test]
#[defended_by(crate::antigens::DropPanicClass)]
fn no_panic_in_drop() {}
",
);
assert_eq!(report.defenses.len(), 1);
assert_eq!(report.defenses[0].antigen_type, "DropPanicClass");
}
#[test]
fn scan_bare_defended_by_without_antigen_is_parse_failure_not_ghost() {
let report = scan_source(
r"
#[defended_by]
fn witness_for_nothing() {}
",
);
assert!(
report.defenses.is_empty(),
"bare #[defended_by] must not record a ghost defense; got: {:?}",
report.defenses
);
assert!(
report
.parse_failures
.iter()
.any(|f| f.error.contains("#[defended_by] requires an antigen type")),
"expected a parse failure naming the missing antigen type; got: {:?}",
report.parse_failures
);
}
#[test]
fn scan_presents_captures_requires_predicate() {
let report = scan_source(
r#"
#[presents(UnpinnedDependency, requires = ratified_doc(path = "docs/x.md"))]
fn add_dependency() {}
"#,
);
assert_eq!(report.presentations.len(), 1);
let p = &report.presentations[0];
assert_eq!(p.antigen_type, "UnpinnedDependency");
assert!(
p.requires_predicate.is_some(),
"the requires= predicate must be captured on the presents-site; got: {p:?}"
);
assert!(p.proof.is_none());
}
#[test]
fn scan_presents_captures_proof_expression() {
let report = scan_source(
r"
#[presents(DropPanicClass, proof = NonPanickingProof::<T>::verified)]
fn make_droppable() {}
",
);
assert_eq!(report.presentations.len(), 1);
let p = &report.presentations[0];
assert_eq!(p.antigen_type, "DropPanicClass");
assert!(
p.proof
.as_deref()
.is_some_and(|s| s.contains("NonPanickingProof")),
"the proof= expression must be captured on the presents-site; got: {p:?}"
);
assert!(p.requires_predicate.is_none());
}
#[test]
fn scan_bare_presents_has_no_site_evidence() {
let report = scan_source(
r"
#[presents(PanickingInDrop)]
fn might_panic() {}
",
);
assert_eq!(report.presentations.len(), 1);
assert!(report.presentations[0].requires_predicate.is_none());
assert!(report.presentations[0].proof.is_none());
}
#[test]
fn atk_adr009_amd1_no_fingerprint_antigen_produces_no_fingerprint_match_presentations() {
let src = r#"
#[antigen(
name = "verify-only-class",
category = AntigenCategory::SubstrateAlignment,
summary = "A verify-only antigen with no fingerprint."
)]
pub struct VerifyOnlyClass;
/// verify-only-class: this function mentions the antigen by name in a doc comment.
/// If fingerprint were `doc_contains("verify-only-class")`, this would match.
pub fn a_function_that_would_match() {}
"#;
let report = scan_source(src);
let fingerprints: Vec<(String, antigen_fingerprint::Fingerprint)> = report
.antigens
.iter()
.filter_map(|ag| {
let raw = ag.fingerprint.as_deref()?;
antigen_fingerprint::Fingerprint::parse(raw)
.ok()
.map(|fp| (ag.type_name.clone(), fp))
})
.collect();
assert!(
fingerprints.is_empty(),
"ATK-ADR009-AMD1(a): no-fingerprint antigen must produce empty fingerprints vec; \
got: {fingerprints:?}"
);
let fingerprint_matches: Vec<_> = report
.presentations
.iter()
.filter(|p| p.match_kind == MatchKind::FingerprintMatch)
.collect();
assert!(
fingerprint_matches.is_empty(),
"ATK-ADR009-AMD1(a): no-fingerprint antigen must produce zero FingerprintMatch \
presentations; got {}: {fingerprint_matches:?}",
fingerprint_matches.len()
);
}
#[test]
fn atk_adr009_amd1_no_fingerprint_does_not_suppress_explicit_presents() {
let src = r#"
#[antigen(
name = "verify-only-class",
summary = "No fingerprint."
)]
pub struct VerifyOnlyClass;
#[presents(VerifyOnlyClass)]
pub fn explicitly_marked_site() {}
"#;
let report = scan_source(src);
let explicit: Vec<_> = report
.presentations
.iter()
.filter(|p| p.match_kind == MatchKind::ExplicitMarker)
.collect();
assert_eq!(
explicit.len(),
1,
"ATK-ADR009-AMD1(c): a no-fingerprint antigen must not suppress explicit \
#[presents] markers; got {} explicit sites: {:?}",
explicit.len(),
explicit
);
assert_eq!(
explicit[0].antigen_type, "VerifyOnlyClass",
"ATK-ADR009-AMD1(c): explicit site must name the correct antigen"
);
assert!(
report
.presentations
.iter()
.all(|p| p.match_kind == MatchKind::ExplicitMarker),
"ATK-ADR009-AMD1(c): all presentations must be ExplicitMarker; no synthesis \
occurred (no fingerprint)"
);
}
#[test]
fn atk_adr009_amd1_no_diagnostic_for_accidental_omission() {
let src = r#"
#[antigen(
name = "accidentally-no-fingerprint",
summary = "Author intended a fingerprint but forgot it."
)]
pub struct AccidentallyNoFingerprint;
"#;
let report = scan_source(src);
assert_eq!(
report.antigens.len(),
1,
"antigen declaration must be scanned"
);
assert!(
report.antigens[0].fingerprint.is_none(),
"no fingerprint in declaration"
);
assert!(
report.parse_failures.is_empty(),
"ATK-ADR009-AMD1(d) documented gap: no diagnostic for accidental fingerprint \
omission; parse_failures is empty even when an author forgot to write a \
fingerprint. Mitigation direction: a future lint warning for antigens with \
no fingerprint and no explicit detection_model=verify_only annotation."
);
}
#[test]
fn scan_immunosuppress_captures_since_and_duration_cap_as_typed_fields() {
let report = scan_source(
r#"
#[immunosuppress(rationale = "mid-refactor, defense lands in PR42", since = "2020-01-01", duration_cap = 30)]
fn suppressed_site() {}
"#,
);
assert_eq!(report.deferred_defenses.len(), 1);
let d = &report.deferred_defenses[0];
assert_eq!(d.kind, crate::scan::DeferredDefenseKind::Immunosuppress);
assert_eq!(
d.since.as_deref(),
Some("2020-01-01"),
"since must be captured as a typed field, not a see[] string tag"
);
assert_eq!(
d.duration_cap,
Some(30),
"duration_cap must be captured as a typed field"
);
assert!(
!d.see
.iter()
.any(|s| s.starts_with("since:") || s.starts_with("duration_cap:")),
"since/duration_cap must NOT be stuffed into see[] as string tags; got: {:?}",
d.see
);
}
}