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;
use quote::{format_ident, quote};
use std::collections::HashSet;
use syn::Item;

use crate::model::StructInfo;
use crate::utils::pluralize;

pub fn generate_soa_suggestion(info: &StructInfo, hot_names: &HashSet<String>) -> String {
    let soa_name = format_ident!("{}", pluralize(&info.name));

    let mut ordered: Vec<_> = info
        .fields
        .iter()
        .filter(|f| hot_names.contains(&f.name))
        .collect();
    ordered.extend(info.fields.iter().filter(|f| !hot_names.contains(&f.name)));

    let field_defs = ordered.iter().map(|f| {
        let name = format_ident!("{}", pluralize(&f.name));
        let ty = &f.ty;
        quote! { pub #name: Vec<#ty>, }
    });

    let tokens = quote! {
        pub struct #soa_name {
            #(#field_defs)*
        }
    };
    render_item(tokens)
}

pub fn generate_soa_derive_suggestion(info: &StructInfo) -> String {
    let name = format_ident!("{}", info.name);
    let field_defs = info.fields.iter().map(|f| {
        let fname = format_ident!("{}", f.name);
        let ty = &f.ty;
        quote! { pub #fname: #ty, }
    });
    let tokens = quote! {
        #[derive(StructOfArray)]
        pub struct #name {
            #(#field_defs)*
        }
    };
    render_item(tokens)
}

fn render_item(tokens: TokenStream2) -> String {
    match syn::parse2::<Item>(tokens.clone()) {
        Ok(item) => {
            let file = syn::File {
                shebang: None,
                attrs: vec![],
                items: vec![item],
            };
            prettyplease::unparse(&file)
        }
        Err(_) => tokens.to_string(),
    }
}