Method extract_field

codegraph-kernel/src/java.rs:715–793

extractField — each declarator becomes a field/constant node.

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

    /// extractField — each declarator becomes a field/constant node.
    fn extract_field(&mut self, node: Node<'t>) {
        let docstring = preceding_docstring(node, self.src);
        let visibility = self.visibility_of(node);
        let is_static = Some(self.is_static(node));
        let field_kind: &'static str = if self.is_const(node) { "constant" } else { "field" };

        let declarators: Vec<Node> = (0..node.named_child_count())
            .filter_map(|i| node.named_child(i))
            .filter(|c| c.kind() == "variable_declarator")
            .collect();

        if !declarators.is_empty() {
            let type_node = (0..node.named_child_count())
                .filter_map(|i| node.named_child(i))
                .find(|c| {
                    !matches!(
                        c.kind(),
                        "modifiers" | "modifier" | "variable_declarator" | "variable_declaration"
                            | "marker_annotation" | "annotation"
                    )
                });
            let type_text = type_node.map(|t| self.text(t).to_string());

            for decl in declarators {
                let name_node = decl.child_by_field_name("name").or_else(|| {
                    (0..decl.named_child_count())
                        .filter_map(|i| decl.named_child(i))
                        .find(|c| c.kind() == "identifier")
                });
                let Some(name_node) = name_node else { continue };
                let name = self.text(name_node).to_string();
                let signature = match &type_text {
                    Some(t) => format!("{t} {name}"),
                    None => name.clone(),
                };
                let row = self.create_node(
                    field_kind,
                    &name,
                    decl,
                    Extra {
                        docstring: docstring.clone(),
                        signature: Some(signature),
                        visibility,
                        is_static,
                        ..Extra::default()
                    },
                );
                if let Some(row) = row {
                    self.extract_decorators_for(node, row);
                    self.extract_type_annotations(node, row);
                    // Walk the initializer ATTRIBUTED to the declared field
                    // (#693, the Go fix): the dispatcher only fn-ref-scans this
                    // subtree, so a lambda / method reference / anonymous class
                    // in `private final Runnable r = () -> target();` emitted no
                    // call edge at all.
                    if let Some(value) = decl.child_by_field_name("value") {
                        self.stack.push(Scope { row, kind: field_kind, name: name.clone() });
                        self.visit_function_body(value);