From baf94a9dab175ec35c20224e6360daf62d8ec242 Mon Sep 17 00:00:00 2001
From: John <j@soft.fish>
Date: Mon, 15 Sep 2025 10:25:50 -0400
Subject: [PATCH] matchers: rename to "macro_matchers"

---
 src/ast/{matcher.rs => macro_matcher.rs} | 32 ++++++++++++++++--------
 1 file changed, 22 insertions(+), 10 deletions(-)
 rename src/ast/{matcher.rs => macro_matcher.rs} (91%)

diff --git a/src/ast/matcher.rs b/src/ast/macro_matcher.rs
similarity index 91%
rename from src/ast/matcher.rs
rename to src/ast/macro_matcher.rs
index 8483d5d..f289ea9 100644
--- a/src/ast/matcher.rs
+++ b/src/ast/macro_matcher.rs
@@ -15,6 +15,26 @@ impl<A: Annotation> Default for Subst<A> {
         Self { exp: Default::default(), pat: Default::default() }
     }
 }
+impl<A: Annotation> Subst<A> {
+    fn add_pat(&mut self, name: String, pat: &Pat) -> bool {
+        if self.exp.contains_key(&name) {
+            return false;
+        }
+        if let Some(entry) = self.pat.get(&name) {
+            return entry == pat;
+        }
+        self.pat.insert(name, pat.clone()).is_none()
+    }
+    fn add_expr(&mut self, name: String, exp: &Expr<A>) -> bool {
+        if self.pat.contains_key(&name) {
+            return false;
+        }
+        if let Some(entry) = self.exp.get(&name) {
+            return entry == exp;
+        }
+        self.exp.insert(name, exp.clone()).is_none()
+    }
+}
 
 pub trait Match<A: Annotation> {
     /// Applies a substitution rule from `pat` to `template` on `self`
@@ -62,11 +82,7 @@ impl<A: Annotation> Match<A> for Expr<A> {
     fn recurse(sub: &mut Subst<A>, pat: &Self, expr: &Self) -> bool {
         match (pat, expr) {
             (Expr::MetId(name), _) if name == "_" => true,
-            (Expr::MetId(name), _) => sub
-                .exp
-                .insert(name.clone(), expr.clone())
-                .filter(|v| v != expr)
-                .is_none(),
+            (Expr::MetId(name), _) => sub.add_expr(name.clone(), expr),
             (Expr::Id(pat), Expr::Id(expr)) => pat == expr,
             (Expr::Id(_), _) => false,
             (Expr::Lit(pat), Expr::Lit(expr)) => pat == expr,
@@ -162,11 +178,7 @@ impl<A: Annotation> Match<A> for Pat {
     fn recurse(sub: &mut Subst<A>, pat: &Self, expr: &Self) -> bool {
         match (pat, expr) {
             (Pat::MetId(name), _) if name == "_" => true,
-            (Pat::MetId(name), _) => sub
-                .pat
-                .insert(name.clone(), expr.clone())
-                .filter(|v| v != expr)
-                .is_none(),
+            (Pat::MetId(name), _) => sub.add_pat(name.clone(), expr),
             (Pat::Ignore, Pat::Ignore) => true,
             (Pat::Ignore, _) => false,
             (Pat::Name(pat), Pat::Name(expr)) => pat == expr,