method-ray 0.1.1

data/rust/src/graph/change_set.rs

@@ -0,0 +1,115 @@
+use super::VertexId;
+
+/// Manages edge changes for type propagation
+#[derive(Debug, Clone)]
+pub struct ChangeSet {
+    new_edges: Vec<(VertexId, VertexId)>,
+    edges: Vec<(VertexId, VertexId)>,
+}
+
+impl ChangeSet {
+    pub fn new() -> Self {
+        Self {
+            new_edges: Vec::new(),
+            edges: Vec::new(),
+        }
+    }
+
+    /// Add edge
+    pub fn add_edge(&mut self, src: VertexId, dst: VertexId) {
+        self.new_edges.push((src, dst));
+    }
+
+    /// Commit changes and return list of added/removed edges
+    pub fn reinstall(&mut self) -> Vec<EdgeUpdate> {
+        // Remove duplicates
+        self.new_edges.sort_by_key(|&(src, dst)| (src.0, dst.0));
+        self.new_edges.dedup();
+
+        let mut updates = Vec::new();
+
+        // New edges
+        for &(src, dst) in &self.new_edges {
+            if !self.edges.contains(&(src, dst)) {
+                updates.push(EdgeUpdate::Add { src, dst });
+            }
+        }
+
+        // Removed edges
+        for &(src, dst) in &self.edges {
+            if !self.new_edges.contains(&(src, dst)) {
+                updates.push(EdgeUpdate::Remove { src, dst });
+            }
+        }
+
+        // Commit edges
+        std::mem::swap(&mut self.edges, &mut self.new_edges);
+        self.new_edges.clear();
+
+        updates
+    }
+}
+
+/// Edge update type
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum EdgeUpdate {
+    Add { src: VertexId, dst: VertexId },
+    Remove { src: VertexId, dst: VertexId },
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_change_set_add() {
+        let mut cs = ChangeSet::new();
+
+        cs.add_edge(VertexId(1), VertexId(2));
+        cs.add_edge(VertexId(2), VertexId(3));
+
+        let updates = cs.reinstall();
+
+        assert_eq!(updates.len(), 2);
+        assert!(updates.contains(&EdgeUpdate::Add {
+            src: VertexId(1),
+            dst: VertexId(2)
+        }));
+        assert!(updates.contains(&EdgeUpdate::Add {
+            src: VertexId(2),
+            dst: VertexId(3)
+        }));
+    }
+
+    #[test]
+    fn test_change_set_dedup() {
+        let mut cs = ChangeSet::new();
+
+        cs.add_edge(VertexId(1), VertexId(2));
+        cs.add_edge(VertexId(1), VertexId(2)); // Duplicate
+
+        let updates = cs.reinstall();
+
+        assert_eq!(updates.len(), 1); // Duplicates removed
+    }
+
+    #[test]
+    fn test_change_set_remove() {
+        let mut cs = ChangeSet::new();
+
+        // First commit
+        cs.add_edge(VertexId(1), VertexId(2));
+        cs.add_edge(VertexId(2), VertexId(3));
+        cs.reinstall();
+
+        // Second time: keep only (1,2)
+        cs.add_edge(VertexId(1), VertexId(2));
+        let updates = cs.reinstall();
+
+        assert_eq!(updates.len(), 1);
+        assert!(updates.contains(&EdgeUpdate::Remove {
+            src: VertexId(2),
+            dst: VertexId(3)
+        }));
+    }
+}

data/rust/src/graph/mod.rs

@@ -0,0 +1,7 @@
+pub mod r#box;
+pub mod change_set;
+pub mod vertex;
+
+pub use change_set::{ChangeSet, EdgeUpdate};
+pub use r#box::{BoxId, BoxTrait, MethodCallBox};
+pub use vertex::{Source, Vertex, VertexId};

data/rust/src/graph/vertex.rs

@@ -0,0 +1,167 @@
+use crate::types::Type;
+use std::collections::{HashMap, HashSet};
+
+/// Vertex ID (uniquely identifies a vertex in the graph)
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct VertexId(pub usize);
+
+/// Source: Vertex with fixed type (e.g., literals)
+#[derive(Debug, Clone)]
+pub struct Source {
+    pub ty: Type,
+}
+
+impl Source {
+    pub fn new(ty: Type) -> Self {
+        Self { ty }
+    }
+}
+
+/// Vertex: Vertex that dynamically accumulates types (e.g., variables)
+#[derive(Debug, Clone)]
+pub struct Vertex {
+    /// Type -> Sources (set of Source IDs that provided this type)
+    pub types: HashMap<Type, HashSet<VertexId>>,
+    /// Set of connected Vertex IDs
+    pub next_vtxs: HashSet<VertexId>,
+}
+
+impl Vertex {
+    pub fn new() -> Self {
+        Self {
+            types: HashMap::new(),
+            next_vtxs: HashSet::new(),
+        }
+    }
+
+    /// Add connection destination
+    pub fn add_next(&mut self, next_id: VertexId) {
+        self.next_vtxs.insert(next_id);
+    }
+
+    /// Add type (core of type propagation)
+    /// Returns: list of newly added types and destinations to propagate to
+    pub fn on_type_added(
+        &mut self,
+        src_id: VertexId,
+        added_types: Vec<Type>,
+    ) -> Vec<(VertexId, Vec<Type>)> {
+        let mut new_added_types = Vec::new();
+
+        for ty in added_types {
+            if let Some(sources) = self.types.get_mut(&ty) {
+                // Type already exists: add Source
+                sources.insert(src_id);
+            } else {
+                // New type: add type and record Source
+                let mut sources = HashSet::new();
+                sources.insert(src_id);
+                self.types.insert(ty.clone(), sources);
+                new_added_types.push(ty);
+            }
+        }
+
+        // If no new types, don't propagate anything
+        if new_added_types.is_empty() {
+            return vec![];
+        }
+
+        // Propagate to connections
+        self.next_vtxs
+            .iter()
+            .map(|&next_id| (next_id, new_added_types.clone()))
+            .collect()
+    }
+
+    /// Convert type to string representation
+    pub fn show(&self) -> String {
+        if self.types.is_empty() {
+            return "untyped".to_string();
+        }
+
+        let mut type_strs: Vec<_> = self.types.keys().map(|t| t.show()).collect();
+        type_strs.sort();
+        type_strs.dedup();
+
+        if type_strs.len() == 1 {
+            type_strs[0].clone()
+        } else {
+            format!("({})", type_strs.join(" | "))
+        }
+    }
+}
+
+impl Default for Vertex {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_source_type() {
+        let src = Source::new(Type::string());
+        assert_eq!(src.ty.show(), "String");
+    }
+
+    #[test]
+    fn test_vertex_empty() {
+        let vtx = Vertex::new();
+        assert_eq!(vtx.show(), "untyped");
+    }
+
+    #[test]
+    fn test_vertex_single_type() {
+        let mut vtx = Vertex::new();
+
+        // Add String type
+        let propagations = vtx.on_type_added(VertexId(1), vec![Type::string()]);
+        assert_eq!(vtx.show(), "String");
+        assert_eq!(propagations.len(), 0); // No propagation since no connections
+    }
+
+    #[test]
+    fn test_vertex_union_type() {
+        let mut vtx = Vertex::new();
+
+        // Add String type
+        vtx.on_type_added(VertexId(1), vec![Type::string()]);
+        assert_eq!(vtx.show(), "String");
+
+        // Add Integer type → becomes Union type
+        vtx.on_type_added(VertexId(1), vec![Type::integer()]);
+        assert_eq!(vtx.show(), "(Integer | String)");
+    }
+
+    #[test]
+    fn test_vertex_propagation() {
+        let mut vtx = Vertex::new();
+
+        // Add connections
+        vtx.add_next(VertexId(3));
+        vtx.add_next(VertexId(4));
+
+        // Add type → propagated to connections
+        let propagations = vtx.on_type_added(VertexId(1), vec![Type::string()]);
+
+        assert_eq!(propagations.len(), 2);
+        assert!(propagations.contains(&(VertexId(3), vec![Type::string()])));
+        assert!(propagations.contains(&(VertexId(4), vec![Type::string()])));
+    }
+
+    #[test]
+    fn test_vertex_no_duplicate_propagation() {
+        let mut vtx = Vertex::new();
+        vtx.add_next(VertexId(3));
+
+        // Add same type twice → only first time propagates
+        let prop1 = vtx.on_type_added(VertexId(1), vec![Type::string()]);
+        assert_eq!(prop1.len(), 1);
+
+        let prop2 = vtx.on_type_added(VertexId(1), vec![Type::string()]);
+        assert_eq!(prop2.len(), 0); // No propagation since already exists
+    }
+}

data/rust/src/lib.rs

@@ -0,0 +1,24 @@
+//! Method-Ray Core - Static type checker for Ruby
+//!
+//! This crate provides the core type inference engine.
+
+pub mod analyzer;
+pub mod cache;
+pub mod diagnostics;
+pub mod env;
+pub mod graph;
+pub mod parser;
+pub mod source_map;
+pub mod types;
+
+#[cfg(feature = "ruby-ffi")]
+pub mod rbs;
+
+#[cfg(any(feature = "cli", feature = "lsp"))]
+pub mod checker;
+
+#[cfg(feature = "cli")]
+pub mod cli;
+
+#[cfg(feature = "lsp")]
+pub mod lsp;

data/rust/src/lsp/diagnostics.rs

@@ -0,0 +1,133 @@
+use crate::diagnostics::{Diagnostic as MethodRayDiagnostic, DiagnosticLevel};
+use tower_lsp::lsp_types::{Diagnostic, DiagnosticSeverity, Position, Range};
+
+/// Extract method name length from error message
+/// Supports messages like:
+/// - "undefined method `downcase` for Integer"
+/// - "method `upcase` is defined for ..."
+fn extract_method_name_length(message: &str) -> Option<u32> {
+    // Pattern: `method_name`
+    if let Some(start) = message.find('`') {
+        if let Some(end) = message[start + 1..].find('`') {
+            let method_name = &message[start + 1..start + 1 + end];
+            return Some(method_name.len() as u32);
+        }
+    }
+    None
+}
+
+/// Convert MethodRay Diagnostic to LSP Diagnostic
+pub fn to_lsp_diagnostic(diag: &MethodRayDiagnostic) -> Diagnostic {
+    let severity = match diag.level {
+        DiagnosticLevel::Error => DiagnosticSeverity::ERROR,
+        DiagnosticLevel::Warning => DiagnosticSeverity::WARNING,
+    };
+
+    let start_line = if diag.location.line > 0 {
+        (diag.location.line - 1) as u32
+    } else {
+        0
+    };
+
+    let start_char = if diag.location.column > 0 {
+        (diag.location.column - 1) as u32
+    } else {
+        0
+    };
+
+    // Use actual source length if available, otherwise extract from message
+    let highlight_length = diag
+        .location
+        .length
+        .map(|len| len as u32)
+        .or_else(|| extract_method_name_length(&diag.message))
+        .unwrap_or(5);
+    let end_char = start_char + highlight_length;
+
+    Diagnostic {
+        range: Range {
+            start: Position {
+                line: start_line,
+                character: start_char,
+            },
+            end: Position {
+                line: start_line,
+                character: end_char,
+            },
+        },
+        severity: Some(severity),
+        code: None,
+        code_description: None,
+        source: Some("methodray".to_string()),
+        message: diag.message.clone(),
+        related_information: None,
+        tags: None,
+        data: None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::diagnostics::Location;
+
+    #[test]
+    fn test_to_lsp_diagnostic() {
+        use std::path::PathBuf;
+
+        let methodray_diag = MethodRayDiagnostic {
+            level: DiagnosticLevel::Error,
+            location: Location {
+                file: PathBuf::from("test.rb"),
+                line: 5,
+                column: 10,
+                length: Some(6), // "upcase".len()
+            },
+            message: "undefined method `upcase` for Integer".to_string(),
+            code: None,
+        };
+
+        let lsp_diag = to_lsp_diagnostic(&methodray_diag);
+
+        assert_eq!(lsp_diag.range.start.line, 4); // 0-indexed
+        assert_eq!(lsp_diag.range.start.character, 9); // 0-indexed
+        assert_eq!(lsp_diag.range.end.character, 15); // start(9) + length(6)
+        assert_eq!(lsp_diag.severity, Some(DiagnosticSeverity::ERROR));
+        assert_eq!(lsp_diag.message, "undefined method `upcase` for Integer");
+    }
+
+    #[test]
+    fn test_extract_method_name_length() {
+        assert_eq!(
+            extract_method_name_length("undefined method `downcase` for Integer"),
+            Some(8)
+        );
+        assert_eq!(
+            extract_method_name_length("method `upcase` is defined for String"),
+            Some(6)
+        );
+        assert_eq!(extract_method_name_length("no method name here"), None);
+    }
+
+    #[test]
+    fn test_highlight_length_for_downcase() {
+        use std::path::PathBuf;
+
+        let methodray_diag = MethodRayDiagnostic {
+            level: DiagnosticLevel::Error,
+            location: Location {
+                file: PathBuf::from("test.rb"),
+                line: 2,
+                column: 5,
+                length: Some(8), // "downcase".len()
+            },
+            message: "undefined method `downcase` for Integer".to_string(),
+            code: None,
+        };
+
+        let lsp_diag = to_lsp_diagnostic(&methodray_diag);
+
+        assert_eq!(lsp_diag.range.start.character, 4); // column 5 -> 0-indexed = 4
+        assert_eq!(lsp_diag.range.end.character, 12); // start(4) + length(8)
+    }
+}

data/rust/src/lsp/main.rs

@@ -0,0 +1,8 @@
+//! LSP server binary entry point
+
+use methodray_core::lsp;
+
+#[tokio::main]
+async fn main() {
+    lsp::run_server().await;
+}

data/rust/src/lsp/mod.rs

@@ -0,0 +1,4 @@
+pub mod diagnostics;
+pub mod server;
+
+pub use server::run_server;

data/rust/src/lsp/server.rs

@@ -0,0 +1,138 @@
+use anyhow::Context;
+use std::collections::HashMap;
+use tokio::sync::RwLock;
+use tower_lsp::jsonrpc::Result;
+use tower_lsp::lsp_types::*;
+use tower_lsp::{Client, LanguageServer, LspService, Server};
+
+use super::diagnostics::to_lsp_diagnostic;
+use crate::checker::FileChecker;
+
+pub struct MethodRayServer {
+    client: Client,
+    documents: RwLock<HashMap<Url, String>>,
+}
+
+impl MethodRayServer {
+    pub fn new(client: Client) -> Self {
+        Self {
+            client,
+            documents: RwLock::new(HashMap::new()),
+        }
+    }
+
+    async fn check_document(&self, uri: Url) {
+        let documents = self.documents.read().await;
+
+        if let Some(source) = documents.get(&uri) {
+            match self.run_type_check(&uri, source).await {
+                Ok(diagnostics) => {
+                    self.client
+                        .publish_diagnostics(uri.clone(), diagnostics, None)
+                        .await;
+                }
+                Err(e) => {
+                    self.client
+                        .log_message(MessageType::ERROR, format!("Type check failed: {}", e))
+                        .await;
+                }
+            }
+        }
+    }
+
+    async fn run_type_check(&self, uri: &Url, source: &str) -> anyhow::Result<Vec<Diagnostic>> {
+        // Convert URI to file path
+        let file_path = uri
+            .to_file_path()
+            .map_err(|_| anyhow::anyhow!("Invalid file URI: {}", uri))?;
+
+        // Create a temporary file for checking
+        let temp_dir = tempfile::tempdir()?;
+        let temp_file = temp_dir.path().join("temp.rb");
+        std::fs::write(&temp_file, source)?;
+
+        // Run type check using FileChecker
+        let checker = FileChecker::new().with_context(|| "Failed to create FileChecker")?;
+
+        let methodray_diagnostics = checker
+            .check_file(&temp_file)
+            .with_context(|| format!("Failed to check file: {}", file_path.display()))?;
+
+        // Convert to LSP diagnostics
+        let lsp_diagnostics = methodray_diagnostics
+            .iter()
+            .map(to_lsp_diagnostic)
+            .collect();
+
+        Ok(lsp_diagnostics)
+    }
+}
+
+#[tower_lsp::async_trait]
+impl LanguageServer for MethodRayServer {
+    async fn initialize(&self, _: InitializeParams) -> Result<InitializeResult> {
+        Ok(InitializeResult {
+            capabilities: ServerCapabilities {
+                text_document_sync: Some(TextDocumentSyncCapability::Kind(
+                    TextDocumentSyncKind::FULL,
+                )),
+                ..Default::default()
+            },
+            ..Default::default()
+        })
+    }
+
+    async fn initialized(&self, _: InitializedParams) {
+        self.client
+            .log_message(MessageType::INFO, "MethodRay LSP server initialized")
+            .await;
+    }
+
+    async fn did_open(&self, params: DidOpenTextDocumentParams) {
+        let uri = params.text_document.uri;
+        let text = params.text_document.text;
+
+        self.documents.write().await.insert(uri.clone(), text);
+        self.check_document(uri).await;
+    }
+
+    async fn did_change(&self, params: DidChangeTextDocumentParams) {
+        let uri = params.text_document.uri;
+
+        if let Some(change) = params.content_changes.first() {
+            let text = change.text.clone();
+            self.documents.write().await.insert(uri.clone(), text);
+            // Note: In production, we'd want debouncing here
+            // self.check_document(uri).await;
+        }
+    }
+
+    async fn did_save(&self, params: DidSaveTextDocumentParams) {
+        self.check_document(params.text_document.uri).await;
+    }
+
+    async fn did_close(&self, params: DidCloseTextDocumentParams) {
+        self.documents
+            .write()
+            .await
+            .remove(&params.text_document.uri);
+
+        // Clear diagnostics
+        self.client
+            .publish_diagnostics(params.text_document.uri, vec![], None)
+            .await;
+    }
+
+    async fn shutdown(&self) -> Result<()> {
+        Ok(())
+    }
+}
+
+pub async fn run_server() {
+    let stdin = tokio::io::stdin();
+    let stdout = tokio::io::stdout();
+
+    let (service, socket) = LspService::new(|client| MethodRayServer::new(client));
+
+    Server::new(stdin, stdout, socket).serve(service).await;
+}

data/rust/src/main.rs

@@ -0,0 +1,46 @@
+//! MethodRay CLI - Fast Ruby type checker
+
+use anyhow::Result;
+use clap::Parser;
+
+mod analyzer;
+mod cache;
+mod checker;
+mod cli;
+mod diagnostics;
+mod env;
+mod graph;
+mod parser;
+mod rbs;
+mod source_map;
+mod types;
+
+use cli::{commands, Cli, Commands};
+
+fn main() -> Result<()> {
+    let cli = Cli::parse();
+
+    match cli.command {
+        Commands::Check { file, verbose } => {
+            if let Some(file_path) = file {
+                let success = commands::check_single_file(&file_path, verbose)?;
+                if !success {
+                    std::process::exit(1);
+                }
+            } else {
+                commands::check_project(verbose)?;
+            }
+        }
+        Commands::Watch { file } => {
+            commands::watch_file(&file)?;
+        }
+        Commands::Version => {
+            commands::print_version();
+        }
+        Commands::ClearCache => {
+            commands::clear_cache()?;
+        }
+    }
+
+    Ok(())
+}