method-ray 0.1.1

data/rust/src/diagnostics/formatter.rs

@@ -0,0 +1,119 @@
+use super::diagnostic::Diagnostic;
+use std::fs;
+use std::path::Path;
+
+/// Format diagnostics in LSP-compatible format
+///
+/// Example output:
+/// ```text
+/// app/models/user.rb:10:5: error: undefined method `upcase` for Integer
+/// ```
+#[allow(dead_code)]
+pub fn format_diagnostics(diagnostics: &[Diagnostic]) -> String {
+    diagnostics
+        .iter()
+        .map(|diag| {
+            format!(
+                "{}:{}:{}: {}: {}",
+                diag.location.file.display(),
+                diag.location.line,
+                diag.location.column,
+                diag.level.as_str(),
+                diag.message
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+/// Format diagnostics with code snippet
+///
+/// Example output:
+/// ```text
+/// app/models/user.rb:10:5: error: undefined method `upcase` for Integer
+///    x.upcase
+///      ^^^^^^
+/// ```
+pub fn format_diagnostics_with_source(diagnostics: &[Diagnostic], source_code: &str) -> String {
+    let lines: Vec<&str> = source_code.lines().collect();
+
+    diagnostics
+        .iter()
+        .map(|diag| {
+            let mut output = format!(
+                "{}:{}:{}: {}: {}",
+                diag.location.file.display(),
+                diag.location.line,
+                diag.location.column,
+                diag.level.as_str(),
+                diag.message
+            );
+
+            // Add code snippet
+            if diag.location.line > 0 && diag.location.line <= lines.len() {
+                let line_index = diag.location.line - 1; // Convert to 0-indexed
+                let source_line = lines[line_index];
+
+                output.push('\n');
+                output.push_str("   ");
+                output.push_str(source_line);
+                output.push('\n');
+
+                // Add caret indicator
+                let column = diag.location.column.saturating_sub(1); // Convert to 0-indexed
+                output.push_str("   ");
+                output.push_str(&" ".repeat(column));
+                output.push('^');
+            }
+
+            output
+        })
+        .collect::<Vec<_>>()
+        .join("\n\n")
+}
+
+/// Read source file and format diagnostics with code snippet
+pub fn format_diagnostics_with_file(diagnostics: &[Diagnostic], file_path: &Path) -> String {
+    match fs::read_to_string(file_path) {
+        Ok(source) => format_diagnostics_with_source(diagnostics, &source),
+        Err(_) => format_diagnostics(diagnostics), // Fallback to simple format
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::diagnostics::diagnostic::{Diagnostic, Location};
+    use std::path::PathBuf;
+
+    #[test]
+    fn test_format_diagnostics() {
+        let diagnostics = vec![
+            Diagnostic::undefined_method(
+                Location {
+                    file: PathBuf::from("test.rb"),
+                    line: 10,
+                    column: 5,
+                    length: None,
+                },
+                "Integer",
+                "upcase",
+            ),
+            Diagnostic::union_partial_error(
+                Location {
+                    file: PathBuf::from("test.rb"),
+                    line: 15,
+                    column: 3,
+                    length: None,
+                },
+                vec!["String".to_string()],
+                vec!["Integer".to_string()],
+                "upcase",
+            ),
+        ];
+
+        let output = format_diagnostics(&diagnostics);
+        assert!(output.contains("test.rb:10:5: error:"));
+        assert!(output.contains("test.rb:15:3: warning:"));
+    }
+}

data/rust/src/diagnostics/mod.rs

@@ -0,0 +1,5 @@
+pub mod diagnostic;
+pub mod formatter;
+
+pub use diagnostic::{Diagnostic, DiagnosticLevel, Location};
+pub use formatter::format_diagnostics_with_file;

data/rust/src/env/box_manager.rs

@@ -0,0 +1,121 @@
+//! Box management and execution queue
+//!
+//! Handles registration and execution of Box instances (reactive computations).
+
+use crate::graph::{BoxId, BoxTrait};
+use std::collections::{HashMap, HashSet, VecDeque};
+
+/// Manages boxes and their execution queue
+#[allow(dead_code)]
+pub struct BoxManager {
+    /// All registered boxes
+    pub boxes: HashMap<BoxId, Box<dyn BoxTrait>>,
+    /// Queue of boxes to be executed
+    pub run_queue: VecDeque<BoxId>,
+    /// Set to prevent duplicate queue entries
+    run_queue_set: HashSet<BoxId>,
+    /// Next box ID to allocate
+    pub next_box_id: usize,
+}
+
+impl Default for BoxManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[allow(dead_code)]
+impl BoxManager {
+    /// Create a new empty box manager
+    pub fn new() -> Self {
+        Self {
+            boxes: HashMap::new(),
+            run_queue: VecDeque::new(),
+            run_queue_set: HashSet::new(),
+            next_box_id: 0,
+        }
+    }
+
+    /// Get a box by ID
+    pub fn get(&self, id: BoxId) -> Option<&Box<dyn BoxTrait>> {
+        self.boxes.get(&id)
+    }
+
+    /// Remove a box and return it (for temporary mutation)
+    pub fn remove(&mut self, id: BoxId) -> Option<Box<dyn BoxTrait>> {
+        self.boxes.remove(&id)
+    }
+
+    /// Insert a box back after temporary removal
+    pub fn insert(&mut self, id: BoxId, box_instance: Box<dyn BoxTrait>) {
+        self.boxes.insert(id, box_instance);
+    }
+
+    /// Check if a box exists
+    pub fn contains(&self, id: BoxId) -> bool {
+        self.boxes.contains_key(&id)
+    }
+
+    /// Add a box to the execution queue
+    pub fn add_run(&mut self, box_id: BoxId) {
+        if !self.run_queue_set.contains(&box_id) {
+            self.run_queue.push_back(box_id);
+            self.run_queue_set.insert(box_id);
+        }
+    }
+
+    /// Pop the next box from the queue
+    pub fn pop_run(&mut self) -> Option<BoxId> {
+        if let Some(box_id) = self.run_queue.pop_front() {
+            self.run_queue_set.remove(&box_id);
+            Some(box_id)
+        } else {
+            None
+        }
+    }
+
+    /// Check if the queue is empty
+    pub fn queue_is_empty(&self) -> bool {
+        self.run_queue.is_empty()
+    }
+
+    /// Get the number of registered boxes
+    pub fn len(&self) -> usize {
+        self.boxes.len()
+    }
+
+    /// Check if there are no registered boxes
+    pub fn is_empty(&self) -> bool {
+        self.boxes.is_empty()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_add_run_prevents_duplicates() {
+        let mut manager = BoxManager::new();
+
+        let id = BoxId(0);
+        manager.add_run(id);
+        manager.add_run(id); // Should be ignored
+
+        assert_eq!(manager.run_queue.len(), 1);
+    }
+
+    #[test]
+    fn test_pop_run() {
+        let mut manager = BoxManager::new();
+
+        let id1 = BoxId(0);
+        let id2 = BoxId(1);
+        manager.add_run(id1);
+        manager.add_run(id2);
+
+        assert_eq!(manager.pop_run(), Some(id1));
+        assert_eq!(manager.pop_run(), Some(id2));
+        assert_eq!(manager.pop_run(), None);
+    }
+}

data/rust/src/env/global_env.rs

@@ -0,0 +1,279 @@
+//! Global environment: facade for the type inference engine
+//!
+//! This module provides a unified interface for managing vertices, boxes,
+//! methods, type errors, and scopes during type inference.
+
+use crate::env::box_manager::BoxManager;
+use crate::env::method_registry::{MethodInfo, MethodRegistry};
+use crate::env::scope::{Scope, ScopeId, ScopeKind, ScopeManager};
+use crate::env::type_error::TypeError;
+use crate::env::vertex_manager::VertexManager;
+use crate::graph::{BoxId, BoxTrait, ChangeSet, EdgeUpdate, Source, Vertex, VertexId};
+use crate::source_map::SourceLocation;
+use crate::types::Type;
+
+/// Global environment: core of the type inference engine
+///
+/// This is a facade that coordinates the various subsystems:
+/// - Vertex management (type graph nodes)
+/// - Box management (reactive computations)
+/// - Method registry (method definitions)
+/// - Type errors (diagnostic collection)
+/// - Scope management (lexical scopes)
+pub struct GlobalEnv {
+    /// Vertex and source management
+    vertex_manager: VertexManager,
+
+    /// Box management and execution queue
+    box_manager: BoxManager,
+
+    /// Method definitions
+    method_registry: MethodRegistry,
+
+    /// Type errors collected during analysis
+    pub type_errors: Vec<TypeError>,
+
+    /// Scope management
+    pub scope_manager: ScopeManager,
+}
+
+#[allow(dead_code)]
+impl GlobalEnv {
+    pub fn new() -> Self {
+        Self {
+            vertex_manager: VertexManager::new(),
+            box_manager: BoxManager::new(),
+            method_registry: MethodRegistry::new(),
+            type_errors: Vec::new(),
+            scope_manager: ScopeManager::new(),
+        }
+    }
+
+    // ===== Vertex Management =====
+
+    /// Create new Vertex
+    pub fn new_vertex(&mut self) -> VertexId {
+        self.vertex_manager.new_vertex()
+    }
+
+    /// Create new Source (fixed type)
+    pub fn new_source(&mut self, ty: Type) -> VertexId {
+        self.vertex_manager.new_source(ty)
+    }
+
+    /// Get Vertex
+    pub fn get_vertex(&self, id: VertexId) -> Option<&Vertex> {
+        self.vertex_manager.get_vertex(id)
+    }
+
+    /// Get Source
+    pub fn get_source(&self, id: VertexId) -> Option<&Source> {
+        self.vertex_manager.get_source(id)
+    }
+
+    /// Add edge (immediate type propagation)
+    pub fn add_edge(&mut self, src: VertexId, dst: VertexId) {
+        self.vertex_manager.add_edge(src, dst);
+    }
+
+    /// For debugging: display types of all Vertices
+    pub fn show_all(&self) -> String {
+        self.vertex_manager.show_all()
+    }
+
+    // ===== Box Management =====
+
+    /// Allocate a new BoxId
+    pub fn alloc_box_id(&mut self) -> BoxId {
+        let id = BoxId(self.box_manager.next_box_id);
+        self.box_manager.next_box_id += 1;
+        id
+    }
+
+    /// Register a Box with a pre-allocated ID and add it to the run queue
+    pub fn register_box(&mut self, box_id: BoxId, box_instance: Box<dyn BoxTrait>) {
+        self.box_manager.insert(box_id, box_instance);
+        self.box_manager.add_run(box_id);
+    }
+
+    /// Get the number of registered boxes
+    pub fn box_count(&self) -> usize {
+        self.box_manager.len()
+    }
+
+    /// Apply changes
+    pub fn apply_changes(&mut self, mut changes: ChangeSet) {
+        let updates = changes.reinstall();
+
+        for update in updates {
+            match update {
+                EdgeUpdate::Add { src, dst } => {
+                    self.add_edge(src, dst);
+                }
+                EdgeUpdate::Remove { .. } => {
+                    // TODO: Implement edge removal (in Phase 2)
+                }
+            }
+        }
+    }
+
+    /// Execute all Boxes
+    pub fn run_all(&mut self) {
+        while let Some(box_id) = self.box_manager.pop_run() {
+            if self.box_manager.contains(box_id) {
+                let mut changes = ChangeSet::new();
+
+                // Execute Box (temporarily remove to avoid &mut self borrow issue)
+                let mut temp_box = self.box_manager.remove(box_id).unwrap();
+                temp_box.run(self, &mut changes);
+                self.box_manager.insert(box_id, temp_box);
+
+                self.apply_changes(changes);
+            }
+        }
+    }
+
+    // ===== Method Registry =====
+
+    /// Resolve method
+    pub fn resolve_method(&self, recv_ty: &Type, method_name: &str) -> Option<&MethodInfo> {
+        self.method_registry.resolve(recv_ty, method_name)
+    }
+
+    /// Register built-in method
+    pub fn register_builtin_method(&mut self, recv_ty: Type, method_name: &str, ret_ty: Type) {
+        self.method_registry.register(recv_ty, method_name, ret_ty);
+    }
+
+    // ===== Type Errors =====
+
+    /// Record a type error (undefined method)
+    pub fn record_type_error(
+        &mut self,
+        receiver_type: Type,
+        method_name: String,
+        location: Option<SourceLocation>,
+    ) {
+        self.type_errors
+            .push(TypeError::new(receiver_type, method_name, location));
+    }
+
+    // ===== Scope Management =====
+
+    /// Enter a class scope
+    pub fn enter_class(&mut self, name: String) -> ScopeId {
+        let scope_id = self.scope_manager.new_scope(ScopeKind::Class {
+            name,
+            superclass: None,
+        });
+        self.scope_manager.enter_scope(scope_id);
+        scope_id
+    }
+
+    /// Enter a method scope
+    pub fn enter_method(&mut self, name: String) -> ScopeId {
+        let class_name = self.scope_manager.current_class_name();
+        let scope_id = self.scope_manager.new_scope(ScopeKind::Method {
+            name,
+            receiver_type: class_name,
+        });
+        self.scope_manager.enter_scope(scope_id);
+        scope_id
+    }
+
+    /// Exit current scope
+    pub fn exit_scope(&mut self) {
+        self.scope_manager.exit_scope();
+    }
+
+    /// Get current scope
+    pub fn current_scope(&self) -> &Scope {
+        self.scope_manager.current_scope()
+    }
+
+    /// Get current scope mutably
+    pub fn current_scope_mut(&mut self) -> &mut Scope {
+        self.scope_manager.current_scope_mut()
+    }
+}
+
+impl Default for GlobalEnv {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_global_env_new_vertex() {
+        let mut genv = GlobalEnv::new();
+
+        let v1 = genv.new_vertex();
+        let v2 = genv.new_vertex();
+
+        assert_eq!(v1.0, 0);
+        assert_eq!(v2.0, 1);
+    }
+
+    #[test]
+    fn test_global_env_new_source() {
+        let mut genv = GlobalEnv::new();
+
+        let s1 = genv.new_source(Type::string());
+        let s2 = genv.new_source(Type::integer());
+
+        assert_eq!(genv.get_source(s1).unwrap().ty.show(), "String");
+        assert_eq!(genv.get_source(s2).unwrap().ty.show(), "Integer");
+    }
+
+    #[test]
+    fn test_global_env_edge_propagation() {
+        let mut genv = GlobalEnv::new();
+
+        // Source<String> -> Vertex
+        let src = genv.new_source(Type::string());
+        let vtx = genv.new_vertex();
+
+        genv.add_edge(src, vtx);
+
+        // Verify type propagated to Vertex
+        assert_eq!(genv.get_vertex(vtx).unwrap().show(), "String");
+    }
+
+    #[test]
+    fn test_global_env_chain_propagation() {
+        let mut genv = GlobalEnv::new();
+
+        // Source<String> -> Vertex1 -> Vertex2
+        let src = genv.new_source(Type::string());
+        let v1 = genv.new_vertex();
+        let v2 = genv.new_vertex();
+
+        genv.add_edge(src, v1);
+        genv.add_edge(v1, v2);
+
+        // Verify type propagated to v2
+        assert_eq!(genv.get_vertex(v1).unwrap().show(), "String");
+        assert_eq!(genv.get_vertex(v2).unwrap().show(), "String");
+    }
+
+    #[test]
+    fn test_global_env_union_propagation() {
+        let mut genv = GlobalEnv::new();
+
+        // Source<String> -> Vertex
+        // Source<Integer> -> Vertex
+        let src1 = genv.new_source(Type::string());
+        let src2 = genv.new_source(Type::integer());
+        let vtx = genv.new_vertex();
+
+        genv.add_edge(src1, vtx);
+        genv.add_edge(src2, vtx);
+
+        // Verify it became Union type
+        assert_eq!(genv.get_vertex(vtx).unwrap().show(), "(Integer | String)");
+    }
+}

data/rust/src/env/local_env.rs

@@ -0,0 +1,58 @@
+use crate::graph::VertexId;
+use std::collections::HashMap;
+
+/// Local environment: mapping of local variable names to VertexIDs
+pub struct LocalEnv {
+    locals: HashMap<String, VertexId>,
+}
+
+#[allow(dead_code)]
+impl LocalEnv {
+    pub fn new() -> Self {
+        Self {
+            locals: HashMap::new(),
+        }
+    }
+
+    /// Register variable
+    pub fn new_var(&mut self, name: String, vtx_id: VertexId) {
+        self.locals.insert(name, vtx_id);
+    }
+
+    /// Get variable
+    pub fn get_var(&self, name: &str) -> Option<VertexId> {
+        self.locals.get(name).copied()
+    }
+
+    /// Get all variables
+    pub fn all_vars(&self) -> impl Iterator<Item = (&String, &VertexId)> {
+        self.locals.iter()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_local_env() {
+        let mut lenv = LocalEnv::new();
+
+        lenv.new_var("x".to_string(), VertexId(1));
+        lenv.new_var("y".to_string(), VertexId(2));
+
+        assert_eq!(lenv.get_var("x"), Some(VertexId(1)));
+        assert_eq!(lenv.get_var("y"), Some(VertexId(2)));
+        assert_eq!(lenv.get_var("z"), None);
+    }
+
+    #[test]
+    fn test_local_env_override() {
+        let mut lenv = LocalEnv::new();
+
+        lenv.new_var("x".to_string(), VertexId(1));
+        lenv.new_var("x".to_string(), VertexId(2)); // Override
+
+        assert_eq!(lenv.get_var("x"), Some(VertexId(2)));
+    }
+}

data/rust/src/env/method_registry.rs

@@ -0,0 +1,63 @@
+//! Method registration and resolution
+
+use crate::types::Type;
+use std::collections::HashMap;
+
+/// Method information
+#[derive(Debug, Clone)]
+pub struct MethodInfo {
+    pub return_type: Type,
+}
+
+/// Registry for method definitions
+#[derive(Debug, Default)]
+pub struct MethodRegistry {
+    methods: HashMap<(Type, String), MethodInfo>,
+}
+
+impl MethodRegistry {
+    /// Create a new empty registry
+    pub fn new() -> Self {
+        Self {
+            methods: HashMap::new(),
+        }
+    }
+
+    /// Register a method for a receiver type
+    pub fn register(&mut self, recv_ty: Type, method_name: &str, ret_ty: Type) {
+        self.methods.insert(
+            (recv_ty, method_name.to_string()),
+            MethodInfo {
+                return_type: ret_ty,
+            },
+        );
+    }
+
+    /// Resolve a method for a receiver type
+    pub fn resolve(&self, recv_ty: &Type, method_name: &str) -> Option<&MethodInfo> {
+        self.methods
+            .get(&(recv_ty.clone(), method_name.to_string()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_register_and_resolve() {
+        let mut registry = MethodRegistry::new();
+        registry.register(Type::string(), "length", Type::integer());
+
+        let info = registry.resolve(&Type::string(), "length").unwrap();
+        assert!(
+            matches!(info.return_type, Type::Instance { ref class_name, .. } if class_name == "Integer")
+        );
+    }
+
+    #[test]
+    fn test_resolve_not_found() {
+        let registry = MethodRegistry::new();
+        assert!(registry.resolve(&Type::string(), "unknown").is_none());
+    }
+}

data/rust/src/env/mod.rs

@@ -0,0 +1,15 @@
+//! Environment management for type inference
+//!
+//! This module provides the core data structures for managing
+//! type inference state including global and local environments.
+
+pub mod box_manager;
+pub mod global_env;
+pub mod local_env;
+pub mod method_registry;
+pub mod scope;
+pub mod type_error;
+pub mod vertex_manager;
+
+pub use global_env::GlobalEnv;
+pub use local_env::LocalEnv;