method-ray 0.1.1

data/rust/src/parser.rs

@@ -0,0 +1,96 @@
+use anyhow::{Context, Result};
+use ruby_prism::{parse, ParseResult};
+use std::fs;
+use std::path::Path;
+
+/// Parse Ruby source code and return ruby-prism AST
+///
+/// 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())
+}
+
+/// 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")
+        );
+    }
+
+    Ok(parse_result)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_simple_ruby() {
+        let source = r#"x = 1
+puts x"#;
+        let result = parse_ruby_source(source, "test.rb".to_string());
+        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());
+        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());
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_parse_method_definition() {
+        let source = r#"def test_method
+  x = "hello"
+  x.upcase
+end"#;
+        let result = parse_ruby_source(source, "test.rb".to_string());
+        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());
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_parse_method_call() {
+        let source = r#"user = User.new
+user.save"#;
+        let result = parse_ruby_source(source, "test.rb".to_string());
+        assert!(result.is_ok());
+    }
+}

data/rust/src/rbs/converter.rs

@@ -0,0 +1,82 @@
+use crate::types::Type;
+
+// RBS Type Converter
+pub struct RbsTypeConverter;
+
+impl RbsTypeConverter {
+    pub fn parse(rbs_type: &str) -> Type {
+        // Handle union types
+        if rbs_type.contains(" | ") {
+            let parts: Vec<&str> = rbs_type.split(" | ").collect();
+            let types: Vec<Type> = parts.iter().map(|s| Self::parse_single(s.trim())).collect();
+            return Type::Union(types);
+        }
+
+        Self::parse_single(rbs_type)
+    }
+
+    fn parse_single(rbs_type: &str) -> Type {
+        let type_name = rbs_type.trim_start_matches("::");
+
+        match type_name {
+            "bool" => Type::Union(vec![
+                Type::Instance {
+                    class_name: "TrueClass".to_string(),
+                },
+                Type::Instance {
+                    class_name: "FalseClass".to_string(),
+                },
+            ]),
+            "void" | "nil" => Type::Nil,
+            "untyped" | "top" => Type::Bot,
+            _ => Type::Instance {
+                class_name: type_name.to_string(),
+            },
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_simple_types() {
+        match RbsTypeConverter::parse("::String") {
+            Type::Instance { class_name } => assert_eq!(class_name, "String"),
+            _ => panic!("Expected Instance type"),
+        }
+
+        match RbsTypeConverter::parse("Integer") {
+            Type::Instance { class_name } => assert_eq!(class_name, "Integer"),
+            _ => panic!("Expected Instance type"),
+        }
+    }
+
+    #[test]
+    fn test_parse_special_types() {
+        assert!(matches!(RbsTypeConverter::parse("nil"), Type::Nil));
+        assert!(matches!(RbsTypeConverter::parse("void"), Type::Nil));
+        assert!(matches!(RbsTypeConverter::parse("untyped"), Type::Bot));
+    }
+
+    #[test]
+    fn test_parse_bool() {
+        match RbsTypeConverter::parse("bool") {
+            Type::Union(types) => {
+                assert_eq!(types.len(), 2);
+            }
+            _ => panic!("Expected Union type for bool"),
+        }
+    }
+
+    #[test]
+    fn test_parse_union_types() {
+        match RbsTypeConverter::parse("String | Integer") {
+            Type::Union(types) => {
+                assert_eq!(types.len(), 2);
+            }
+            _ => panic!("Expected Union type"),
+        }
+    }
+}

data/rust/src/rbs/error.rs

@@ -0,0 +1,37 @@
+use std::fmt;
+
+#[derive(Debug)]
+pub enum RbsError {
+    RbsNotInstalled,
+    LoadError(String),
+    ParseError(String),
+    MagnusError(magnus::Error),
+}
+
+impl fmt::Display for RbsError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            RbsError::RbsNotInstalled => {
+                write!(f, "RBS gem not found. Please install: gem install rbs")
+            }
+            RbsError::LoadError(msg) => write!(f, "Failed to load RBS environment: {}", msg),
+            RbsError::ParseError(msg) => write!(f, "Failed to parse RBS type: {}", msg),
+            RbsError::MagnusError(e) => write!(f, "Magnus error: {}", e),
+        }
+    }
+}
+
+impl std::error::Error for RbsError {}
+
+impl From<magnus::Error> for RbsError {
+    fn from(err: magnus::Error) -> Self {
+        RbsError::MagnusError(err)
+    }
+}
+
+impl From<RbsError> for magnus::Error {
+    fn from(err: RbsError) -> Self {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        magnus::Error::new(ruby.exception_runtime_error(), err.to_string())
+    }
+}

data/rust/src/rbs/loader.rs

@@ -0,0 +1,183 @@
+use crate::env::GlobalEnv;
+use crate::rbs::converter::RbsTypeConverter;
+use crate::rbs::error::RbsError;
+use crate::types::Type;
+use magnus::{Error, RArray, RHash, Ruby, TryConvert, Value};
+
+/// Method information loaded from RBS
+#[derive(Debug, Clone)]
+pub struct RbsMethodInfo {
+    pub receiver_class: String,
+    pub method_name: String,
+    pub return_type: Type,
+}
+
+/// Loader that calls RBS API via magnus to load method information
+pub struct RbsLoader<'a> {
+    ruby: &'a Ruby,
+}
+
+impl<'a> RbsLoader<'a> {
+    /// Create a new RbsLoader
+    /// Assumes RBS gem is already loaded on the Ruby side
+    pub fn new(ruby: &'a Ruby) -> Result<Self, RbsError> {
+        // Check if RBS module is defined
+        let rbs_defined: bool = ruby
+            .eval("defined?(RBS) == 'constant'")
+            .map_err(|e| RbsError::LoadError(format!("Failed to check RBS: {}", e)))?;
+
+        if !rbs_defined {
+            return Err(RbsError::RbsNotInstalled);
+        }
+
+        Ok(Self { ruby })
+    }
+
+    /// Load all method definitions from RBS
+    pub fn load_methods(&self) -> Result<Vec<RbsMethodInfo>, RbsError> {
+        // Load method_loader.rb
+        let rb_path = concat!(env!("CARGO_MANIFEST_DIR"), "/src/rbs/method_loader.rb");
+        let load_code = format!("require '{}'", rb_path);
+        let _: Value = self
+            .ruby
+            .eval(&load_code)
+            .map_err(|e| RbsError::LoadError(format!("Failed to load method_loader.rb: {}", e)))?;
+
+        // Instantiate Rbs::MethodLoader class and call method
+        let results: Value = self
+            .ruby
+            .eval("Rbs::MethodLoader.new.load_methods")
+            .map_err(|e| {
+                RbsError::LoadError(format!(
+                    "Failed to call Rbs::MethodLoader#load_methods: {}",
+                    e
+                ))
+            })?;
+
+        self.parse_results(results)
+    }
+
+    /// Convert Ruby array results to Vec of RbsMethodInfo structs
+    fn parse_results(&self, results: Value) -> Result<Vec<RbsMethodInfo>, RbsError> {
+        let mut method_infos = Vec::new();
+
+        // Convert to Ruby array
+        let results_array = RArray::try_convert(results)
+            .map_err(|e| RbsError::ParseError(format!("Failed to convert to array: {}", e)))?;
+
+        // Process each element
+        for entry in results_array.into_iter() {
+            let entry: Value = entry;
+
+            // Convert to hash
+            let hash = RHash::try_convert(entry).map_err(|e| {
+                RbsError::ParseError(format!("Failed to convert entry to hash: {}", e))
+            })?;
+
+            // Get each field
+            let receiver_class_value = hash
+                .get(self.ruby.to_symbol("receiver_class"))
+                .ok_or_else(|| RbsError::ParseError("Missing receiver_class".to_string()))?;
+            let receiver_class: String =
+                String::try_convert(receiver_class_value).map_err(|e| {
+                    RbsError::ParseError(format!("Failed to convert receiver_class: {}", e))
+                })?;
+
+            let method_name_value = hash
+                .get(self.ruby.to_symbol("method_name"))
+                .ok_or_else(|| RbsError::ParseError("Missing method_name".to_string()))?;
+            let method_name: String = String::try_convert(method_name_value).map_err(|e| {
+                RbsError::ParseError(format!("Failed to convert method_name: {}", e))
+            })?;
+
+            let return_type_value = hash
+                .get(self.ruby.to_symbol("return_type"))
+                .ok_or_else(|| RbsError::ParseError("Missing return_type".to_string()))?;
+            let return_type_str: String = String::try_convert(return_type_value).map_err(|e| {
+                RbsError::ParseError(format!("Failed to convert return_type: {}", e))
+            })?;
+
+            // Convert RBS type string to internal Type enum
+            let return_type = RbsTypeConverter::parse(&return_type_str);
+
+            method_infos.push(RbsMethodInfo {
+                receiver_class,
+                method_name,
+                return_type,
+            });
+        }
+
+        Ok(method_infos)
+    }
+}
+
+/// Helper function to register RBS methods to GlobalEnv
+/// Uses cache to avoid slow Ruby FFI calls
+pub fn register_rbs_methods(genv: &mut GlobalEnv, ruby: &Ruby) -> Result<usize, Error> {
+    use crate::cache::RbsCache;
+
+    let methodray_version = env!("CARGO_PKG_VERSION");
+
+    // Try to get RBS version
+    let rbs_version_value: Value = ruby
+        .eval("RBS::VERSION")
+        .unwrap_or_else(|_| ruby.eval("'unknown'").unwrap());
+    let rbs_version: String =
+        String::try_convert(rbs_version_value).unwrap_or_else(|_| "unknown".to_string());
+
+    // 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...");
+            let methods = load_and_cache_rbs_methods(ruby, methodray_version, &rbs_version)?;
+            methods
+        }
+    } else {
+        eprintln!("No cache found, loading from RBS...");
+        load_and_cache_rbs_methods(ruby, methodray_version, &rbs_version)?
+    };
+
+    let count = methods.len();
+    for method_info in methods {
+        let receiver_type = Type::Instance {
+            class_name: method_info.receiver_class,
+        };
+        genv.register_builtin_method(
+            receiver_type,
+            &method_info.method_name,
+            method_info.return_type,
+        );
+    }
+
+    Ok(count)
+}
+
+/// Load RBS methods and save to cache
+fn load_and_cache_rbs_methods(
+    ruby: &Ruby,
+    version: &str,
+    rbs_version: &str,
+) -> Result<Vec<RbsMethodInfo>, Error> {
+    use crate::cache::RbsCache;
+
+    let loader = RbsLoader::new(ruby)?;
+    let methods = loader.load_methods()?;
+
+    // Save to cache
+    let cache = RbsCache::from_method_infos(
+        methods.clone(),
+        version.to_string(),
+        rbs_version.to_string(),
+    );
+
+    if let Err(e) = cache.save() {
+        eprintln!("Warning: Failed to save RBS cache: {}", e);
+    } else {
+        eprintln!("Saved {} methods to cache", methods.len());
+    }
+
+    Ok(methods)
+}

data/rust/src/rbs/mod.rs

@@ -0,0 +1,15 @@
+//! RBS type loading and conversion
+
+#[cfg(feature = "ruby-ffi")]
+pub mod converter;
+#[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")]
+pub use loader::{register_rbs_methods, RbsLoader, RbsMethodInfo};

data/rust/src/source_map.rs

@@ -0,0 +1,102 @@
+/// Convert byte offset to (line, column) - 1-indexed
+fn offset_to_line_column(source: &str, offset: usize) -> (usize, usize) {
+    let mut line = 1;
+    let mut column = 1;
+    let mut current_offset = 0;
+
+    for ch in source.chars() {
+        if current_offset >= offset {
+            break;
+        }
+
+        if ch == '\n' {
+            line += 1;
+            column = 1;
+        } else {
+            column += 1;
+        }
+
+        current_offset += ch.len_utf8();
+    }
+
+    (line, column)
+}
+
+/// Source code location information
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SourceLocation {
+    pub line: usize,
+    pub column: usize,
+    pub length: usize,
+}
+
+#[allow(dead_code)]
+impl SourceLocation {
+    pub fn new(line: usize, column: usize, length: usize) -> Self {
+        Self {
+            line,
+            column,
+            length,
+        }
+    }
+
+    /// Create from ruby-prism Location and source code
+    /// Calculates line/column from byte offset
+    pub fn from_prism_location_with_source(location: &ruby_prism::Location, source: &str) -> Self {
+        let start_offset = location.start_offset();
+        let length = location.end_offset() - start_offset;
+
+        // Calculate line and column from byte offset
+        let (line, column) = offset_to_line_column(source, start_offset);
+
+        Self {
+            line,
+            column,
+            length,
+        }
+    }
+
+    /// Create from ruby-prism Location (without source - uses approximation)
+    pub fn from_prism_location(location: &ruby_prism::Location) -> Self {
+        let start_offset = location.start_offset();
+        let length = location.end_offset() - start_offset;
+
+        // Without source, we can't calculate exact line/column
+        // Use offset as column for now
+        Self {
+            line: 1, // Placeholder
+            column: start_offset + 1,
+            length,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_source_location_creation() {
+        let loc = SourceLocation::new(10, 5, 6);
+        assert_eq!(loc.line, 10);
+        assert_eq!(loc.column, 5);
+        assert_eq!(loc.length, 6);
+    }
+
+    #[test]
+    fn test_offset_to_line_column() {
+        let source = "x = 1\ny = x.upcase";
+        // "x = 1\n" is 6 bytes (0-5)
+        // "y = x.upcase" starts at offset 6
+        // "y = x." is 6 bytes, so ".upcase" starts at offset 12
+
+        // Test offset 0 (start of line 1)
+        assert_eq!(offset_to_line_column(source, 0), (1, 1));
+
+        // Test offset 6 (start of line 2, after newline)
+        assert_eq!(offset_to_line_column(source, 6), (2, 1));
+
+        // Test offset 10 (the 'x' in 'x.upcase')
+        assert_eq!(offset_to_line_column(source, 10), (2, 5));
+    }
+}

data/rust/src/types.rs

@@ -0,0 +1,75 @@
+/// Type system for graph-based type inference
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[allow(dead_code)]
+pub enum Type {
+    /// Instance type: String, Integer, etc.
+    Instance { class_name: String },
+    /// Singleton type: for class methods
+    Singleton { class_name: String },
+    /// nil type
+    Nil,
+    /// Union type: sum of multiple types
+    Union(Vec<Type>),
+    /// Bottom type: no type information
+    Bot,
+}
+
+impl Type {
+    /// Convert type to string representation
+    pub fn show(&self) -> String {
+        match self {
+            Type::Instance { class_name } => class_name.clone(),
+            Type::Singleton { class_name } => format!("singleton({})", class_name),
+            Type::Nil => "nil".to_string(),
+            Type::Union(types) => {
+                let names: Vec<_> = types.iter().map(|t| t.show()).collect();
+                names.join(" | ")
+            }
+            Type::Bot => "untyped".to_string(),
+        }
+    }
+
+    /// Convenience constructors
+    pub fn string() -> Self {
+        Type::Instance {
+            class_name: "String".to_string(),
+        }
+    }
+
+    pub fn integer() -> Self {
+        Type::Instance {
+            class_name: "Integer".to_string(),
+        }
+    }
+
+    pub fn array() -> Self {
+        Type::Instance {
+            class_name: "Array".to_string(),
+        }
+    }
+
+    pub fn hash() -> Self {
+        Type::Instance {
+            class_name: "Hash".to_string(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_type_show() {
+        assert_eq!(Type::string().show(), "String");
+        assert_eq!(Type::integer().show(), "Integer");
+        assert_eq!(Type::Nil.show(), "nil");
+        assert_eq!(Type::Bot.show(), "untyped");
+    }
+
+    #[test]
+    fn test_type_union() {
+        let union = Type::Union(vec![Type::string(), Type::integer()]);
+        assert_eq!(union.show(), "String | Integer");
+    }
+}