Handle rbs_node and rbs_node_list types

This adds support for `rbs_node` and `rbs_node_list` field types in the
bindings generator. This enables access to child nodes and node lists
from parent AST nodes.

We handle fields named `type` (which is a Rust keyword) by escaping the
accessor method to `r#type()` and correctly mapping to the underlying
`type_` field in the C struct.

Author: alexcrocha

rust/ruby-rbs/build.rs

@@ -147,6 +147,29 @@ fn generate(config: &Config) -> Result<(), Box<dyn Error>> {
                         )?;
                         writeln!(file, "    }}")?;
                     }
+                    "rbs_node" => {
+                        let (function_name, field_name) = match field.name.as_str() {
+                            "type" => ("r#type", "type_"),
+                            name => (name, name),
+                        };
+
+                        writeln!(file, "    pub fn {}(&self) -> Node {{", function_name)?;
+                        writeln!(
+                            file,
+                            "        unsafe {{ Node::new(self.parser, (*self.pointer).{}) }}",
+                            field_name
+                        )?;
+                        writeln!(file, "    }}")?;
+                    }
+                    "rbs_node_list" => {
+                        writeln!(file, "    pub fn {}(&self) -> NodeList {{", field.name)?;
+                        writeln!(
+                            file,
+                            "        NodeList::new(self.parser, unsafe {{ (*self.pointer).{} }})",
+                            field.name
+                        )?;
+                        writeln!(file, "    }}")?;
+                    }
                     _ => eprintln!("Unknown field type: {}", field.c_type),
                 }
             }

rust/ruby-rbs/src/lib.rs

@@ -66,6 +66,10 @@ pub struct NodeList {
 }
 
 impl NodeList {
+    pub fn new(parser: *mut rbs_parser_t, pointer: *mut rbs_node_list_t) -> Self {
+        Self { parser, pointer }
+    }
+
     /// Returns an iterator over the nodes.
     #[must_use]
     pub fn iter(&self) -> NodeListIter {