Method maybe_capture_fn_refs

codegraph-kernel/src/java.rs:1120–1193

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

    // --- function-as-value refs (JAVA_SPEC: method references only) ----------------

    fn maybe_capture_fn_refs(&mut self, node: Node<'t>) {
        let mode_field: Option<&str> = match node.kind() {
            "argument_list" => Some(""),          // args: every named child
            "assignment_expression" => Some("right"),
            "variable_declarator" => Some("value"),
            _ => None,
        };
        let Some(field) = mode_field else { return };
        if self.stack.is_empty() {
            return;
        }
        let from = self.top_row();

        let mut values: Vec<Node> = Vec::new();
        if field.is_empty() {
            for i in 0..node.named_child_count() {
                if let Some(c) = node.named_child(i) {
                    values.push(c);
                }
            }
        } else if field == "right" {
            if let Some(rhs) = node.child_by_field_name("right") {
                let lhs_text = node
                    .child_by_field_name("left")
                    .map(|l| self.text(l))
                    .unwrap_or("");
                let lhs_last = util::lhs_last_name()
                    .captures(lhs_text)
                    .and_then(|c| c.get(1))
                    .map(|m| m.as_str());
                if !(lhs_last.is_some() && lhs_last == Some(self.text(rhs).trim())) {
                    values.push(rhs);
                }
            }
        } else if let Some(v) = node.child_by_field_name("value") {
            // varinit — destructuring patterns don't exist in Java.
            values.push(v);
        }

        for v in values {
            if v.kind() != "method_reference" {
                continue; // idTypes is EMPTY for Java — only method references
            }
            let mut last_ident: Option<Node> = None;
            for i in 0..v.named_child_count() {
                if let Some(c) = v.named_child(i) {
                    if c.kind() == "identifier" {
                        last_ident = Some(c);
                    }
                }
            }
            let Some(last) = last_ident else { continue };
            let m = self.text(last);
            let text = self.text(v);
            let name = if text.starts_with("this::") || text.starts_with("super::") {
                format!("this.{m}")
            } else if let Some(c) = method_ref_type_re().captures(text) {
                if m == "new" {