Method try_visit_hook

codegraph-kernel/src/kotlin.rs:586–646

(&mut self, node: Node<'t>)

    // defer-shielded and not ported) ------------------------------------------------

    fn try_visit_hook(&mut self, node: Node<'t>) -> bool {
        if node.kind() != "property_declaration" {
            return false;
        }
        let var_decl = (0..node.named_child_count())
            .filter_map(|i| node.named_child(i))
            .find(|c| c.kind() == "variable_declaration");
        let name_node = var_decl.and_then(|vd| {
            (0..vd.named_child_count())
                .filter_map(|i| vd.named_child(i))
                .find(|c| c.kind() == "simple_identifier")
        });
        let Some(name_node) = name_node else { return false }; // destructuring → decline
        let name = self.text(name_node).to_string();
        if name.is_empty() {
            return false;
        }

        // Scope walk up the parent chain — first match wins.
        let mut scope: &str = "const";
        let mut p = node.parent();
        while let Some(pn) = p {
            match pn.kind() {
                "function_body" | "function_declaration" | "lambda_literal"
                | "anonymous_initializer" | "control_structure_body" | "getter" | "setter" => {
                    scope = "local";
                    break;
                }
                "companion_object" | "object_declaration" => {
                    scope = "const";
                    break;
                }
                "class_declaration" => {
                    scope = "instance";
                    break;
                }
                _ => {}
            }
            p = pn.parent();
        }
        if scope == "local" {
            return true; // a local — extract nothing, subtree still scanned
        }

        let binding = (0..node.named_child_count())
            .filter_map(|i| node.named_child(i))
            .find(|c| c.kind() == "binding_pattern_kind");
        let is_val = binding.map(|b| self.text(b) == "val").unwrap_or(false);
        let kind: &'static str = if scope == "instance" {
            "field"
        } else if is_val {
            "constant"
        } else {
            "variable"
        };
        // The `type`-field signature read is dead (zero fields) → signature
        // undefined; NO docstring/visibility/isStatic — the modifiers merge in
        // create_node still decorates expect/actual properties.