macros-code-review — independently scanned and version-tracked by SaferSkills.
SaferSkills independently audited macros-code-review (Agent Skill) and scored it 100/100 (green). The audit ran 55 deterministic rules across Security, Supply Chain, Maintenance, Transparency, and Community; it found 0 high-severity and 0 lower-severity findings. The full rule-by-rule trace and per-finding evidence are below. Free, methodology-open.
Findings & checks · 0 flagged
Every scanned point with the score it earned and what moved between them.
First recorded scan — no prior version to compare against.
The primary manifest — the file an agent reads to learn what this artifact does.
gen keyword, affecting macro output), proc-macro crate dependencies (syn, quote, proc-macro2), and feature flags (e.g., syn with minimal features)macro_rules!), function-like proc macro, attribute macro, or derive macroComplete in order. Do not emit findings until Gate 4 passes for each issue.
Gate 1 — Crate context (on disk) PASS when: You opened the reviewed crate’s Cargo.toml (workspace member path if applicable) and recorded Rust edition, whether the crate is proc-macro = true, and relevant proc-macro dependencies or syn / quote feature flags. Blocks rationalization: Edition 2024 findings (gen, unsafe extern, generated unsafe bodies) and syn “full” vs minimal flags require this — do not flag edition-specific macro output without matching edition from the file.
Gate 2 — Macro definitions read PASS when: For every macro you critique, you read the full definition (all macro_rules! arms, or the proc-macro entry plus helpers you rely on), not only call sites or partial expansions. Artifact: At least one path per macro to the defining .rs file(s) you used.
Gate 3 — Per-finding evidence PASS when: Each planned issue has [FILE:LINE] from the current tree for the macro definition, attribute/derive site, or generated code location you are discussing (not from memory, docs-only, or another branch).
Gate 4 — Pre-report protocol PASS when: You loaded and applied the review-verification-protocol skill, including Macro-Specific Verification for hygiene, fragment type, and proc-macro performance claims. Then add findings.
Report findings as:
[FILE:LINE] ISSUE_TITLE
Severity: Critical | Major | Minor | Informational
Description of the issue and why it matters.| Issue Type | Reference |
|---|---|
Fragment types, repetition, hygiene boundaries (vars vs types), $crate paths, TT-muncher pattern + recursion limits, fragment-matcher follow restrictions, decl-vs-proc decision tree | references/declarative-macros.md |
Proc macro types, syn/quote, span hygiene (call_site vs def_site vs mixed_site), syn::Error::new_spanned + combine, parse_quote! vs quote!, syn feature audit, trybuild UI tests | references/procedural-macros.md |
macro_rules!):expr vs :tt vs :ident -- wrong choice causes unexpected parsing), vs ; vs none, * vs +)$(,)? or $(;)? at end of repetition)#[macro_export]) use $crate:: for crate-internal paths, never crate:: or self::::core:: and ::alloc:: (not ::std::) for no_std compatibilitycompile_error! used for meaningful error messages on invalid input patterns#[macro_export]syn features minimized (don't enable full when derive suffices -- reduces compile time)Span::mixed_site() is the default for introduced helper variables — call_site only when intentionally pointing at user code; def_site is nightly-only on proc_macro::Spansyn::Error::new_spanned(node, msg) with the offending AST node, never panic!syn::Error::combine (good UX vs first-failure)parse_quote! (not quote!) used when the result needs to be a syn::T for further AST manipulation; syn::parse2(quote!{...}) for fallible casesproc_macro2, not proc_macro (compatibility with downstream consumers)proc-macro2 used for testing (testable outside of compiler context)#[serde(skip)] style) are documentedimpl blocks use fully qualified paths (::core::, $crate::)#[test_case] style) produce unique test namesgen as an identifier (reserved keyword -- use r#gen or rename)unsafe fn bodies use explicit unsafe {} blocks around unsafe opsextern blocks use unsafe externFlag a macro when the same result is achievable with generics or trait bounds. Macros are appropriate when:
const fn cannot expressunsafe codeunsafe blocks (caller's variables leak into unsafe context)compile_error! (crashes the compiler)crate:: or self:: instead of $crate:: (breaks for downstream users)::std:: instead of ::core::/::alloc:: (breaks no_std users):expr where :tt needed, or vice versa)syn full features unnecessarily (compile time cost)compile_error!)compile_error! fallback arm for invalid patternsmacro_rules! into a proc macro~30 seconds. Free. No account. Every finding cites a rule and a line of evidence.