use proc_macro2::{TokenStream as TokenStream2, TokenTree};
use std::collections::HashMap;
use syn::visit::{self, Visit};
use syn::{Expr, ExprAssign, ExprField, ExprIndex, ExprPath, ExprReference, Ident, Member};
use crate::model::FieldAccessStat;
use crate::utils::{is_assign_op, is_target_path, unwrap_expr};
pub struct FieldAccessCollector {
target: String,
pub accesses: HashMap<String, FieldAccessStat>,
}
impl FieldAccessCollector {
pub fn new(target: &str) -> Self {
Self {
target: target.to_string(),
accesses: HashMap::new(),
}
}
fn record(&mut self, field: &str, write: bool) {
let entry = self.accesses.entry(field.to_string()).or_default();
if write {
entry.writes += 1;
} else {
entry.reads += 1;
}
}
fn field_of_target<'e>(&self, expr: &'e Expr) -> Option<&'e Ident> {
if let Expr::Field(ExprField {
base,
member: Member::Named(name),
..
}) = unwrap_expr(expr)
&& is_target_path(base, &self.target)
{
return Some(name);
}
None
}
}
impl<'ast> Visit<'ast> for FieldAccessCollector {
fn visit_expr_field(&mut self, node: &'ast ExprField) {
if let Member::Named(name) = &node.member
&& is_target_path(&node.base, &self.target)
{
self.record(&name.to_string(), false);
return;
}
visit::visit_expr_field(self, node);
}
fn visit_expr_assign(&mut self, node: &'ast ExprAssign) {
if let Some(name) = self.field_of_target(&node.left) {
self.record(&name.to_string(), true);
} else {
self.visit_expr(&node.left);
}
self.visit_expr(&node.right);
}
fn visit_expr_binary(&mut self, node: &'ast syn::ExprBinary) {
if is_assign_op(&node.op) {
if let Some(name) = self.field_of_target(&node.left) {
self.record(&name.to_string(), true);
} else {
self.visit_expr(&node.left);
}
self.visit_expr(&node.right);
} else {
visit::visit_expr_binary(self, node);
}
}
fn visit_expr_reference(&mut self, node: &'ast ExprReference) {
if node.mutability.is_some()
&& let Some(name) = self.field_of_target(&node.expr)
{
self.record(&name.to_string(), true);
return;
}
visit::visit_expr_reference(self, node);
}
fn visit_macro(&mut self, node: &'ast syn::Macro) {
scan_tokens_for_field_access(node.tokens.clone(), &self.target, &mut self.accesses);
visit::visit_macro(self, node);
}
}
pub struct IndexedFieldAccessCollector<'a> {
known: &'a HashMap<String, String>,
pub data: HashMap<String, HashMap<String, FieldAccessStat>>,
}
impl<'a> IndexedFieldAccessCollector<'a> {
pub fn new(known: &'a HashMap<String, String>) -> Self {
Self {
known,
data: HashMap::new(),
}
}
fn record(&mut self, collection: &str, field: &str, write: bool) {
let entry = self
.data
.entry(collection.to_string())
.or_default()
.entry(field.to_string())
.or_default();
if write {
entry.writes += 1;
} else {
entry.reads += 1;
}
}
fn indexed_field<'e>(&self, node: &'e ExprField) -> Option<(String, &'e Ident)> {
let Member::Named(field) = &node.member else {
return None;
};
let Expr::Index(ExprIndex { expr: inner, .. }) = unwrap_expr(&node.base) else {
return None;
};
let Expr::Path(ExprPath {
path, qself: None, ..
}) = unwrap_expr(inner)
else {
return None;
};
if path.segments.len() != 1 {
return None;
}
let name = path.segments[0].ident.to_string();
if self.known.contains_key(&name) {
Some((name, field))
} else {
None
}
}
}
impl<'a, 'ast> Visit<'ast> for IndexedFieldAccessCollector<'a> {
fn visit_expr_field(&mut self, node: &'ast ExprField) {
if let Some((coll, field)) = self.indexed_field(node) {
self.record(&coll, &field.to_string(), false);
return;
}
visit::visit_expr_field(self, node);
}
fn visit_expr_assign(&mut self, node: &'ast ExprAssign) {
if let Expr::Field(f) = unwrap_expr(&node.left)
&& let Some((coll, field)) = self.indexed_field(f)
{
self.record(&coll, &field.to_string(), true);
self.visit_expr(&node.right);
return;
}
self.visit_expr(&node.left);
self.visit_expr(&node.right);
}
fn visit_expr_binary(&mut self, node: &'ast syn::ExprBinary) {
if is_assign_op(&node.op) {
if let Expr::Field(f) = unwrap_expr(&node.left)
&& let Some((coll, field)) = self.indexed_field(f)
{
self.record(&coll, &field.to_string(), true);
self.visit_expr(&node.right);
return;
}
self.visit_expr(&node.left);
self.visit_expr(&node.right);
} else {
visit::visit_expr_binary(self, node);
}
}
fn visit_expr_reference(&mut self, node: &'ast ExprReference) {
if node.mutability.is_some()
&& let Expr::Field(f) = unwrap_expr(&node.expr)
&& let Some((coll, field)) = self.indexed_field(f)
{
self.record(&coll, &field.to_string(), true);
return;
}
visit::visit_expr_reference(self, node);
}
}
pub fn scan_tokens_for_field_access(
tokens: TokenStream2,
target: &str,
out: &mut HashMap<String, FieldAccessStat>,
) {
let trees: Vec<TokenTree> = tokens.into_iter().collect();
let mut i = 0;
while i < trees.len() {
match &trees[i] {
TokenTree::Ident(id) if *id == target => {
if let (Some(TokenTree::Punct(p)), Some(TokenTree::Ident(field))) =
(trees.get(i + 1), trees.get(i + 2))
&& p.as_char() == '.'
{
out.entry(field.to_string()).or_default().reads += 1;
i += 3;
continue;
}
i += 1;
}
TokenTree::Group(g) => {
scan_tokens_for_field_access(g.stream(), target, out);
i += 1;
}
_ => i += 1,
}
}
}