feat: add start_line, end_line, start_column, end_column, and chop methods for Location

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: 2 people

rust/ruby-prism-sys/build/main.rs

@@ -118,6 +118,7 @@ fn generate_bindings(ruby_include_path: &Path) -> bindgen::Bindings {
         .allowlist_type("pm_diagnostic_t")
         .allowlist_type("pm_list_t")
         .allowlist_type("pm_magic_comment_t")
+        .allowlist_type("pm_line_offset_list_t")
         .allowlist_type("pm_node_t")
         .allowlist_type("pm_node_type")
         .allowlist_type("pm_parser_t")

rust/ruby-prism-sys/src/lib.rs

@@ -35,3 +35,25 @@ mod bindings {
 }
 
 pub use self::bindings::*;
+
+/// Line and column information for a given byte offset relative to the
+/// beginning of the source.
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct pm_line_column_t {
+    /// The 1-indexed line number relative to the start line configured on the
+    /// parser.
+    pub line: i32,
+    /// The 0-indexed column number in bytes.
+    pub column: u32,
+}
+
+extern "C" {
+    /// Return the line and column number for the given byte offset relative to
+    /// the beginning of the source.
+    pub fn pm_line_offset_list_line_column(
+        list: *const pm_line_offset_list_t,
+        cursor: u32,
+        start_line: i32,
+    ) -> pm_line_column_t;
+}

rust/ruby-prism/src/lib.rs

@@ -181,6 +181,48 @@ mod tests {
         assert_eq!(slice, "222");
     }
 
+    #[test]
+    #[allow(clippy::similar_names)]
+    fn location_line_column_test() {
+        let source = "foo\nbar\nbaz";
+        let result = parse(source.as_ref());
+
+        let node = result.node();
+        let program = node.as_program_node().unwrap();
+        let statements = program.statements().body();
+        let mut iter = statements.iter();
+        let _foo = iter.next().unwrap();
+        let bar = iter.next().unwrap();
+        let baz = iter.next().unwrap();
+
+        let bar_loc = bar.location();
+        assert_eq!(bar_loc.start_line(), 2);
+        assert_eq!(bar_loc.end_line(), 2);
+        assert_eq!(bar_loc.start_column(), 0);
+        assert_eq!(bar_loc.end_column(), 3);
+
+        let baz_loc = baz.location();
+        assert_eq!(baz_loc.start_line(), 3);
+        assert_eq!(baz_loc.end_line(), 3);
+        assert_eq!(baz_loc.start_column(), 0);
+        assert_eq!(baz_loc.end_column(), 3);
+    }
+
+    #[test]
+    fn test_chop() {
+        let result = parse(b"foo");
+        let mut location = result.node().as_program_node().unwrap().location();
+
+        assert_eq!(location.chop().as_slice(), b"fo");
+        assert_eq!(location.chop().chop().chop().as_slice(), b"");
+
+        // Check that we don't go negative.
+        for _ in 0..10 {
+            location = location.chop();
+        }
+        assert_eq!(location.as_slice(), b"");
+    }
+
     #[test]
     fn visitor_test() {
         use super::{visit_interpolated_regular_expression_node, visit_regular_expression_node, InterpolatedRegularExpressionNode, RegularExpressionNode, Visit};

rust/ruby-prism/src/parse_result/mod.rs

@@ -8,7 +8,7 @@ mod diagnostics;
 
 use std::ptr::NonNull;
 
-use ruby_prism_sys::{pm_comment_t, pm_diagnostic_t, pm_location_t, pm_magic_comment_t, pm_node_destroy, pm_node_t, pm_parser_free, pm_parser_t};
+use ruby_prism_sys::{pm_comment_t, pm_diagnostic_t, pm_line_column_t, pm_line_offset_list_line_column, pm_location_t, pm_magic_comment_t, pm_node_destroy, pm_node_t, pm_parser_free, pm_parser_t};
 
 pub use self::comments::{Comment, CommentType, Comments, MagicComment, MagicComments};
 pub use self::diagnostics::{Diagnostic, Diagnostics};
@@ -66,6 +66,55 @@ impl<'pr> Location<'pr> {
             })
         }
     }
+
+    /// Returns the line number where this location starts.
+    #[must_use]
+    pub fn start_line(&self) -> i32 {
+        self.line_column_at(self.start).line
+    }
+
+    /// Returns the line number where this location ends.
+    #[must_use]
+    pub fn end_line(&self) -> i32 {
+        self.line_column_at(self.end()).line
+    }
+
+    /// Returns the column number in bytes where this location starts from the
+    /// start of the line.
+    #[must_use]
+    pub fn start_column(&self) -> u32 {
+        self.line_column_at(self.start).column
+    }
+
+    /// Returns the column number in bytes where this location ends from the
+    /// start of the line.
+    #[must_use]
+    pub fn end_column(&self) -> u32 {
+        self.line_column_at(self.end()).column
+    }
+
+    /// Returns a new location that is the result of chopping off the last byte.
+    #[must_use]
+    pub const fn chop(&self) -> Self {
+        Location {
+            parser: self.parser,
+            start: self.start,
+            length: if self.length == 0 { 0 } else { self.length - 1 },
+            marker: std::marker::PhantomData,
+        }
+    }
+
+    fn line_column_at(&self, offset: u32) -> pm_line_column_t {
+        // SAFETY: `self.parser` is a valid pointer to a `pm_parser_t` that
+        // outlives `self`, and `pm_line_offset_list_line_column` only reads
+        // from the line offset list.
+        unsafe {
+            let parser = self.parser.as_ptr();
+            let line_offsets = &(*parser).line_offsets;
+            let start_line = (*parser).start_line;
+            pm_line_offset_list_line_column(line_offsets, offset, start_line)
+        }
+    }
 }
 
 impl std::fmt::Debug for Location<'_> {