cache-lens 0.1.0

A static analyzer that detects cache-unfriendly Array-of-Structures (AoS) usage in Rust and suggests Structure-of-Arrays (SoA) refactors.
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,
        }
    }
}