method-ray 0.1.1

data/rust/src/cache/rbs_cache.rs

@@ -0,0 +1,158 @@
+use anyhow::{Context, Result};
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::path::PathBuf;
+use std::time::SystemTime;
+
+#[cfg(feature = "ruby-ffi")]
+use crate::rbs::loader::RbsMethodInfo;
+
+/// Binary cache for RBS method definitions
+#[derive(Serialize, Deserialize, Debug)]
+pub struct RbsCache {
+    /// MethodRay version
+    pub version: String,
+    /// RBS gem version
+    pub rbs_version: String,
+    /// Cached method information
+    pub methods: Vec<SerializableMethodInfo>,
+    /// Cache creation timestamp
+    pub timestamp: SystemTime,
+}
+
+/// Serializable version of RbsMethodInfo
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct SerializableMethodInfo {
+    pub receiver_class: String,
+    pub method_name: String,
+    pub return_type_str: String, // Simplified: store as string
+}
+
+impl SerializableMethodInfo {
+    /// Parse return type string into Type (simple parser for cached data)
+    pub fn return_type(&self) -> crate::types::Type {
+        crate::types::Type::Instance {
+            class_name: self.return_type_str.clone(),
+        }
+    }
+}
+
+#[allow(dead_code)]
+impl RbsCache {
+    /// Get cache file path
+    pub fn cache_path() -> Result<PathBuf> {
+        let cache_dir = dirs::cache_dir()
+            .context("Failed to get cache directory")?
+            .join("methodray");
+
+        fs::create_dir_all(&cache_dir).context("Failed to create cache directory")?;
+
+        Ok(cache_dir.join("rbs_cache.bin"))
+    }
+
+    /// Load cache from disk
+    pub fn load() -> Result<Self> {
+        let path = Self::cache_path()?;
+        let bytes = fs::read(&path)
+            .with_context(|| format!("Failed to read cache from {}", path.display()))?;
+
+        bincode::deserialize(&bytes).context("Failed to deserialize cache")
+    }
+
+    /// Save cache to disk
+    pub fn save(&self) -> Result<()> {
+        let path = Self::cache_path()?;
+        let bytes = bincode::serialize(self).context("Failed to serialize cache")?;
+
+        fs::write(&path, bytes)
+            .with_context(|| format!("Failed to write cache to {}", path.display()))?;
+
+        Ok(())
+    }
+
+    /// Check if cache is valid
+    pub fn is_valid(&self, current_version: &str, current_rbs_version: &str) -> bool {
+        self.version == current_version && self.rbs_version == current_rbs_version
+    }
+
+    /// Get methods for registration (works without ruby-ffi feature)
+    pub fn methods(&self) -> &[SerializableMethodInfo] {
+        &self.methods
+    }
+
+    /// Convert to RbsMethodInfo (requires ruby-ffi for full type parsing)
+    #[cfg(feature = "ruby-ffi")]
+    pub fn to_method_infos(&self) -> Vec<RbsMethodInfo> {
+        self.methods
+            .iter()
+            .map(|m| RbsMethodInfo {
+                receiver_class: m.receiver_class.clone(),
+                method_name: m.method_name.clone(),
+                return_type: crate::rbs::converter::RbsTypeConverter::parse(&m.return_type_str),
+            })
+            .collect()
+    }
+
+    /// Create from RbsMethodInfo
+    #[cfg(feature = "ruby-ffi")]
+    pub fn from_method_infos(
+        methods: Vec<RbsMethodInfo>,
+        version: String,
+        rbs_version: String,
+    ) -> Self {
+        let serializable_methods = methods
+            .into_iter()
+            .map(|m| SerializableMethodInfo {
+                receiver_class: m.receiver_class,
+                method_name: m.method_name,
+                return_type_str: m.return_type.show(),
+            })
+            .collect();
+
+        Self {
+            version,
+            rbs_version,
+            methods: serializable_methods,
+            timestamp: SystemTime::now(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_cache_serialization() {
+        let cache = RbsCache {
+            version: "0.1.0".to_string(),
+            rbs_version: "3.7.0".to_string(),
+            methods: vec![SerializableMethodInfo {
+                receiver_class: "String".to_string(),
+                method_name: "upcase".to_string(),
+                return_type_str: "String".to_string(),
+            }],
+            timestamp: SystemTime::now(),
+        };
+
+        let bytes = bincode::serialize(&cache).unwrap();
+        let deserialized: RbsCache = bincode::deserialize(&bytes).unwrap();
+
+        assert_eq!(deserialized.version, "0.1.0");
+        assert_eq!(deserialized.methods.len(), 1);
+    }
+
+    #[test]
+    fn test_cache_validation() {
+        let cache = RbsCache {
+            version: "0.1.0".to_string(),
+            rbs_version: "3.7.0".to_string(),
+            methods: vec![],
+            timestamp: SystemTime::now(),
+        };
+
+        assert!(cache.is_valid("0.1.0", "3.7.0"));
+        assert!(!cache.is_valid("0.2.0", "3.7.0"));
+        assert!(!cache.is_valid("0.1.0", "3.8.0"));
+    }
+}

data/rust/src/checker.rs

@@ -0,0 +1,139 @@
+use crate::analyzer::AstInstaller;
+use crate::diagnostics::Diagnostic;
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::parser;
+use anyhow::{Context, Result};
+use std::path::Path;
+
+/// File type checker
+pub struct FileChecker {
+    // No state - creates fresh GlobalEnv for each check
+}
+
+impl FileChecker {
+    /// Create new FileChecker
+    /// Note: This is for standalone CLI usage (no Ruby runtime)
+    pub fn new() -> Result<Self> {
+        // Just verify cache exists
+        use crate::cache::RbsCache;
+        RbsCache::load().context(
+            "Failed to load RBS cache. Please run from Ruby first to generate cache:\n\
+             ruby -rmethodray -e 'MethodRay::Analyzer.new(\".\").infer_types(\"x=1\")'",
+        )?;
+
+        Ok(Self {})
+    }
+
+    /// Check a single Ruby file
+    pub fn check_file(&self, file_path: &Path) -> Result<Vec<Diagnostic>> {
+        // Read source code
+        let source = std::fs::read_to_string(file_path)
+            .with_context(|| format!("Failed to read {}", file_path.display()))?;
+
+        // Parse file
+        let parse_result = parser::parse_ruby_file(file_path)
+            .with_context(|| format!("Failed to parse {}", file_path.display()))?;
+
+        // Create fresh GlobalEnv for this analysis
+        let mut genv = GlobalEnv::new();
+        load_rbs_from_cache(&mut genv)?;
+
+        let mut lenv = LocalEnv::new();
+        let mut installer = AstInstaller::new(&mut genv, &mut lenv, &source);
+
+        // Process AST
+        let root = parse_result.node();
+        if let Some(program_node) = root.as_program_node() {
+            let statements = program_node.statements();
+            for stmt in &statements.body() {
+                installer.install_node(&stmt);
+            }
+        }
+
+        installer.finish();
+
+        // Collect diagnostics
+        let diagnostics = collect_diagnostics(&genv, file_path);
+
+        Ok(diagnostics)
+    }
+}
+
+/// Load RBS methods from cache (CLI mode without Ruby runtime)
+fn load_rbs_from_cache(genv: &mut GlobalEnv) -> Result<()> {
+    use crate::cache::RbsCache;
+    use crate::types::Type;
+
+    let cache = RbsCache::load().context(
+        "Failed to load RBS cache. Please run from Ruby first to generate cache:\n\
+         ruby -rmethodray -e 'MethodRay::Analyzer.new(\".\").infer_types(\"x=1\")'",
+    )?;
+
+    let methods = cache.methods();
+    eprintln!("Loaded {} methods from cache", methods.len());
+
+    for method_info in methods {
+        let receiver_type = Type::Instance {
+            class_name: method_info.receiver_class.clone(),
+        };
+        genv.register_builtin_method(
+            receiver_type,
+            &method_info.method_name,
+            method_info.return_type(),
+        );
+    }
+
+    Ok(())
+}
+
+/// Collect type error diagnostics from GlobalEnv
+fn collect_diagnostics(genv: &GlobalEnv, file_path: &Path) -> Vec<Diagnostic> {
+    use crate::diagnostics::{Diagnostic, Location};
+    use std::path::PathBuf;
+
+    let mut diagnostics = Vec::new();
+
+    // Convert TypeErrors to Diagnostics
+    for type_error in &genv.type_errors {
+        // Use actual location from TypeError if available
+        let location = if let Some(source_loc) = &type_error.location {
+            Location {
+                file: PathBuf::from(file_path),
+                line: source_loc.line,
+                column: source_loc.column,
+                length: Some(source_loc.length),
+            }
+        } else {
+            // Fallback to placeholder
+            Location {
+                file: PathBuf::from(file_path),
+                line: 1,
+                column: 1,
+                length: None,
+            }
+        };
+
+        let diagnostic = Diagnostic::undefined_method(
+            location,
+            &type_error.receiver_type.show(),
+            &type_error.method_name,
+        );
+
+        diagnostics.push(diagnostic);
+    }
+
+    diagnostics
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_file_checker_creation() {
+        // This test will fail if RBS cache doesn't exist
+        // That's expected - cache should be generated from Ruby side first
+        let result = FileChecker::new();
+        assert!(result.is_ok() || result.is_err()); // Just check it doesn't panic
+    }
+}

data/rust/src/cli/args.rs

@@ -0,0 +1,40 @@
+//! CLI argument definitions
+
+use clap::{Parser, Subcommand};
+use std::path::PathBuf;
+
+/// MethodRay - Fast Ruby type checker
+#[derive(Parser)]
+#[command(name = "methodray")]
+#[command(about = "Fast Ruby type checker with method chain validation", long_about = None)]
+pub struct Cli {
+    #[command(subcommand)]
+    pub command: Commands,
+}
+
+#[derive(Subcommand)]
+pub enum Commands {
+    /// Check Ruby file(s) for type errors
+    Check {
+        /// Ruby file to check (if not specified, checks all files in project)
+        #[arg(value_name = "FILE")]
+        file: Option<PathBuf>,
+
+        /// Show detailed output
+        #[arg(short, long)]
+        verbose: bool,
+    },
+
+    /// Watch a Ruby file and re-check on changes
+    Watch {
+        /// Ruby file to watch
+        #[arg(value_name = "FILE")]
+        file: PathBuf,
+    },
+
+    /// Show version information
+    Version,
+
+    /// Clear RBS cache
+    ClearCache,
+}

data/rust/src/cli/commands.rs

@@ -0,0 +1,139 @@
+//! CLI command implementations
+
+use anyhow::Result;
+use std::path::PathBuf;
+
+use crate::cache::RbsCache;
+use crate::checker::FileChecker;
+use crate::diagnostics;
+
+/// Check a single Ruby file for type errors
+/// Returns Ok(true) if no errors, Ok(false) if errors found
+pub fn check_single_file(file_path: &PathBuf, verbose: bool) -> Result<bool> {
+    let checker = FileChecker::new()?;
+    let diagnostics = checker.check_file(file_path)?;
+
+    if diagnostics.is_empty() {
+        if verbose {
+            println!("{}: No errors found", file_path.display());
+        }
+        Ok(true)
+    } else {
+        let output = diagnostics::format_diagnostics_with_file(&diagnostics, file_path);
+        println!("{}", output);
+
+        let has_errors = diagnostics
+            .iter()
+            .any(|d| d.level == diagnostics::DiagnosticLevel::Error);
+
+        Ok(!has_errors)
+    }
+}
+
+/// Check all Ruby files in the project
+pub fn check_project(_verbose: bool) -> Result<()> {
+    println!("Project-wide checking not yet implemented");
+    println!("Use: methodray check <file> to check a single file");
+    Ok(())
+}
+
+/// Watch a file for changes and re-check on modifications
+pub fn watch_file(file_path: &PathBuf) -> Result<()> {
+    use notify::{Config, RecommendedWatcher, RecursiveMode, Watcher};
+    use std::sync::mpsc::channel;
+    use std::time::Duration;
+
+    if !file_path.exists() {
+        anyhow::bail!("File not found: {}", file_path.display());
+    }
+
+    println!(
+        "Watching {} for changes (Press Ctrl+C to stop)",
+        file_path.display()
+    );
+    println!();
+
+    // Initial check
+    println!("Initial check:");
+    let mut had_errors = match check_single_file(file_path, true) {
+        Ok(success) => !success,
+        Err(e) => {
+            eprintln!("Error during initial check: {}", e);
+            true
+        }
+    };
+    println!();
+
+    // Setup file watcher
+    let (tx, rx) = channel();
+
+    let mut watcher = RecommendedWatcher::new(
+        move |res| {
+            if let Ok(event) = res {
+                let _ = tx.send(event);
+            }
+        },
+        Config::default().with_poll_interval(Duration::from_millis(500)),
+    )?;
+
+    watcher.watch(file_path.as_ref(), RecursiveMode::NonRecursive)?;
+
+    // Event loop
+    loop {
+        match rx.recv() {
+            Ok(event) => {
+                if let notify::EventKind::Modify(_) = event.kind {
+                    println!("\n--- File changed, re-checking... ---\n");
+
+                    std::thread::sleep(Duration::from_millis(100));
+
+                    match check_single_file(file_path, true) {
+                        Ok(success) => {
+                            if success && had_errors {
+                                println!("✓ All errors fixed!");
+                                had_errors = false;
+                            } else if !success && !had_errors {
+                                had_errors = true;
+                            }
+                        }
+                        Err(e) => {
+                            eprintln!("Error during check: {}", e);
+                            had_errors = true;
+                        }
+                    }
+                    println!();
+                }
+            }
+            Err(e) => {
+                eprintln!("Watch error: {}", e);
+                break;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Clear the RBS cache
+pub fn clear_cache() -> Result<()> {
+    match RbsCache::cache_path() {
+        Ok(path) => {
+            if path.exists() {
+                std::fs::remove_file(&path)?;
+                println!("Cache cleared: {}", path.display());
+            } else {
+                println!("No cache file found");
+            }
+        }
+        Err(e) => {
+            eprintln!("Failed to get cache path: {}", e);
+        }
+    }
+
+    Ok(())
+}
+
+/// Print version information
+pub fn print_version() {
+    println!("MethodRay {}", env!("CARGO_PKG_VERSION"));
+}

data/rust/src/cli/mod.rs

@@ -0,0 +1,6 @@
+//! CLI module - Command-line interface for MethodRay
+
+pub mod args;
+pub mod commands;
+
+pub use args::{Cli, Commands};

data/rust/src/diagnostics/diagnostic.rs

@@ -0,0 +1,125 @@
+use std::path::PathBuf;
+
+/// Diagnostic severity level (LSP compatible)
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[allow(dead_code)]
+pub enum DiagnosticLevel {
+    Error,
+    Warning,
+}
+
+impl DiagnosticLevel {
+    pub fn as_str(&self) -> &str {
+        match self {
+            DiagnosticLevel::Error => "error",
+            DiagnosticLevel::Warning => "warning",
+        }
+    }
+}
+
+/// Source code location
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Location {
+    pub file: PathBuf,
+    pub line: usize,
+    pub column: usize,
+    pub length: Option<usize>, // Character length of the error span
+}
+
+/// Type checking diagnostic
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub struct Diagnostic {
+    pub location: Location,
+    pub level: DiagnosticLevel,
+    pub message: String,
+    pub code: Option<String>, // e.g., "E001"
+}
+
+#[allow(dead_code)]
+impl Diagnostic {
+    /// Create an error diagnostic
+    pub fn error(location: Location, message: String) -> Self {
+        Self {
+            location,
+            level: DiagnosticLevel::Error,
+            message,
+            code: None,
+        }
+    }
+
+    /// Create a warning diagnostic (internal use only)
+    fn warning(location: Location, message: String) -> Self {
+        Self {
+            location,
+            level: DiagnosticLevel::Warning,
+            message,
+            code: None,
+        }
+    }
+
+    /// Create undefined method error
+    pub fn undefined_method(location: Location, receiver_type: &str, method_name: &str) -> Self {
+        Self::error(
+            location,
+            format!("undefined method `{}` for {}", method_name, receiver_type),
+        )
+    }
+
+    /// Create Union type partial error (warning)
+    pub fn union_partial_error(
+        location: Location,
+        valid_types: Vec<String>,
+        invalid_types: Vec<String>,
+        method_name: &str,
+    ) -> Self {
+        let message = format!(
+            "method `{}` is defined for {} but not for {}",
+            method_name,
+            valid_types.join(", "),
+            invalid_types.join(", ")
+        );
+        Self::warning(location, message)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_diagnostic_creation() {
+        let loc = Location {
+            file: PathBuf::from("test.rb"),
+            line: 10,
+            column: 5,
+            length: None,
+        };
+
+        let diag = Diagnostic::undefined_method(loc.clone(), "Integer", "upcase");
+        assert_eq!(diag.level, DiagnosticLevel::Error);
+        assert_eq!(diag.message, "undefined method `upcase` for Integer");
+    }
+
+    #[test]
+    fn test_union_partial_error() {
+        let loc = Location {
+            file: PathBuf::from("test.rb"),
+            line: 15,
+            column: 3,
+            length: None,
+        };
+
+        let diag = Diagnostic::union_partial_error(
+            loc,
+            vec!["String".to_string()],
+            vec!["Integer".to_string()],
+            "upcase",
+        );
+
+        assert_eq!(diag.level, DiagnosticLevel::Warning);
+        assert!(diag
+            .message
+            .contains("method `upcase` is defined for String but not for Integer"));
+    }
+}