sassi-macros 0.1.0-beta.5

//! Attribute macro for registering cross-type trait implementations.
//!
//! The macro supports only `#[sassi::trait_impl] impl Trait for Type`
//! blocks. Expansion emits the original impl plus one
//! `inventory::submit!` block. The `inventory` crate handles the
//! platform-specific startup registration (`.init_array` /
//! `__DATA,__mod_init_func` / `.CRT$XCU` on native, the wasm32
//! initializer on `wasm32-unknown-unknown`), so adopter crates with
//! `#![forbid(unsafe_code)]` are not rejected — the `unsafe`
//! attribute syntax never appears in the macro's output. Verified
//! by `sassi-macros/tests/lihaaf/compile_pass/forbid_unsafe_code_adopter.rs`,
//! which compiles a fixture crate declaring `#![forbid(unsafe_code)]`
//! at the crate root and applying this macro. The fixture runs as
//! part of the `cargo lihaaf` compile-fixture suite configured in
//! `sassi-macros/Cargo.toml`'s `[package.metadata.lihaaf]` block.
//!
//! WASM target: `cargo build --target wasm32-unknown-unknown` is
//! clean. Full runtime-test coverage on wasm32 (asserting that
//! `Sassi::all_impl::<dyn Trait>()` actually returns registered
//! entries under the wasm-bindgen-test runner) is tracked by sassi
//! GitHub issue #3.

use proc_macro::TokenStream;
use proc_macro2::TokenStream as TokenStream2;
use quote::quote;
use syn::spanned::Spanned;

use crate::sassi_path;

/// Expand `#[sassi::trait_impl]` on a concrete trait impl.
///
/// The original impl is emitted unchanged. A `inventory::submit!`
/// block registers the `(model type, trait)` pair with sassi's
/// hidden registry so `Sassi::all_impl::<dyn Trait>()` can collect
/// matching entries later.
///
/// # Adopter constraints
///
/// - The impl block must be concrete — generic parameters, `where`
///   clauses, and negative impls are rejected at expansion time
///   with a span-pointing diagnostic.
/// - The trait must satisfy `Send + Sync + 'static`. Without those
///   bounds, the macro's emitted collector cannot box the typed
///   `Vec<Arc<dyn Trait>>` as `Box<dyn Any + Send + Sync>` and the
///   adopter sees a compile-time error at the macro invocation.
///   `'static` is implied by `dyn Trait: Any` whenever the trait
///   has no captured lifetimes; in practice almost every cross-type
///   trait satisfies this naturally.
pub fn trait_impl(args: TokenStream, input: TokenStream) -> TokenStream {
    trait_impl_impl(args.into(), input.into()).into()
}

fn trait_impl_impl(args: TokenStream2, input: TokenStream2) -> TokenStream2 {
    let item = match syn::parse2::<syn::ItemImpl>(input) {
        Ok(item) => item,
        Err(e) => return e.to_compile_error(),
    };

    if !args.is_empty() {
        return syn::Error::new(args.span(), "sassi::trait_impl takes no arguments")
            .to_compile_error();
    }

    if !item.generics.params.is_empty() || item.generics.where_clause.is_some() {
        return syn::Error::new(
            item.generics.span(),
            "#[sassi::trait_impl] currently supports concrete, non-generic impl blocks",
        )
        .to_compile_error();
    }

    let trait_path = match &item.trait_ {
        Some((None, path, _for_token)) => path.clone(),
        Some((Some(not_token), _path, _for_token)) => {
            return syn::Error::new(
                not_token.span(),
                "#[sassi::trait_impl] cannot register negative impl blocks",
            )
            .to_compile_error();
        }
        None => {
            return syn::Error::new(
                item.impl_token.span(),
                "sassi::trait_impl must be applied to `impl Trait for Type`",
            )
            .to_compile_error();
        }
    };

    let sassi_path = match sassi_path() {
        Ok(path) => path,
        Err(e) => return e.to_compile_error(),
    };

    let model_ty = &item.self_ty;
    let expanded = quote! {
        #item

        impl #sassi_path::__private::Sealed<dyn #trait_path> for #model_ty {}
        impl #sassi_path::TraitImpl<dyn #trait_path> for #model_ty {}

        const _: () = {
            fn __sassi_collect_trait_impl(
                sassi: &#sassi_path::Sassi,
            ) -> ::std::boxed::Box<dyn ::std::any::Any + ::std::marker::Send + ::std::marker::Sync> {
                let values: ::std::vec::Vec<::std::sync::Arc<dyn #trait_path>> =
                    match sassi.pool::<#model_ty>() {
                        Some(pool) => pool
                            .scope(::std::vec::Vec::new())
                            .collect()
                            .into_iter()
                            .map(|value| value as ::std::sync::Arc<dyn #trait_path>)
                            .collect(),
                        None => ::std::vec::Vec::new(),
                    };
                ::std::boxed::Box::new(values)
            }

            #sassi_path::__private::inventory::submit! {
                #sassi_path::__private::TraitImplEntry {
                    trait_type_id: ::std::any::TypeId::of::<dyn #trait_path>(),
                    model_type_id: ::std::any::TypeId::of::<#model_ty>(),
                    collect_fn: __sassi_collect_trait_impl,
                }
            }
        };
    };

    expanded
}

#[cfg(test)]
mod marker_emit_tests {
    use super::trait_impl_impl;
    use quote::quote;

    #[test]
    fn emits_marker_impl_for_dyn_trait() {
        let item = quote! {
            impl Searchable for Vehicle {
                fn cols(&self) -> &'static [&'static str] { &["title"] }
            }
        };
        let out = trait_impl_impl(quote! {}, item).to_string();
        assert!(out.contains("impl Searchable for Vehicle"));
        assert!(
            out.contains("TraitImpl") && out.contains("for Vehicle"),
            "expected a TraitImpl<dyn Searchable> impl for Vehicle; got: {out}"
        );
        assert!(
            out.contains("Sealed") && out.contains("for Vehicle"),
            "expected a Sealed<dyn Searchable> witness impl for Vehicle; got: {out}"
        );
        assert!(out.contains("TraitImplEntry"));
    }
}