Generate location() accessor for each node type

Each node already has location data in its C struct, but it wasn't
exposed through the Rust API. This adds a generated `location()` method
to every node type, making it easy to get source ranges for any part
of the AST.

Also reorders RBSLocation and RBSLocationList struct fields to
consistently put parser first, matching the pattern used elsewhere.

Author: alexcrocha

rust/ruby-rbs/build.rs

@@ -350,6 +350,16 @@ fn generate(config: &Config) -> Result<(), Box<dyn Error>> {
         writeln!(file, "    pub fn as_node(self) -> Node {{")?;
         writeln!(file, "        Node::{}(self)", node.variant_name())?;
         writeln!(file, "    }}")?;
+        writeln!(file)?;
+        writeln!(file, "    /// Returns the location of this node.")?;
+        writeln!(file, "    #[must_use]")?;
+        writeln!(file, "    pub fn location(&self) -> RBSLocation {{")?;
+        writeln!(
+            file,
+            "        RBSLocation::new(self.parser, unsafe {{ (*self.pointer).base.location }})"
+        )?;
+        writeln!(file, "    }}")?;
+        writeln!(file)?;
 
         if let Some(fields) = &node.fields {
             for field in fields {

rust/ruby-rbs/src/lib.rs

@@ -133,14 +133,14 @@ impl Iterator for RBSHashIter {
 }
 
 pub struct RBSLocation {
-    pointer: *const rbs_location_t,
     #[allow(dead_code)]
     parser: *mut rbs_parser_t,
+    pointer: *const rbs_location_t,
 }
 
 impl RBSLocation {
-    pub fn new(pointer: *const rbs_location_t, parser: *mut rbs_parser_t) -> Self {
-        Self { pointer, parser }
+    pub fn new(parser: *mut rbs_parser_t, pointer: *const rbs_location_t) -> Self {
+        Self { parser, pointer }
     }
 
     pub fn start_loc(&self) -> i32 {
@@ -153,8 +153,8 @@ impl RBSLocation {
 }
 
 pub struct RBSLocationListIter {
-    current: *mut rbs_location_list_node_t,
     parser: *mut rbs_parser_t,
+    current: *mut rbs_location_list_node_t,
 }
 
 impl Iterator for RBSLocationListIter {
@@ -165,29 +165,29 @@ impl Iterator for RBSLocationListIter {
             None
         } else {
             let pointer_data = unsafe { *self.current };
-            let loc = RBSLocation::new(pointer_data.loc, self.parser);
+            let loc = RBSLocation::new(self.parser, pointer_data.loc);
             self.current = pointer_data.next;
             Some(loc)
         }
     }
 }
 
 pub struct RBSLocationList {
-    pointer: *mut rbs_location_list,
     parser: *mut rbs_parser_t,
+    pointer: *mut rbs_location_list,
 }
 
 impl RBSLocationList {
-    pub fn new(pointer: *mut rbs_location_list, parser: *mut rbs_parser_t) -> Self {
-        Self { pointer, parser }
+    pub fn new(parser: *mut rbs_parser_t, pointer: *mut rbs_location_list) -> Self {
+        Self { parser, pointer }
     }
 
     /// Returns an iterator over the locations.
     #[must_use]
     pub fn iter(&self) -> RBSLocationListIter {
         RBSLocationListIter {
-            current: unsafe { (*self.pointer).head },
             parser: self.parser,
+            current: unsafe { (*self.pointer).head },
         }
     }
 }
@@ -435,4 +435,32 @@ mod tests {
             visitor.visited
         );
     }
+
+    #[test]
+    fn test_node_location_ranges() {
+        let rbs_code = r#"type foo = 1"#;
+        let signature = parse(rbs_code.as_bytes()).unwrap();
+
+        let declaration = signature.declarations().iter().next().unwrap();
+        let Node::TypeAlias(type_alias) = declaration else {
+            panic!("Expected TypeAlias");
+        };
+
+        // TypeAlias spans the entire declaration
+        let loc = type_alias.location();
+        assert_eq!(0, loc.start_loc());
+        assert_eq!(12, loc.end_loc());
+
+        // The literal "1" is at position 11-12
+        let Node::LiteralType(literal) = type_alias.type_() else {
+            panic!("Expected LiteralType");
+        };
+        let Node::Integer(integer) = literal.literal() else {
+            panic!("Expected Integer");
+        };
+
+        let int_loc = integer.location();
+        assert_eq!(11, int_loc.start_loc());
+        assert_eq!(12, int_loc.end_loc());
+    }
 }