feat: separate RuleCoreError and RuleConfigError

BREAKING CHANGE: this requires ast-grep-config users to
use RuleCoreError instead of RuleConfigError

crates/config/src/check_var.rs

@@ -1,19 +1,19 @@
 use crate::fixer::Fixer;
 use crate::rule::Rule;
-use crate::rule_core::RuleConfigError;
+use crate::rule_core::RuleCoreError;
 use crate::transform::Transformation;
 use crate::{GlobalRules, RuleCore};
 
 use ast_grep_core::language::Language;
 
 use std::collections::{HashMap, HashSet};
 
-type RResult<T> = std::result::Result<T, RuleConfigError>;
+type RResult<T> = std::result::Result<T, RuleCoreError>;
 
 pub fn check_rewriters_in_transform<L: Language>(
   rule: &RuleCore<L>,
   rewriters: &GlobalRules<L>,
-) -> Result<(), RuleConfigError> {
+) -> Result<(), RuleCoreError> {
   let rewriters = rewriters.read();
   if let Some(err) = check_one_rewriter_in_rule(rule, &rewriters) {
     return Err(err);
@@ -30,13 +30,13 @@ pub fn check_rewriters_in_transform<L: Language>(
 fn check_one_rewriter_in_rule<L: Language>(
   rule: &RuleCore<L>,
   rewriters: &HashMap<String, RuleCore<L>>,
-) -> Option<RuleConfigError> {
+) -> Option<RuleCoreError> {
   let transform = rule.transform.as_ref()?;
   let mut used_rewriters = transform
     .values()
     .flat_map(|trans| trans.used_rewriters().iter());
   let undefined_writers = used_rewriters.find(|r| !rewriters.contains_key(*r))?;
-  Some(RuleConfigError::UndefinedRewriter(
+  Some(RuleCoreError::UndefinedRewriter(
     undefined_writers.to_string(),
   ))
 }
@@ -82,7 +82,7 @@ fn check_var_in_constraints<'r, L: Language>(
   for var in constraints.keys() {
     let var: &str = var;
     if !vars.contains(var) {
-      return Err(RuleConfigError::UndefinedMetaVar(
+      return Err(RuleCoreError::UndefinedMetaVar(
         var.to_owned(),
         "constraints",
       ));
@@ -104,7 +104,7 @@ fn check_var_in_transform<'r>(
   for trans in transform.values() {
     let needed = trans.used_vars();
     if !vars.contains(needed) {
-      return Err(RuleConfigError::UndefinedMetaVar(
+      return Err(RuleCoreError::UndefinedMetaVar(
         needed.to_string(),
         "transform",
       ));
@@ -119,7 +119,7 @@ fn check_var_in_fix<L: Language>(vars: HashSet<&str>, fixer: &Option<Fixer<L>>)
   };
   for var in fixer.used_vars() {
     if !vars.contains(&var) {
-      return Err(RuleConfigError::UndefinedMetaVar(var.to_string(), "fix"));
+      return Err(RuleCoreError::UndefinedMetaVar(var.to_string(), "fix"));
     }
   }
   Ok(())
@@ -157,7 +157,7 @@ transform:
     let env = DeserializeEnv::new(TypeScript::Tsx);
     let ser_rule: SerializableRuleCore = from_str(src).expect("should deser");
     match ser_rule.get_matcher(env) {
-      Err(RuleConfigError::UndefinedMetaVar(name, section)) => (name, section),
+      Err(RuleCoreError::UndefinedMetaVar(name, section)) => (name, section),
       _ => panic!("should error"),
     }
   }

crates/config/src/lib.rs

@@ -19,9 +19,8 @@ pub use rule::referent_rule::GlobalRules;
 pub use rule::DeserializeEnv;
 pub use rule::{Rule, RuleSerializeError, SerializableRule};
 pub use rule_collection::RuleCollection;
-pub use rule_config::{
-  RuleConfig, RuleConfigError, RuleCore, SerializableRuleConfig, SerializableRuleCore, Severity,
-};
+pub use rule_config::{RuleConfig, SerializableRuleConfig, Severity};
+pub use rule_core::{RuleCore, RuleCoreError, SerializableRuleCore};
 pub use transform::Transformation;
 
 pub fn from_str<'de, T: Deserialize<'de>>(s: &'de str) -> Result<T, YamlError> {
@@ -32,7 +31,7 @@ pub fn from_str<'de, T: Deserialize<'de>>(s: &'de str) -> Result<T, YamlError> {
 pub fn from_yaml_string<'a, L: Language + Deserialize<'a>>(
   yamls: &'a str,
   registration: &GlobalRules<L>,
-) -> Result<Vec<RuleConfig<L>>, RuleConfigError> {
+) -> Result<Vec<RuleConfig<L>>, RuleCoreError> {
   let mut ret = vec![];
   for yaml in Deserializer::from_str(yamls) {
     let config = RuleConfig::deserialize(yaml, registration)?;

crates/config/src/rule/deserialize_env.rs

@@ -1,8 +1,7 @@
 use super::referent_rule::{GlobalRules, ReferentRuleError, RuleRegistration};
 use crate::maybe::Maybe;
 use crate::rule::{self, Rule, RuleSerializeError, SerializableRule};
-use crate::rule_config::RuleConfigError;
-use crate::rule_core::SerializableRuleCore;
+use crate::rule_core::{RuleCoreError, SerializableRuleCore};
 
 use ast_grep_core::language::Language;
 
@@ -166,7 +165,7 @@ impl<L: Language> DeserializeEnv<L> {
   /// register global utils rule discovered in the config.
   pub fn parse_global_utils(
     utils: Vec<SerializableGlobalRule<L>>,
-  ) -> Result<GlobalRules<L>, RuleConfigError> {
+  ) -> Result<GlobalRules<L>, RuleCoreError> {
     let registration = GlobalRules::default();
     let utils = into_map(utils);
     let order = TopologicalSort::get_order(&utils).map_err(RuleSerializeError::from)?;

crates/config/src/rule_config.rs

@@ -3,7 +3,7 @@ use crate::GlobalRules;
 use crate::check_var::check_rewriters_in_transform;
 use crate::fixer::Fixer;
 use crate::rule::DeserializeEnv;
-pub use crate::rule_core::{RuleConfigError, RuleCore, SerializableRuleCore};
+use crate::rule_core::{RuleCore, RuleCoreError, SerializableRuleCore};
 use ast_grep_core::language::Language;
 use ast_grep_core::replacer::Replacer;
 use ast_grep_core::{NodeMatch, StrDoc};
@@ -73,7 +73,7 @@ impl<L: Language> SerializableRuleConfig<L> {
     String::from_utf8(bytes).expect("replacement must be valid utf-8")
   }
 
-  pub fn get_matcher(&self, globals: &GlobalRules<L>) -> Result<RuleCore<L>, RuleConfigError> {
+  pub fn get_matcher(&self, globals: &GlobalRules<L>) -> Result<RuleCore<L>, RuleCoreError> {
     // every RuleConfig has one rewriters, and the rewriter is shared between sub-rules
     // all RuleConfigs has one common globals
     // every sub-rule has one util
@@ -91,7 +91,7 @@ impl<L: Language> SerializableRuleConfig<L> {
     rule: &RuleCore<L>,
     globals: &GlobalRules<L>,
     rewriters: &GlobalRules<L>,
-  ) -> Result<(), RuleConfigError> {
+  ) -> Result<(), RuleCoreError> {
     let Some(ser) = &self.rewriters else {
       return Ok(());
     };
@@ -133,15 +133,15 @@ impl<L: Language> RuleConfig<L> {
   pub fn try_from(
     inner: SerializableRuleConfig<L>,
     globals: &GlobalRules<L>,
-  ) -> Result<Self, RuleConfigError> {
+  ) -> Result<Self, RuleCoreError> {
     let matcher = inner.get_matcher(globals)?;
     Ok(Self { inner, matcher })
   }
 
   pub fn deserialize<'de>(
     deserializer: Deserializer<'de>,
     globals: &GlobalRules<L>,
-  ) -> Result<Self, RuleConfigError>
+  ) -> Result<Self, RuleCoreError>
   where
     L: Deserialize<'de>,
   {
@@ -152,7 +152,7 @@ impl<L: Language> RuleConfig<L> {
   pub fn get_message(&self, node: &NodeMatch<StrDoc<L>>) -> String {
     self.inner.get_message(node)
   }
-  pub fn get_fixer(&self) -> Result<Option<Fixer<L>>, RuleConfigError> {
+  pub fn get_fixer(&self) -> Result<Option<Fixer<L>>, RuleCoreError> {
     if let Some(fix) = &self.fix {
       let env = self.matcher.get_env(self.language.clone());
       let parsed = Fixer::parse(fix, &env, &self.transform)?;
@@ -495,7 +495,7 @@ rewriters:
     let rule: SerializableRuleConfig<TypeScript> = from_str(src).expect("should parse");
     let err = RuleConfig::try_from(rule, &Default::default());
     match err {
-      Err(RuleConfigError::UndefinedRewriter(name)) => name,
+      Err(RuleCoreError::UndefinedRewriter(name)) => name,
       _ => panic!("unexpected parsing result"),
     }
   }

crates/config/src/rule_core.rs

@@ -21,7 +21,7 @@ use std::collections::{HashMap, HashSet};
 use std::ops::Deref;
 
 #[derive(Debug, Error)]
-pub enum RuleConfigError {
+pub enum RuleCoreError {
   #[error("Fail to parse yaml as RuleConfig")]
   Yaml(#[from] YamlError),
   #[error("Rule is not configured correctly.")]
@@ -38,7 +38,7 @@ pub enum RuleConfigError {
   UndefinedRewriter(String),
 }
 
-type RResult<T> = std::result::Result<T, RuleConfigError>;
+type RResult<T> = std::result::Result<T, RuleCoreError>;
 
 /// Used for global rules, rewriters, and pyo3/napi
 #[derive(Serialize, Deserialize, Clone, JsonSchema)]
@@ -67,7 +67,7 @@ impl SerializableRuleCore {
     if let Some(utils) = &self.utils {
       let env = env
         .register_local_utils(utils)
-        .map_err(RuleConfigError::Utils)?;
+        .map_err(RuleCoreError::Utils)?;
       Ok(env)
     } else {
       Ok(env)