method-ray 0.1.2 → 0.1.4

data/rust/src/parser.rs

@@ -1,46 +1,81 @@
 use anyhow::{Context, Result};
+use bumpalo::Bump;
 use ruby_prism::{parse, ParseResult};
 use std::fs;
 use std::path::Path;
 
-/// Parse Ruby source code and return ruby-prism AST
+/// Parse session - manages source bytes for multiple files using arena allocation
 ///
-/// Note: Uses Box::leak internally to ensure 'static lifetime
-pub fn parse_ruby_file(file_path: &Path) -> Result<ParseResult<'static>> {
-    let source = fs::read_to_string(file_path)
-        .with_context(|| format!("Failed to read file: {}", file_path.display()))?;
-
-    parse_ruby_source(&source, file_path.to_string_lossy().to_string())
+/// Uses an arena allocator to efficiently manage source bytes during parsing.
+/// When the session is dropped, all memory is released at once.
+pub struct ParseSession {
+    arena: Bump,
 }
 
-/// Parse Ruby source code string
-pub fn parse_ruby_source(source: &str, file_name: String) -> Result<ParseResult<'static>> {
-    // ruby-prism accepts &[u8]
-    // Use Box::leak to ensure 'static lifetime (memory leak is acceptable for analysis tools)
-    let source_bytes: &'static [u8] = Box::leak(source.as_bytes().to_vec().into_boxed_slice());
-    let parse_result = parse(source_bytes);
-
-    // Check parse errors
-    let error_messages: Vec<String> = parse_result
-        .errors()
-        .map(|e| {
-            format!(
-                "Parse error at offset {}: {}",
-                e.location().start_offset(),
-                e.message()
-            )
-        })
-        .collect();
-
-    if !error_messages.is_empty() {
-        anyhow::bail!(
-            "Failed to parse Ruby source in {}:\n{}",
-            file_name,
-            error_messages.join("\n")
-        );
+impl ParseSession {
+    pub fn new() -> Self {
+        Self { arena: Bump::new() }
+    }
+
+    /// Create with pre-allocated capacity (recommended for batch file processing)
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self {
+            arena: Bump::with_capacity(capacity),
+        }
+    }
+
+    /// Allocate source in arena and parse
+    pub fn parse_source<'a>(&'a self, source: &str, file_name: &str) -> Result<ParseResult<'a>> {
+        // Copy bytes to arena
+        let source_bytes = self.arena.alloc_slice_copy(source.as_bytes());
+        let parse_result = parse(source_bytes);
+
+        // Check for parse errors
+        let error_messages: Vec<String> = parse_result
+            .errors()
+            .map(|e| {
+                format!(
+                    "Parse error at offset {}: {}",
+                    e.location().start_offset(),
+                    e.message()
+                )
+            })
+            .collect();
+
+        if !error_messages.is_empty() {
+            anyhow::bail!(
+                "Failed to parse Ruby source in {}:\n{}",
+                file_name,
+                error_messages.join("\n")
+            );
+        }
+
+        Ok(parse_result)
+    }
+
+    /// Read file and parse
+    pub fn parse_file<'a>(&'a self, file_path: &Path) -> Result<ParseResult<'a>> {
+        let source = fs::read_to_string(file_path)
+            .with_context(|| format!("Failed to read file: {}", file_path.display()))?;
+
+        self.parse_source(&source, &file_path.to_string_lossy())
     }
 
-    Ok(parse_result)
+    /// Get allocated memory size (for debugging)
+    pub fn allocated_bytes(&self) -> usize {
+        self.arena.allocated_bytes()
+    }
+
+    /// Reset arena (for memory control during batch file processing)
+    pub fn reset(&mut self) {
+        self.arena.reset();
+    }
+}
+
+impl Default for ParseSession {
+    fn default() -> Self {
+        Self::new()
+    }
 }
 
 #[cfg(test)]
@@ -51,21 +86,24 @@ mod tests {
     fn test_parse_simple_ruby() {
         let source = r#"x = 1
 puts x"#;
-        let result = parse_ruby_source(source, "test.rb".to_string());
+        let session = ParseSession::new();
+        let result = session.parse_source(source, "test.rb");
         assert!(result.is_ok());
     }
 
     #[test]
     fn test_parse_string_literal() {
         let source = r#""hello".upcase"#;
-        let result = parse_ruby_source(source, "test.rb".to_string());
+        let session = ParseSession::new();
+        let result = session.parse_source(source, "test.rb");
         assert!(result.is_ok());
     }
 
     #[test]
     fn test_parse_array_literal() {
         let source = r#"[1, 2, 3].map { |x| x * 2 }"#;
-        let result = parse_ruby_source(source, "test.rb".to_string());
+        let session = ParseSession::new();
+        let result = session.parse_source(source, "test.rb");
         assert!(result.is_ok());
     }
 
@@ -75,14 +113,16 @@ puts x"#;
   x = "hello"
   x.upcase
 end"#;
-        let result = parse_ruby_source(source, "test.rb".to_string());
+        let session = ParseSession::new();
+        let result = session.parse_source(source, "test.rb");
         assert!(result.is_ok());
     }
 
     #[test]
     fn test_parse_invalid_ruby() {
         let source = "def\nend end";
-        let result = parse_ruby_source(source, "test.rb".to_string());
+        let session = ParseSession::new();
+        let result = session.parse_source(source, "test.rb");
         assert!(result.is_err());
     }
 
@@ -90,7 +130,27 @@ end"#;
     fn test_parse_method_call() {
         let source = r#"user = User.new
 user.save"#;
-        let result = parse_ruby_source(source, "test.rb".to_string());
+        let session = ParseSession::new();
+        let result = session.parse_source(source, "test.rb");
         assert!(result.is_ok());
     }
+
+    #[test]
+    fn test_parse_session_memory_tracking() {
+        let session = ParseSession::new();
+        let source = "x = 1";
+        let _ = session.parse_source(source, "test.rb").unwrap();
+        assert!(session.allocated_bytes() > 0);
+    }
+
+    #[test]
+    fn test_parse_session_reset() {
+        let mut session = ParseSession::new();
+        let source = "x = 1";
+        let _ = session.parse_source(source, "test.rb").unwrap();
+        let before_reset = session.allocated_bytes();
+        session.reset();
+        // After reset, allocated_bytes may still report used chunks but internal data is cleared
+        assert!(before_reset > 0);
+    }
 }

data/rust/src/rbs/converter.rs

@@ -20,18 +20,12 @@ impl RbsTypeConverter {
 
         match type_name {
             "bool" => Type::Union(vec![
-                Type::Instance {
-                    class_name: "TrueClass".to_string(),
-                },
-                Type::Instance {
-                    class_name: "FalseClass".to_string(),
-                },
+                Type::instance("TrueClass"),
+                Type::instance("FalseClass"),
             ]),
             "void" | "nil" => Type::Nil,
             "untyped" | "top" => Type::Bot,
-            _ => Type::Instance {
-                class_name: type_name.to_string(),
-            },
+            _ => Type::instance(type_name),
         }
     }
 }
@@ -43,12 +37,23 @@ mod tests {
     #[test]
     fn test_parse_simple_types() {
         match RbsTypeConverter::parse("::String") {
-            Type::Instance { class_name } => assert_eq!(class_name, "String"),
+            Type::Instance { name } => assert_eq!(name.full_name(), "String"),
             _ => panic!("Expected Instance type"),
         }
 
         match RbsTypeConverter::parse("Integer") {
-            Type::Instance { class_name } => assert_eq!(class_name, "Integer"),
+            Type::Instance { name } => assert_eq!(name.full_name(), "Integer"),
+            _ => panic!("Expected Instance type"),
+        }
+    }
+
+    #[test]
+    fn test_parse_qualified_types() {
+        match RbsTypeConverter::parse("::Api::User") {
+            Type::Instance { name } => {
+                assert_eq!(name.full_name(), "Api::User");
+                assert_eq!(name.name(), "User");
+            }
             _ => panic!("Expected Instance type"),
         }
     }

data/rust/src/rbs/loader.rs

@@ -2,6 +2,7 @@ use crate::env::GlobalEnv;
 use crate::rbs::converter::RbsTypeConverter;
 use crate::rbs::error::RbsError;
 use crate::types::Type;
+use magnus::value::ReprValue;
 use magnus::{Error, RArray, RHash, Ruby, TryConvert, Value};
 
 /// Method information loaded from RBS
@@ -10,6 +11,7 @@ pub struct RbsMethodInfo {
     pub receiver_class: String,
     pub method_name: String,
     pub return_type: Type,
+    pub block_param_types: Option<Vec<String>>,
 }
 
 /// Loader that calls RBS API via magnus to load method information
@@ -100,10 +102,33 @@ impl<'a> RbsLoader<'a> {
             // Convert RBS type string to internal Type enum
             let return_type = RbsTypeConverter::parse(&return_type_str);
 
+            // Parse block_param_types (optional)
+            let block_param_types: Option<Vec<String>> =
+                if let Some(bpt_value) = hash.get(self.ruby.to_symbol("block_param_types")) {
+                    if bpt_value.is_nil() {
+                        None
+                    } else if let Ok(bpt_array) = RArray::try_convert(bpt_value) {
+                        let types: Vec<String> = bpt_array
+                            .into_iter()
+                            .filter_map(|v| String::try_convert(v).ok())
+                            .collect();
+                        if types.is_empty() {
+                            None
+                        } else {
+                            Some(types)
+                        }
+                    } else {
+                        None
+                    }
+                } else {
+                    None
+                };
+
             method_infos.push(RbsMethodInfo {
                 receiver_class,
                 method_name,
                 return_type,
+                block_param_types,
             });
         }
 
@@ -128,7 +153,6 @@ pub fn register_rbs_methods(genv: &mut GlobalEnv, ruby: &Ruby) -> Result<usize,
     // Try to load from cache
     let methods = if let Ok(cache) = RbsCache::load() {
         if cache.is_valid(methodray_version, &rbs_version) {
-            eprintln!("Loaded {} methods from cache", cache.methods.len());
             cache.to_method_infos()
         } else {
             eprintln!("Cache invalid, reloading from RBS...");
@@ -142,13 +166,19 @@ pub fn register_rbs_methods(genv: &mut GlobalEnv, ruby: &Ruby) -> Result<usize,
 
     let count = methods.len();
     for method_info in methods {
-        let receiver_type = Type::Instance {
-            class_name: method_info.receiver_class,
-        };
-        genv.register_builtin_method(
+        let receiver_type = Type::instance(&method_info.receiver_class);
+        // Convert block param type strings to Type enums
+        let block_param_types = method_info.block_param_types.map(|types| {
+            types
+                .iter()
+                .map(|s| RbsTypeConverter::parse(s))
+                .collect()
+        });
+        genv.register_builtin_method_with_block(
             receiver_type,
             &method_info.method_name,
             method_info.return_type,
+            block_param_types,
         );
     }
 

data/rust/src/rbs/mod.rs

@@ -1,14 +1,15 @@
 //! RBS type loading and conversion
 
-#[cfg(feature = "ruby-ffi")]
+// Converter is always available (no Ruby FFI dependency)
 pub mod converter;
+pub use converter::RbsTypeConverter;
+
+// These require Ruby FFI for RBS loading
 #[cfg(feature = "ruby-ffi")]
 pub mod error;
 #[cfg(feature = "ruby-ffi")]
 pub mod loader;
 
-#[cfg(feature = "ruby-ffi")]
-pub use converter::RbsTypeConverter;
 #[cfg(feature = "ruby-ffi")]
 pub use error::RbsError;
 #[cfg(feature = "ruby-ffi")]