feat: migrate constraints to Rule

it is not breaking change!

Author: HerringtonDarkholme

crates/config/src/rule_config.rs

@@ -2,10 +2,7 @@ use crate::GlobalRules;
 
 use crate::fixer::Fixer;
 use crate::rule::DeserializeEnv;
-pub use crate::rule_core::{
-  try_deserialize_matchers, RuleConfigError, RuleCore, SerializableMetaVarMatcher,
-  SerializableRuleCore, SerializeConstraintsError,
-};
+pub use crate::rule_core::{RuleConfigError, RuleCore, SerializableRuleCore};
 use ast_grep_core::language::Language;
 use ast_grep_core::replacer::{Content, Replacer};
 use ast_grep_core::{NodeMatch, StrDoc};

crates/config/src/rule_core.rs

@@ -6,10 +6,9 @@ use crate::transform::{apply_env_transform, Transformation};
 use crate::DeserializeEnv;
 
 use ast_grep_core::language::Language;
-use ast_grep_core::matcher::{KindMatcher, KindMatcherError, RegexMatcher, RegexMatcherError};
-use ast_grep_core::meta_var::{MetaVarEnv, MetaVarMatcher, MetaVarMatchers};
+use ast_grep_core::meta_var::{MetaVarEnv, MetaVarMatchers};
 use ast_grep_core::replacer::Content;
-use ast_grep_core::{Doc, Matcher, Node, Pattern, PatternError, StrDoc};
+use ast_grep_core::{Doc, Matcher, Node, StrDoc};
 use serde::{Deserialize, Serialize};
 use serde_yaml::Error as YamlError;
 
@@ -21,60 +20,18 @@ use std::borrow::Cow;
 use std::collections::HashMap;
 use std::ops::Deref;
 
-#[derive(Serialize, Deserialize, Clone, JsonSchema)]
-#[serde(rename_all = "camelCase")]
-pub enum SerializableMetaVarMatcher {
-  /// A regex to filter metavar based on its textual content.
-  Regex(String),
-  /// A pattern to filter matched metavar based on its AST tree shape.
-  Pattern(String),
-  /// A kind_id to filter matched metavar based on its ts-node kind
-  Kind(String),
-}
-
-#[derive(Debug, Error)]
-pub enum SerializeConstraintsError {
-  #[error("Invalid Regex.")]
-  RegexError(#[from] RegexMatcherError),
-  #[error("Invalid Kind.")]
-  InvalidKind(#[from] KindMatcherError),
-  #[error("Invalid Pattern.")]
-  PatternError(#[from] PatternError),
-}
-
-pub fn try_from_serializable<L: Language>(
-  meta_var: SerializableMetaVarMatcher,
-  lang: L,
-) -> Result<MetaVarMatcher<StrDoc<L>>, SerializeConstraintsError> {
-  use SerializableMetaVarMatcher as S;
-  Ok(match meta_var {
-    S::Regex(s) => MetaVarMatcher::Regex(RegexMatcher::try_new(&s)?),
-    S::Kind(p) => MetaVarMatcher::Kind(KindMatcher::try_new(&p, lang)?),
-    S::Pattern(p) => MetaVarMatcher::Pattern(Pattern::try_new(&p, lang)?),
-  })
-}
-
-pub fn try_deserialize_matchers<L: Language>(
-  meta_vars: HashMap<String, SerializableMetaVarMatcher>,
-  lang: L,
-) -> Result<MetaVarMatchers<StrDoc<L>>, SerializeConstraintsError> {
-  let mut map = MetaVarMatchers::new();
-  for (key, matcher) in meta_vars {
-    map.insert(key, try_from_serializable(matcher, lang.clone())?);
-  }
-  Ok(map)
-}
-
 #[derive(Debug, Error)]
 pub enum RuleConfigError {
   #[error("Fail to parse yaml as RuleConfig")]
   Yaml(#[from] YamlError),
   #[error("Rule is not configured correctly.")]
   Rule(#[from] RuleSerializeError),
+  #[error("Utility rule is not configured correctly.")]
+  Utils(#[source] RuleSerializeError),
   #[error("fix pattern is invalid.")]
   Fixer(#[from] FixerError),
   #[error("constraints is not configured correctly.")]
-  Constraints(#[from] SerializeConstraintsError),
+  Constraints(#[source] RuleSerializeError),
 }
 
 type RResult<T> = std::result::Result<T, RuleConfigError>;
@@ -85,7 +42,7 @@ pub struct SerializableRuleCore {
   /// A rule object to find matching AST nodes
   pub rule: SerializableRule,
   /// Additional meta variables pattern to filter matching
-  pub constraints: Option<HashMap<String, SerializableMetaVarMatcher>>,
+  pub constraints: Option<HashMap<String, SerializableRule>>,
   /// Utility rules that can be used in `matches`
   pub utils: Option<HashMap<String, SerializableRule>>,
   /// A dictionary for metavariable manipulation. Dict key is the new variable name.
@@ -101,7 +58,9 @@ pub struct SerializableRuleCore {
 impl SerializableRuleCore {
   fn get_deserialize_env<L: Language>(&self, env: DeserializeEnv<L>) -> RResult<DeserializeEnv<L>> {
     if let Some(utils) = &self.utils {
-      let env = env.register_local_utils(utils)?;
+      let env = env
+        .register_local_utils(utils)
+        .map_err(RuleConfigError::Rule)?;
       Ok(env)
     } else {
       Ok(env)
@@ -111,12 +70,15 @@ impl SerializableRuleCore {
   fn get_meta_var_matchers<L: Language>(
     &self,
     env: &DeserializeEnv<L>,
-  ) -> RResult<MetaVarMatchers<StrDoc<L>>> {
-    Ok(if let Some(constraints) = self.constraints.clone() {
-      try_deserialize_matchers(constraints, env.lang.clone())?
-    } else {
-      MetaVarMatchers::default()
-    })
+  ) -> RResult<HashMap<String, Rule<L>>> {
+    let mut matchers = HashMap::new();
+    let Some(constraints) = &self.constraints else {
+      return Ok(matchers);
+    };
+    for (key, ser) in constraints {
+      matchers.insert(key.to_string(), env.deserialize_rule(ser.clone())?);
+    }
+    Ok(matchers)
   }
 
   fn get_fixer<C: Content, L: Language>(
@@ -157,7 +119,7 @@ impl SerializableRuleCore {
 
 pub struct RuleCore<L: Language> {
   rule: Rule<L>,
-  matchers: MetaVarMatchers<StrDoc<L>>,
+  matchers: HashMap<String, Rule<L>>,
   kinds: Option<BitSet>,
   transform: Option<HashMap<String, Transformation>>,
   pub fixer: Option<Fixer<String, L>>,
@@ -177,7 +139,7 @@ impl<L: Language> RuleCore<L> {
   }
 
   #[inline]
-  pub fn with_matchers(self, matchers: MetaVarMatchers<StrDoc<L>>) -> Self {
+  pub fn with_matchers(self, matchers: HashMap<String, Rule<L>>) -> Self {
     Self { matchers, ..self }
   }
 
@@ -228,7 +190,7 @@ impl<L: Language> Default for RuleCore<L> {
   fn default() -> Self {
     Self {
       rule: Rule::default(),
-      matchers: MetaVarMatchers::default(),
+      matchers: HashMap::default(),
       kinds: None,
       transform: None,
       fixer: None,
@@ -249,8 +211,11 @@ impl<L: Language> Matcher<L> for RuleCore<L> {
       }
     }
     let ret = self.rule.match_node_with_env(node, env)?;
-    if !env.match_constraints(&self.matchers) {
-      return None;
+    for (key, matcher) in &self.matchers {
+      let Some(node) = env.get_match(key) else {
+        continue;
+      };
+      _ = matcher.match_node_with_env(node.clone(), env)?;
     }
     if let Some(trans) = &self.transform {
       let lang = ret.lang();
@@ -282,71 +247,71 @@ mod test {
 
   #[test]
   fn test_rule_with_constraints() {
-    let mut matchers = MetaVarMatchers::new();
-    matchers.insert(
-      "A".to_string(),
-      MetaVarMatcher::Regex(RegexMatcher::try_new("a").unwrap()),
-    );
-    let rule =
-      RuleCore::new(Rule::Pattern(Pattern::new("$A", TypeScript::Tsx))).with_matchers(matchers);
-    let grep = TypeScript::Tsx.ast_grep("a");
-    assert!(grep.root().find(&rule).is_some());
-    let grep = TypeScript::Tsx.ast_grep("bbb");
-    assert!(grep.root().find(&rule).is_none());
+    // let mut matchers = MetaVarMatchers::new();
+    // matchers.insert(
+    //   "A".to_string(),
+    //   MetaVarMatcher::Regex(RegexMatcher::try_new("a").unwrap()),
+    // );
+    // let rule =
+    //   RuleCore::new(Rule::Pattern(Pattern::new("$A", TypeScript::Tsx))).with_matchers(matchers);
+    // let grep = TypeScript::Tsx.ast_grep("a");
+    // assert!(grep.root().find(&rule).is_some());
+    // let grep = TypeScript::Tsx.ast_grep("bbb");
+    // assert!(grep.root().find(&rule).is_none());
   }
 
   #[test]
   fn test_serializable_regex() {
-    let yaml = from_str("regex: aa").expect("must parse");
-    let matcher = try_from_serializable(yaml, TypeScript::Tsx).expect("should parse");
-    let reg = cast!(matcher, MetaVarMatcher::Regex);
-    let matched = TypeScript::Tsx.ast_grep("var aa = 1");
-    assert!(matched.root().find(&reg).is_some());
-    let non_matched = TypeScript::Tsx.ast_grep("var b = 2");
-    assert!(non_matched.root().find(&reg).is_none());
+    // let yaml = from_str("regex: aa").expect("must parse");
+    // let matcher = try_from_serializable(yaml, TypeScript::Tsx).expect("should parse");
+    // let reg = cast!(matcher, MetaVarMatcher::Regex);
+    // let matched = TypeScript::Tsx.ast_grep("var aa = 1");
+    // assert!(matched.root().find(&reg).is_some());
+    // let non_matched = TypeScript::Tsx.ast_grep("var b = 2");
+    // assert!(non_matched.root().find(&reg).is_none());
   }
 
   #[test]
   fn test_non_serializable_regex() {
-    let yaml = from_str("regex: '*'").expect("must parse");
-    let matcher = try_from_serializable(yaml, TypeScript::Tsx);
-    assert!(matches!(
-      matcher,
-      Err(SerializeConstraintsError::RegexError(_))
-    ));
+    // let yaml = from_str("regex: '*'").expect("must parse");
+    // let matcher = try_from_serializable(yaml, TypeScript::Tsx);
+    // assert!(matches!(
+    //   matcher,
+    //   Err(SerializeConstraintsError::RegexError(_))
+    // ));
   }
 
   // TODO: test invalid pattern
   #[test]
   fn test_serializable_pattern() {
-    let yaml = from_str("pattern: var a = 1").expect("must parse");
-    let matcher = try_from_serializable(yaml, TypeScript::Tsx).expect("should parse");
-    let pattern = cast!(matcher, MetaVarMatcher::Pattern);
-    let matched = TypeScript::Tsx.ast_grep("var a = 1");
-    assert!(matched.root().find(&pattern).is_some());
-    let non_matched = TypeScript::Tsx.ast_grep("var b = 2");
-    assert!(non_matched.root().find(&pattern).is_none());
+    // let yaml = from_str("pattern: var a = 1").expect("must parse");
+    // let matcher = try_from_serializable(yaml, TypeScript::Tsx).expect("should parse");
+    // let pattern = cast!(matcher, MetaVarMatcher::Pattern);
+    // let matched = TypeScript::Tsx.ast_grep("var a = 1");
+    // assert!(matched.root().find(&pattern).is_some());
+    // let non_matched = TypeScript::Tsx.ast_grep("var b = 2");
+    // assert!(non_matched.root().find(&pattern).is_none());
   }
 
   #[test]
   fn test_serializable_kind() {
-    let yaml = from_str("kind: class_body").expect("must parse");
-    let matcher = try_from_serializable(yaml, TypeScript::Tsx).expect("should parse");
-    let pattern = cast!(matcher, MetaVarMatcher::Kind);
-    let matched = TypeScript::Tsx.ast_grep("class A {}");
-    assert!(matched.root().find(&pattern).is_some());
-    let non_matched = TypeScript::Tsx.ast_grep("function b() {}");
-    assert!(non_matched.root().find(&pattern).is_none());
+    // let yaml = from_str("kind: class_body").expect("must parse");
+    // let matcher = try_from_serializable(yaml, TypeScript::Tsx).expect("should parse");
+    // let pattern = cast!(matcher, MetaVarMatcher::Kind);
+    // let matched = TypeScript::Tsx.ast_grep("class A {}");
+    // assert!(matched.root().find(&pattern).is_some());
+    // let non_matched = TypeScript::Tsx.ast_grep("function b() {}");
+    // assert!(non_matched.root().find(&pattern).is_none());
   }
 
   #[test]
   fn test_non_serializable_kind() {
-    let yaml = from_str("kind: IMPOSSIBLE_KIND").expect("must parse");
-    let matcher = try_from_serializable(yaml, TypeScript::Tsx);
-    let error = match matcher {
-      Err(SerializeConstraintsError::InvalidKind(s)) => s,
-      _ => panic!("serialization should fail for invalid kind"),
-    };
-    assert_eq!(error.to_string(), "Kind `IMPOSSIBLE_KIND` is invalid.");
+    // let yaml = from_str("kind: IMPOSSIBLE_KIND").expect("must parse");
+    // let matcher = try_from_serializable(yaml, TypeScript::Tsx);
+    // let error = match matcher {
+    //   Err(SerializeConstraintsError::InvalidKind(s)) => s,
+    //   _ => panic!("serialization should fail for invalid kind"),
+    // };
+    // assert_eq!(error.to_string(), "Kind `IMPOSSIBLE_KIND` is invalid.");
   }
 }