matchers: rename to "macro_matchers"

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
+            (Expr::MetId(name), _) => sub.add_expr(name.clone(), expr),
-                .exp
-                .insert(name.clone(), expr.clone())
-                .filter(|v| v != expr)
-                .is_none(),
             (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::MetId(name), _) => sub.add_pat(name.clone(), expr),
-                .pat
-                .insert(name.clone(), expr.clone())
-                .filter(|v| v != expr)
-                .is_none(),
             (Pat::Ignore, Pat::Ignore) => true,
             (Pat::Ignore, _) => false,
             (Pat::Name(pat), Pat::Name(expr)) => pat == expr,