fix: Return explicit error when dependent rule is not found during deserialization

_typos.toml

@@ -29,24 +29,15 @@ extend-ignore-identifiers-re = [
   "RET",
   "prev",
   "normalises",
-  "goes",
-  "Bare",
   "inout",
-  "ba",
-  "ede",
+  "goes",
 ]
 
-[default.extend-words]
-Bare = "Bare"
-Supress = "Supress"
-teh = "teh"
-Teh = "Teh"
-
 [files]
 ignore-hidden = false
 ignore-files = true
 extend-exclude = [
-  "CHANGELOG.md",
+  "./CHANGELOG.md",
   "/usr/**/*",
   "/tmp/**/*",
   "/**/node_modules/**",

classifications/_universal_rules.json

@@ -1189,7 +1189,7 @@
     "inner": "syntax_punctuation",
     "inner_attribute_item": "syntax_annotation",
     "inner_doc_comment_marker": "syntax_literal",
-    "input": "syntax_keyword",
+    "inout": "syntax_keyword",
     "instance": "syntax_keyword",
     "instance_declarations": "definition_type",
     "instance_expression": "operation_operator",

crates/ast-engine/src/language.rs

@@ -67,11 +67,8 @@ pub trait Language: Clone + std::fmt::Debug + Send + Sync + 'static {
     fn extract_meta_var(&self, source: &str) -> Option<MetaVariable> {
         extract_meta_var(source, self.expando_char())
     }
-    /// Return the file language inferred from a filesystem path.
-    ///
-    /// The *default* implementation is not implemented and will panic if called.
-    /// Implementors should override this method and return `Some(Self)` when the
-    /// file type is supported and `None` when it is not.
+    /// Return the file language from path. Return None if the file type is not supported.
+    /// Will panic with an unimplimented error if called and not implemented
     fn from_path<P: AsRef<Path>>(_path: P) -> Option<Self> {
         unimplemented!(
             "Language::from_path is not implemented for type `{}`. \
@@ -94,26 +91,12 @@ mod test {
     use super::*;
     use crate::tree_sitter::{LanguageExt, StrDoc, TSLanguage};
 
-    // Shared helpers for test Language impls backed by tree-sitter-typescript.
-    fn tsx_kind_to_id(kind: &str) -> u16 {
-        let ts_lang: TSLanguage = tree_sitter_typescript::LANGUAGE_TSX.into();
-        ts_lang.id_for_node_kind(kind, /* named */ true)
-    }
-
-    fn tsx_field_to_id(field: &str) -> Option<u16> {
-        let ts_lang: TSLanguage = tree_sitter_typescript::LANGUAGE_TSX.into();
-        ts_lang.field_id_for_name(field).map(|f| f.get())
-    }
-
-    fn tsx_ts_language() -> TSLanguage {
-        tree_sitter_typescript::LANGUAGE_TSX.into()
-    }
-
     #[derive(Clone, Debug)]
     pub struct Tsx;
     impl Language for Tsx {
         fn kind_to_id(&self, kind: &str) -> u16 {
-            tsx_kind_to_id(kind)
+            let ts_lang: TSLanguage = tree_sitter_typescript::LANGUAGE_TSX.into();
+            ts_lang.id_for_node_kind(kind, /* named */ true)
         }
         fn field_to_id(&self, field: &str) -> Option<u16> {
             self.get_ts_language()
@@ -126,70 +109,7 @@ mod test {
     }
     impl LanguageExt for Tsx {
         fn get_ts_language(&self) -> TSLanguage {
-            tsx_ts_language()
-        }
-    }
-
-    /// A minimal `Language` impl that does *not* override `from_path`, used to
-    /// verify that the default implementation panics.
-    #[derive(Clone, Debug)]
-    struct NoFromPath;
-    impl Language for NoFromPath {
-        fn kind_to_id(&self, kind: &str) -> u16 {
-            tsx_kind_to_id(kind)
-        }
-        fn field_to_id(&self, field: &str) -> Option<u16> {
-            tsx_field_to_id(field)
-        }
-        #[cfg(feature = "matching")]
-        fn build_pattern(&self, builder: &PatternBuilder) -> Result<Pattern, PatternError> {
-            builder.build(|src| StrDoc::try_new(src, self.clone()))
-        }
-    }
-    impl LanguageExt for NoFromPath {
-        fn get_ts_language(&self) -> TSLanguage {
-            tsx_ts_language()
+            tree_sitter_typescript::LANGUAGE_TSX.into()
         }
     }
-
-    /// A `Language` impl that *does* override `from_path`, used to verify that
-    /// overriding the default works correctly.
-    #[derive(Clone, Debug)]
-    struct TsxWithFromPath;
-    impl Language for TsxWithFromPath {
-        fn kind_to_id(&self, kind: &str) -> u16 {
-            tsx_kind_to_id(kind)
-        }
-        fn field_to_id(&self, field: &str) -> Option<u16> {
-            tsx_field_to_id(field)
-        }
-        #[cfg(feature = "matching")]
-        fn build_pattern(&self, builder: &PatternBuilder) -> Result<Pattern, PatternError> {
-            builder.build(|src| StrDoc::try_new(src, self.clone()))
-        }
-        fn from_path<P: AsRef<Path>>(path: P) -> Option<Self> {
-            path.as_ref()
-                .extension()
-                .and_then(|e| e.to_str())
-                .filter(|&e| e == "tsx")
-                .map(|_| Self)
-        }
-    }
-    impl LanguageExt for TsxWithFromPath {
-        fn get_ts_language(&self) -> TSLanguage {
-            tsx_ts_language()
-        }
-    }
-
-    #[test]
-    #[should_panic(expected = "Language::from_path is not implemented for type")]
-    fn default_from_path_panics() {
-        let _ = NoFromPath::from_path("some/file.rs");
-    }
-
-    #[test]
-    fn overridden_from_path_does_not_panic() {
-        assert!(TsxWithFromPath::from_path("component.tsx").is_some());
-        assert!(TsxWithFromPath::from_path("main.rs").is_none());
-    }
 }

crates/ast-engine/src/replacer/indent.rs

@@ -306,7 +306,7 @@ fn remove_indent<C: Content>(indent: usize, src: &[C::Underlying]) -> Vec<C::Und
             stripped
         })
         .collect();
-    lines.join(&new_line).clone()
+    lines.join(&new_line)
 }
 
 #[cfg(test)]

crates/flow/src/incremental/analyzer.rs

@@ -471,21 +471,21 @@ impl IncrementalAnalyzer {
         }
 
         // Save edges to storage in batch
-        if !edges_to_save.is_empty()
-            && let Err(e) = self.storage.save_edges_batch(&edges_to_save).await
-        {
-            warn!(
-                error = %e,
-                "batch save failed, falling back to individual saves"
-            );
-            for edge in &edges_to_save {
-                if let Err(e) = self.storage.save_edge(edge).await {
-                    warn!(
-                        file_from = ?edge.from,
-                        file_to = ?edge.to,
-                        error = %e,
-                        "failed to save edge individually"
-                    );
+        if !edges_to_save.is_empty() {
+            if let Err(e) = self.storage.save_edges_batch(&edges_to_save).await {
+                warn!(
+                    error = %e,
+                    "batch save failed, falling back to individual saves"
+                );
+                for edge in &edges_to_save {
+                    if let Err(e) = self.storage.save_edge(edge).await {
+                        warn!(
+                            file_from = ?edge.from,
+                            file_to = ?edge.to,
+                            error = %e,
+                            "failed to save edge individually"
+                        );
+                    }
                 }
             }
         }

crates/language/src/lib.rs

@@ -1721,23 +1721,20 @@ pub fn from_extension(path: &Path) -> Option<SupportLang> {
     }
 
     // Handle extensionless files or files with unknown extensions
-    if let Some(_file_name) = path.file_name().and_then(|n| n.to_str()) {
+    if let Some(file_name) = path.file_name().and_then(|n| n.to_str()) {
         // 1. Check if the full filename matches a known extension (e.g. .bashrc)
         #[cfg(any(feature = "bash", feature = "all-parsers"))]
-        if constants::BASH_EXTS.contains(&_file_name) {
+        if constants::BASH_EXTS.contains(&file_name) {
             return Some(SupportLang::Bash);
         }
 
         // 2. Check known extensionless file names
         #[cfg(any(feature = "bash", feature = "all-parsers", feature = "ruby"))]
         for (name, lang) in constants::LANG_RELATIONSHIPS_WITH_NO_EXTENSION {
-            if *name == _file_name {
+            if *name == file_name {
                 return Some(*lang);
             }
         }
-
-        // Silence unused variable warning if bash and ruby and all-parsers are not enabled
-        let _ = file_name;
     }
 
     // 3. Try shebang check as last resort

crates/rule-engine/src/rule/deserialize_env.rs

@@ -38,7 +38,7 @@ fn into_map<L: Language>(
         .collect()
 }
 
-type OrderResult<T> = Result<T, String>;
+type OrderResult<T> = Result<T, ReferentRuleError>;
 
 /// A struct to store information to deserialize rules.
 #[derive(Clone, Debug)]
@@ -79,22 +79,27 @@ struct TopologicalSort<'a, T: DependentRule> {
     order: Vec<&'a str>,
     // bool stands for if the rule has completed visit
     seen: RapidMap<&'a str, bool>,
+    env: Option<&'a RuleRegistration>,
 }
 
 impl<'a, T: DependentRule> TopologicalSort<'a, T> {
-    fn get_order(maps: &RapidMap<String, T>) -> OrderResult<Vec<&str>> {
-        let mut top_sort = TopologicalSort::new(maps);
+    fn get_order(
+        maps: &'a RapidMap<String, T>,
+        env: Option<&'a RuleRegistration>,
+    ) -> OrderResult<Vec<&'a str>> {
+        let mut top_sort = TopologicalSort::new(maps, env);
         for key in maps.keys() {
             top_sort.visit(key)?;
         }
         Ok(top_sort.order)
     }
 
-    fn new(maps: &'a RapidMap<String, T>) -> Self {
+    fn new(maps: &'a RapidMap<String, T>, env: Option<&'a RuleRegistration>) -> Self {
         Self {
             maps,
             order: vec![],
             seen: RapidMap::default(),
+            env,
         }
     }
 
@@ -105,15 +110,20 @@ impl<'a, T: DependentRule> TopologicalSort<'a, T> {
             return if completed {
                 Ok(())
             } else {
-                Err(key.to_string())
+                Err(ReferentRuleError::CyclicRule(key.to_string()))
             };
         }
         let Some(item) = self.maps.get(key) else {
             // key can be found elsewhere
             // e.g. if key is rule_id
             // if rule_id not found in global, it can be a local rule
             // if rule_id not found in local, it can be a global rule
-            // TODO: add check here and return Err if rule not found
+            if let Some(env) = self.env {
+                // Note: We only check if the key is completely missing
+                if !env.contains_match_rule(key) {
+                    return Err(ReferentRuleError::UndefinedUtil(key.to_string()));
+                }
+            }
             return Ok(());
         };
         // mark the id as seen but not completed
@@ -165,8 +175,7 @@ impl<L: Language> DeserializeEnv<L> {
         self,
         utils: &RapidMap<String, SerializableRule>,
     ) -> Result<Self, RuleSerializeError> {
-        let order = TopologicalSort::get_order(utils)
-            .map_err(ReferentRuleError::CyclicRule)
+        let order = TopologicalSort::get_order(utils, Some(&self.registration))
             .map_err(RuleSerializeError::MatchesReference)?;
         for id in order {
             let rule = utils.get(id).expect("must exist");
@@ -182,8 +191,8 @@ impl<L: Language> DeserializeEnv<L> {
     ) -> Result<GlobalRules, RuleCoreError> {
         let registration = GlobalRules::default();
         let utils = into_map(utils);
-        let order = TopologicalSort::get_order(&utils)
-            .map_err(ReferentRuleError::CyclicRule)
+        let temp_env = RuleRegistration::from_globals(&registration);
+        let order = TopologicalSort::get_order(&utils, Some(&temp_env))
             .map_err(RuleSerializeError::from)?;
         for id in order {
             let (lang, core) = utils.get(id).expect("must exist");
@@ -204,10 +213,11 @@ impl<L: Language> DeserializeEnv<L> {
     }
 
     pub(crate) fn get_transform_order<'a>(
-        &self,
+        &'a self,
         trans: &'a RapidMap<String, Trans<MetaVariable>>,
-    ) -> Result<Vec<&'a str>, String> {
-        TopologicalSort::get_order(trans)
+    ) -> Result<Vec<&'a str>, ReferentRuleError> {
+        // Transformations don't need env rule registration checks, pass None
+        TopologicalSort::get_order(trans, None)
     }
 
     pub fn with_globals(self, globals: &GlobalRules) -> Self {
@@ -277,7 +287,16 @@ local-rule:
         )
         .expect("failed to parse utils");
         // should not panic
-        DeserializeEnv::new(TypeScript::Tsx).with_utils(&utils)?;
+        let registration = GlobalRules::default();
+        let core: crate::rule_core::SerializableRuleCore =
+            from_str("rule: {pattern: '123'}").unwrap();
+        let env_dummy = DeserializeEnv::new(TypeScript::Tsx).with_globals(&registration);
+        registration
+            .insert("global-rule", core.get_matcher(env_dummy).unwrap())
+            .unwrap();
+        DeserializeEnv::new(TypeScript::Tsx)
+            .with_globals(&registration)
+            .with_utils(&utils)?;
         Ok(())
     }
 

crates/rule-engine/src/rule/referent_rule.rs

@@ -32,6 +32,10 @@ impl<R> Registration<R> {
         // it only insert new item to the RapidMap. It is safe to cast the raw ptr.
         unsafe { &mut *(Arc::as_ptr(&self.0) as *mut RapidMap<String, R>) }
     }
+
+    pub(crate) fn contains_key(&self, id: &str) -> bool {
+        self.0.contains_key(id)
+    }
 }
 pub type GlobalRules = Registration<RuleCore>;
 
@@ -83,6 +87,10 @@ impl RuleRegistration {
         RegistrationRef { local, global }
     }
 
+    pub(crate) fn contains_match_rule(&self, id: &str) -> bool {
+        self.local.contains_key(id) || self.global.contains_key(id)
+    }
+
     pub(crate) fn insert_local(&self, id: &str, rule: Rule) -> Result<(), ReferentRuleError> {
         if rule.check_cyclic(id) {
             return Err(ReferentRuleError::CyclicRule(id.into()));

crates/rule-engine/src/transform/mod.rs

@@ -8,6 +8,7 @@ mod parse;
 mod rewrite;
 mod string_case;
 mod trans;
+use crate::rule::referent_rule::ReferentRuleError;
 
 use crate::{DeserializeEnv, RuleCore};
 
@@ -70,9 +71,12 @@ impl Transform {
             .map(|(key, val)| val.parse(&env.lang).map(|t| (key.to_string(), t)))
             .collect();
         let map = map?;
-        let order = env
-            .get_transform_order(&map)
-            .map_err(TransformError::Cyclic)?;
+        let order = env.get_transform_order(&map).map_err(|e| match e {
+            ReferentRuleError::CyclicRule(s) => TransformError::Cyclic(s),
+            _ => unreachable!(
+                "get_transform_order uses None for env, so only CyclicRule is possible"
+            ),
+        })?;
         let transforms = order
             .iter()
             .map(|&key| (key.to_string(), map[key].clone()))

crates/rule-engine/src/transform/trans.rs

@@ -551,6 +551,7 @@ if (true) {
         Ok(())
     }
 
+    // TODO: add a symbolic test for Rewrite
     #[test]
     fn test_rewrite() -> R {
         let trans = parse(