fix(codegen): guard cyclic inheritance walks against non-termination

crates/perry-codegen/src/collectors/class_accessors.rs

@@ -14,7 +14,13 @@ pub fn is_class_getter(
     property: &str,
 ) -> bool {
     let mut cur = Some(class_name.to_string());
+    let mut seen = std::collections::HashSet::new();
+    let mut depth = 0usize;
     while let Some(name) = cur {
+        if !seen.insert(name.clone()) || depth > 64 {
+            break;
+        }
+        depth += 1;
         if let Some(class) = classes.get(&name) {
             if class.getters.iter().any(|(n, _)| n == property) {
                 return true;
@@ -36,7 +42,13 @@ pub fn is_class_setter(
     property: &str,
 ) -> bool {
     let mut cur = Some(class_name.to_string());
+    let mut seen = std::collections::HashSet::new();
+    let mut depth = 0usize;
     while let Some(name) = cur {
+        if !seen.insert(name.clone()) || depth > 64 {
+            break;
+        }
+        depth += 1;
         if let Some(class) = classes.get(&name) {
             if class.setters.iter().any(|(n, _)| n == property) {
                 return true;
@@ -48,3 +60,76 @@ pub fn is_class_setter(
     }
     false
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use perry_hir::{Class, Function};
+    use perry_types::Type;
+    use std::collections::HashMap;
+
+    fn function(name: &str) -> Function {
+        Function {
+            id: 0,
+            name: name.to_string(),
+            type_params: Vec::new(),
+            params: Vec::new(),
+            return_type: Type::Any,
+            body: Vec::new(),
+            is_async: false,
+            is_generator: false,
+            is_strict: false,
+            is_exported: false,
+            captures: Vec::new(),
+            decorators: Vec::new(),
+            was_plain_async: false,
+            was_unrolled: false,
+        }
+    }
+
+    fn class(name: &str, extends_name: Option<&str>) -> Class {
+        Class {
+            id: 0,
+            name: name.to_string(),
+            type_params: Vec::new(),
+            extends: None,
+            extends_name: extends_name.map(str::to_string),
+            native_extends: None,
+            extends_expr: None,
+            fields: Vec::new(),
+            constructor: None,
+            methods: Vec::new(),
+            getters: Vec::new(),
+            setters: Vec::new(),
+            static_fields: Vec::new(),
+            static_methods: Vec::new(),
+            computed_members: Vec::new(),
+            decorators: Vec::new(),
+            is_exported: false,
+            aliases: Vec::new(),
+            static_accessor_names: Vec::new(),
+            static_accessor_fn_ids: Vec::new(),
+        }
+    }
+
+    #[test]
+    fn accessor_lookup_stops_on_cyclic_parent_chain() {
+        let mut child = class("A", Some("B"));
+        let mut parent = class("B", Some("A"));
+        parent
+            .getters
+            .push(("value".to_string(), function("__get_value")));
+        child
+            .setters
+            .push(("own".to_string(), function("__set_own")));
+
+        let mut classes = HashMap::new();
+        classes.insert(child.name.clone(), &child);
+        classes.insert(parent.name.clone(), &parent);
+
+        assert!(is_class_getter(&classes, "A", "value"));
+        assert!(is_class_setter(&classes, "A", "own"));
+        assert!(!is_class_getter(&classes, "A", "missing"));
+        assert!(!is_class_setter(&classes, "A", "missing"));
+    }
+}

crates/perry-codegen/src/collectors/this_as_value.rs

@@ -34,7 +34,13 @@ pub fn class_uses_this_as_value(
     let mut field_names: HashSet<String> = HashSet::new();
     field_names.extend(class.fields.iter().map(|f| f.name.clone()));
     let mut parent = class.extends_name.as_deref();
+    let mut seen_parent_names: HashSet<&str> = HashSet::new();
+    let mut parent_depth = 0usize;
     while let Some(p) = parent {
+        if !seen_parent_names.insert(p) || parent_depth > 64 {
+            break;
+        }
+        parent_depth += 1;
         if let Some(pc) = classes.get(p) {
             field_names.extend(pc.fields.iter().map(|f| f.name.clone()));
             parent = pc.extends_name.as_deref();
@@ -57,7 +63,13 @@ pub fn class_uses_this_as_value(
     // Parent fields are initialized via apply_field_initializers_recursive
     // in scalar replacement; check their initializers too.
     let mut parent = class.extends_name.as_deref();
+    let mut seen_parent_names: HashSet<&str> = HashSet::new();
+    let mut parent_depth = 0usize;
     while let Some(p) = parent {
+        if !seen_parent_names.insert(p) || parent_depth > 64 {
+            break;
+        }
+        parent_depth += 1;
         if let Some(pc) = classes.get(p) {
             for f in &pc.fields {
                 if let Some(init) = &f.init {
@@ -86,8 +98,12 @@ pub fn class_chain_extends_builtin_error(
     classes: &std::collections::HashMap<String, &perry_hir::Class>,
 ) -> bool {
     let mut cur = class.extends_name.as_deref().map(|s| s.to_string());
+    let mut seen_parent_names: HashSet<String> = HashSet::new();
     let mut depth = 0usize;
     while let Some(name) = cur {
+        if !seen_parent_names.insert(name.clone()) {
+            break;
+        }
         if matches!(
             name.as_str(),
             "Error"
@@ -377,3 +393,100 @@ pub fn expr_uses_this_as_value(e: &perry_hir::Expr, fields: &HashSet<String>) ->
         _ => true,
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use perry_hir::{Class, ClassField, Expr, Function, Stmt};
+    use perry_types::Type;
+    use std::collections::HashMap;
+
+    fn function(name: &str, body: Vec<Stmt>) -> Function {
+        Function {
+            id: 0,
+            name: name.to_string(),
+            type_params: Vec::new(),
+            params: Vec::new(),
+            return_type: Type::Any,
+            body,
+            is_async: false,
+            is_generator: false,
+            is_strict: false,
+            is_exported: false,
+            captures: Vec::new(),
+            decorators: Vec::new(),
+            was_plain_async: false,
+            was_unrolled: false,
+        }
+    }
+
+    fn field(name: &str) -> ClassField {
+        ClassField {
+            name: name.to_string(),
+            key_expr: None,
+            ty: Type::Any,
+            init: None,
+            is_private: false,
+            is_readonly: false,
+            decorators: Vec::new(),
+        }
+    }
+
+    fn class(name: &str, extends_name: Option<&str>) -> Class {
+        Class {
+            id: 0,
+            name: name.to_string(),
+            type_params: Vec::new(),
+            extends: None,
+            extends_name: extends_name.map(str::to_string),
+            native_extends: None,
+            extends_expr: None,
+            fields: Vec::new(),
+            constructor: None,
+            methods: Vec::new(),
+            getters: Vec::new(),
+            setters: Vec::new(),
+            static_fields: Vec::new(),
+            static_methods: Vec::new(),
+            computed_members: Vec::new(),
+            decorators: Vec::new(),
+            is_exported: false,
+            aliases: Vec::new(),
+            static_accessor_names: Vec::new(),
+            static_accessor_fn_ids: Vec::new(),
+        }
+    }
+
+    #[test]
+    fn this_as_value_parent_walk_stops_on_cyclic_parent_chain() {
+        let mut child = class("A", Some("B"));
+        child.constructor = Some(function(
+            "constructor",
+            vec![Stmt::Return(Some(Expr::PropertyGet {
+                object: Box::new(Expr::This),
+                property: "value".to_string(),
+            }))],
+        ));
+
+        let mut parent = class("B", Some("A"));
+        parent.fields.push(field("value"));
+
+        let mut classes = HashMap::new();
+        classes.insert(child.name.clone(), &child);
+        classes.insert(parent.name.clone(), &parent);
+
+        assert!(!class_uses_this_as_value(&child, &classes));
+    }
+
+    #[test]
+    fn builtin_error_parent_walk_stops_on_cyclic_parent_chain() {
+        let child = class("A", Some("B"));
+        let parent = class("B", Some("A"));
+
+        let mut classes = HashMap::new();
+        classes.insert(child.name.clone(), &child);
+        classes.insert(parent.name.clone(), &parent);
+
+        assert!(!class_chain_extends_builtin_error(&child, &classes));
+    }
+}

crates/perry-codegen/src/lib.rs

@@ -25,6 +25,7 @@ pub(crate) mod stmt;
 pub mod strings;
 pub mod stubs;
 pub(crate) mod type_analysis;
+pub(crate) mod type_analysis_class_fields;
 pub(crate) mod type_analysis_net;
 pub(crate) mod typed_shape;
 pub mod types;