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

.github/workflows/rust-bindings.yml

@@ -40,8 +40,8 @@ jobs:
           path: |
             ~/.cargo/registry
             ~/.cargo/git
-            target
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.toml') }}
+            rust/target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.toml', 'rust/Cargo.lock', 'rust/ruby-prism-sys/build/**/*.rs', 'include/**/*.h', 'src/**/*.c') }}
       - name: Run tests
         run: bundle exec rake cargo:test
 
@@ -69,8 +69,8 @@ jobs:
           path: |
             ~/.cargo/registry
             ~/.cargo/git
-            target
-          key: ${{ runner.os }}-cargo--${{ hashFiles('**/Cargo.toml') }}
+            rust/target
+          key: ${{ runner.os }}-cargo--${{ hashFiles('**/Cargo.toml', 'rust/Cargo.lock', 'rust/ruby-prism-sys/build/**/*.rs', 'include/**/*.h', 'src/**/*.c') }}
       - name: rake cargo:build
         run: bundle exec rake cargo:build
       - name: rake cargo:lint

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

@@ -9,6 +9,7 @@ fn main() {
 
     let ruby_build_path = prism_lib_path();
     let ruby_include_path = prism_include_path();
+    emit_rerun_hints(&ruby_include_path);
 
     // Tell cargo/rustc that we want to link against `libprism.a`.
     println!("cargo:rustc-link-lib=static=prism");
@@ -23,6 +24,19 @@ fn main() {
     write_bindings(&bindings);
 }
 
+fn emit_rerun_hints(ruby_include_path: &Path) {
+    println!("cargo:rerun-if-env-changed=PRISM_INCLUDE_DIR");
+    println!("cargo:rerun-if-env-changed=PRISM_LIB_DIR");
+    println!("cargo:rerun-if-changed={}", ruby_include_path.display());
+
+    if let Some(project_root) = ruby_include_path.parent() {
+        let src_path = project_root.join("src");
+        if src_path.exists() {
+            println!("cargo:rerun-if-changed={}", src_path.display());
+        }
+    }
+}
+
 /// Gets the path to project files (`libprism*`) at `[root]/build/`.
 ///
 fn prism_lib_path() -> PathBuf {
@@ -118,6 +132,8 @@ 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_column_t")
+        .allowlist_type("pm_line_offset_list_t")
         .allowlist_type("pm_node_t")
         .allowlist_type("pm_node_type")
         .allowlist_type("pm_parser_t")
@@ -140,6 +156,7 @@ fn generate_bindings(ruby_include_path: &Path) -> bindgen::Bindings {
         .allowlist_function("pm_string_length")
         .allowlist_function("pm_string_source")
         .allowlist_function("pm_version")
+        .allowlist_function("pm_line_offset_list_line_column")
         // Vars
         .allowlist_var(r"^pm_encoding\S+")
         .generate()

rust/ruby-prism-sys/tests/utils_tests.rs

@@ -30,6 +30,24 @@ fn list_test() {
     }
 }
 
+#[test]
+fn line_column_test() {
+    use ruby_prism_sys::{pm_line_offset_list_line_column, pm_line_offset_list_t};
+
+    let mut offsets: Vec<u32> = vec![0, 10, 20, 30, 40];
+    let line_offsets = pm_line_offset_list_t {
+        size: 5,
+        capacity: 8,
+        offsets: offsets.as_mut_ptr(),
+    };
+
+    unsafe {
+        let result = pm_line_offset_list_line_column(&raw const line_offsets, 32, 1);
+        assert_eq!(result.line, 4);
+        assert_eq!(result.column, 2);
+    }
+}
+
 mod string {
     use ruby_prism_sys::{
         pm_string_free, pm_string_length, pm_string_source, pm_string_t, pm_string_t__bindgen_ty_1, PM_STRING_CONSTANT,

rust/ruby-prism/src/lib.rs

@@ -127,7 +127,7 @@ mod tests {
     }
 
     #[test]
-    fn location_test() {
+    fn location_slice_test() {
         let source = "111 + 222 + 333";
         let result = parse(source.as_ref());
 
@@ -181,6 +181,48 @@ mod tests {
         assert_eq!(slice, "222");
     }
 
+    #[test]
+    fn location_line_column_test() {
+        let source = "first\nsecond\nthird";
+        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 _first = iter.next().unwrap();
+        let second = iter.next().unwrap();
+        let third = iter.next().unwrap();
+
+        let second_loc = second.location();
+        assert_eq!(second_loc.start_line(), 2);
+        assert_eq!(second_loc.end_line(), 2);
+        assert_eq!(second_loc.start_column(), 0);
+        assert_eq!(second_loc.end_column(), 6);
+
+        let third_loc = third.location();
+        assert_eq!(third_loc.start_line(), 3);
+        assert_eq!(third_loc.end_line(), 3);
+        assert_eq!(third_loc.start_column(), 0);
+        assert_eq!(third_loc.end_column(), 5);
+    }
+
+    #[test]
+    fn location_chop_test() {
+        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,52 @@ impl<'pr> Location<'pr> {
             })
         }
     }
+
+    /// Returns the line number where this location starts.
+    #[must_use]
+    pub fn start_line(&self) -> i32 {
+        self.line_column(self.start).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(self.start).column
+    }
+
+    /// Returns the line number where this location ends.
+    #[must_use]
+    pub fn end_line(&self) -> i32 {
+        self.line_column(self.end()).line
+    }
+
+    /// 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(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(&self, offset: u32) -> pm_line_column_t {
+        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<'_> {