Snapshot Testing for CGP Proc Macros (#236)

* Draft implement new assert_delegate_components macro

* Add pretty_format helper

* Use pretty_format in assert_delegate_components

* Try file-based snapshot

* Inline snapshot now works

* Put original code first before snapshot

* Migrate more tests to assert_delegate_components

* Rename to snapshot_delegate_components

* Allow arbitrary expression in body

* Add MacroSnapshot::wrap_output helper

* Add snapshot_cgp_component

* Add cgp-macro-test-util-lib crate

* Refactor snapshot_delegate_components macro

* Add back snapshot_cgp_component

* Snapshot cgp_component is now working

* Format output as string inside macro

* Implement `snapshot_cgp_impl!`

* Implement `snapshot_cgp_auto_getter!`

* Move pretty_format to test-util-lib

* AI-migrate tests

* Implement `snapshot_cgp_fn!`

* Use fully qualified `insta::assert_snapshot!`

* Add `snapshot_cgp_namespace!` macro

* Add `snapshot_cgp_type!` macro

* Add `snapshot_check_components!` and `snapshot_delegate_and_check_components!`

* Add StatementMacroSnapshot

* Add AttributeMacroSnapshot

* Remove SnapshotCgpComponent

* Migrate all other macros

* Add `snapshot_cgp_provider!` macro

* Fix formatting

Author: soareschen

Cargo.lock

@@ -26,6 +26,8 @@ members = [
     "crates/macros/cgp-macro",
     "crates/macros/cgp-macro-core",
     "crates/macros/cgp-macro-lib",
+    "crates/macros/cgp-macro-test-util",
+    "crates/macros/cgp-macro-test-util-lib",
     "crates/macros/cgp-extra-macro",
     "crates/macros/cgp-extra-macro-lib",
 
@@ -68,5 +70,7 @@ cgp-async-macro             = { version = "0.7.0", path = "./crates/macros/cgp-a
 cgp-macro                   = { version = "0.7.0", path = "./crates/macros/cgp-macro" }
 cgp-macro-core              = { version = "0.7.0", path = "./crates/macros/cgp-macro-core" }
 cgp-macro-lib               = { version = "0.7.0", path = "./crates/macros/cgp-macro-lib" }
+cgp-macro-test-util         = { version = "0.7.0", path = "./crates/macros/cgp-macro-test-util" }
+cgp-macro-test-util-lib     = { version = "0.7.0", path = "./crates/macros/cgp-macro-test-util-lib" }
 cgp-extra-macro             = { version = "0.7.0", path = "./crates/macros/cgp-extra-macro" }
 cgp-extra-macro-lib         = { version = "0.7.0", path = "./crates/macros/cgp-extra-macro-lib" }

Cargo.toml

@@ -7,15 +7,9 @@ repository   = { workspace = true }
 authors      = { workspace = true }
 rust-version = { workspace = true }
 keywords     = { workspace = true }
-description  = """
-    Context-generic programming core component macros implemented as a library.
-"""
-
-[features]
-default = []
 
 [dependencies]
-syn             = { version = "2.0.95", features = [ "full", "extra-traits", "visit", "visit-mut" ] }
-quote           = "1.0.38"
-proc-macro2     = "1.0.92"
-itertools       = "0.14.0"
+syn                 = { version = "2.0.95", features = [ "full", "extra-traits", "visit", "visit-mut" ] }
+quote               = { version = "1.0.38" }
+proc-macro2         = { version = "1.0.92" }
+itertools           = { version = "0.14.0" }

crates/macros/cgp-macro-core/Cargo.toml

@@ -7,6 +7,7 @@ mod implicits;
 mod is_provider_params;
 mod parse_internal;
 mod snake_case;
+mod strip;
 
 pub use camel_case::*;
 pub use delegated_impls::*;
@@ -17,3 +18,4 @@ pub use implicits::*;
 pub use is_provider_params::*;
 pub use parse_internal::*;
 pub use snake_case::*;
+pub use strip::*;

crates/macros/cgp-macro-core/src/functions/mod.rs

@@ -1,10 +1,11 @@
 use core::any::type_name;
 
-use proc_macro2::{Group, TokenStream, TokenTree};
+use proc_macro2::TokenStream;
 use syn::parse::Parse;
 use syn::spanned::Spanned;
 use syn::{Error, parse2};
 
+use crate::functions::strip_macro_prelude;
 pub use crate::macros::parse_internal;
 
 pub fn parse_internal<T>(body: TokenStream) -> Result<T, Error>
@@ -23,57 +24,3 @@ where
         e
     })
 }
-
-/// Strips the `::cgp::macro_prelude::` prefix from the [`TokenStream`] so the
-/// error message shows the more readable, unqualified paths. The replacement is
-/// done at the token level, recursing into nested groups.
-fn strip_macro_prelude(body: TokenStream) -> TokenStream {
-    // The prefix `::cgp::macro_prelude::` is made up of the following tokens.
-    fn is_prefix(tokens: &[TokenTree]) -> bool {
-        matches!(
-            tokens,
-            [
-                TokenTree::Punct(p1),
-                TokenTree::Punct(p2),
-                TokenTree::Ident(cgp),
-                TokenTree::Punct(p3),
-                TokenTree::Punct(p4),
-                TokenTree::Ident(prelude),
-                TokenTree::Punct(p5),
-                TokenTree::Punct(p6),
-            ] if p1.as_char() == ':'
-                && p2.as_char() == ':'
-                && cgp == "cgp"
-                && p3.as_char() == ':'
-                && p4.as_char() == ':'
-                && prelude == "macro_prelude"
-                && p5.as_char() == ':'
-                && p6.as_char() == ':'
-        )
-    }
-
-    const PREFIX_LEN: usize = 8;
-
-    let tokens: Vec<TokenTree> = body.into_iter().collect();
-    let mut output = Vec::with_capacity(tokens.len());
-    let mut i = 0;
-
-    while i < tokens.len() {
-        if is_prefix(&tokens[i..(i + PREFIX_LEN).min(tokens.len())]) {
-            i += PREFIX_LEN;
-        } else {
-            match &tokens[i] {
-                TokenTree::Group(group) => {
-                    let inner = strip_macro_prelude(group.stream());
-                    let mut new_group = Group::new(group.delimiter(), inner);
-                    new_group.set_span(group.span());
-                    output.push(TokenTree::Group(new_group));
-                }
-                other => output.push(other.clone()),
-            }
-            i += 1;
-        }
-    }
-
-    output.into_iter().collect()
-}