method-ray 0.1.7 → 0.1.9

data/{rust → core}/src/env/global_env.rs

@@ -3,6 +3,8 @@
 //! This module provides a unified interface for managing vertices, boxes,
 //! methods, type errors, and scopes during type inference.
 
+use std::collections::HashMap;
+
 use crate::env::box_manager::BoxManager;
 use crate::env::method_registry::{MethodInfo, MethodRegistry};
 use crate::env::scope::{Scope, ScopeId, ScopeKind, ScopeManager};
@@ -35,9 +37,12 @@ pub struct GlobalEnv {
 
     /// Scope management
     pub scope_manager: ScopeManager,
+
+    /// Module inclusions: class_name → Vec<module_name> (in include order)
+    module_inclusions: HashMap<String, Vec<String>>,
+
 }
 
-#[allow(dead_code)]
 impl GlobalEnv {
     pub fn new() -> Self {
         Self {
@@ -46,6 +51,7 @@ impl GlobalEnv {
             method_registry: MethodRegistry::new(),
             type_errors: Vec::new(),
             scope_manager: ScopeManager::new(),
+            module_inclusions: HashMap::new(),
         }
     }
 
@@ -157,7 +163,16 @@ impl GlobalEnv {
 
     /// Resolve method
     pub fn resolve_method(&self, recv_ty: &Type, method_name: &str) -> Option<&MethodInfo> {
-        self.method_registry.resolve(recv_ty, method_name)
+        self.method_registry
+            .resolve(recv_ty, method_name, &self.module_inclusions)
+    }
+
+    /// Record that a class includes a module
+    pub fn record_include(&mut self, class_name: &str, module_name: &str) {
+        self.module_inclusions
+            .entry(class_name.to_string())
+            .or_default()
+            .push(module_name.to_string());
     }
 
     /// Register built-in method
@@ -184,9 +199,15 @@ impl GlobalEnv {
         method_name: &str,
         return_vertex: VertexId,
         param_vertices: Vec<VertexId>,
+        keyword_param_vertices: Option<HashMap<String, VertexId>>,
     ) {
-        self.method_registry
-            .register_user_method(recv_ty, method_name, return_vertex, param_vertices);
+        self.method_registry.register_user_method(
+            recv_ty,
+            method_name,
+            return_vertex,
+            param_vertices,
+            keyword_param_vertices,
+        );
     }
 
     // ===== Type Errors =====
@@ -218,11 +239,11 @@ impl GlobalEnv {
         }
     }
 
-    /// Enter a class scope
-    pub fn enter_class(&mut self, name: String) -> ScopeId {
+    /// Enter a class scope with optional superclass
+    pub fn enter_class(&mut self, name: String, superclass: Option<&str>) -> ScopeId {
         let scope_id = self.scope_manager.new_scope(ScopeKind::Class {
             name: name.clone(),
-            superclass: None,
+            superclass: superclass.map(|s| s.to_string()),
         });
         self.scope_manager.enter_scope(scope_id);
         self.register_constant_in_parent(scope_id, &name);

data/{rust → core}/src/env/local_env.rs

@@ -6,7 +6,12 @@ pub struct LocalEnv {
     locals: HashMap<String, VertexId>,
 }
 
-#[allow(dead_code)]
+impl Default for LocalEnv {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl LocalEnv {
     pub fn new() -> Self {
         Self {
@@ -24,6 +29,12 @@ impl LocalEnv {
         self.locals.get(name).copied()
     }
 
+    /// Remove a variable from the local environment.
+    /// Used for scoped variables like rescue's `=> e` binding.
+    pub fn remove_var(&mut self, name: &str) {
+        self.locals.remove(name);
+    }
+
     /// Get all variables
     pub fn all_vars(&self) -> impl Iterator<Item = (&String, &VertexId)> {
         self.locals.iter()
@@ -34,6 +45,12 @@ impl LocalEnv {
 mod tests {
     use super::*;
 
+    #[test]
+    fn test_local_env_default() {
+        let lenv = LocalEnv::default();
+        assert_eq!(lenv.get_var("x"), None);
+    }
+
     #[test]
     fn test_local_env() {
         let mut lenv = LocalEnv::new();
@@ -46,6 +63,23 @@ mod tests {
         assert_eq!(lenv.get_var("z"), None);
     }
 
+    #[test]
+    fn test_local_env_remove_var() {
+        let mut lenv = LocalEnv::new();
+
+        lenv.new_var("e".to_string(), VertexId(1));
+        assert_eq!(lenv.get_var("e"), Some(VertexId(1)));
+
+        lenv.remove_var("e");
+        assert_eq!(lenv.get_var("e"), None);
+    }
+
+    #[test]
+    fn test_local_env_remove_nonexistent() {
+        let mut lenv = LocalEnv::new();
+        lenv.remove_var("x"); // should not panic
+    }
+
     #[test]
     fn test_local_env_override() {
         let mut lenv = LocalEnv::new();

data/{rust → core}/src/env/method_registry.rs

@@ -1,9 +1,10 @@
 //! Method registration and resolution
 
+use std::collections::HashMap;
+
 use crate::graph::VertexId;
 use crate::types::Type;
 use smallvec::SmallVec;
-use std::collections::HashMap;
 
 const OBJECT_CLASS: &str = "Object";
 const KERNEL_MODULE: &str = "Kernel";
@@ -15,6 +16,7 @@ pub struct MethodInfo {
     pub block_param_types: Option<Vec<Type>>,
     pub return_vertex: Option<VertexId>,
     pub param_vertices: Option<Vec<VertexId>>,
+    pub keyword_param_vertices: Option<HashMap<String, VertexId>>,
 }
 
 /// Registry for method definitions
@@ -51,6 +53,7 @@ impl MethodRegistry {
                 block_param_types,
                 return_vertex: None,
                 param_vertices: None,
+                keyword_param_vertices: None,
             },
         );
     }
@@ -62,6 +65,7 @@ impl MethodRegistry {
         method_name: &str,
         return_vertex: VertexId,
         param_vertices: Vec<VertexId>,
+        keyword_param_vertices: Option<HashMap<String, VertexId>>,
     ) {
         self.methods.insert(
             (recv_ty, method_name.to_string()),
@@ -70,6 +74,7 @@ impl MethodRegistry {
                 block_param_types: None,
                 return_vertex: Some(return_vertex),
                 param_vertices: Some(param_vertices),
+                keyword_param_vertices,
             },
         );
     }
@@ -79,9 +84,13 @@ impl MethodRegistry {
     /// Returns a list of types to search in order:
     /// 1. Exact receiver type
     /// 2. Generic → base class (e.g., Array[Integer] → Array)
-    /// 3. Object (for Instance/Generic types only)
-    /// 4. Kernel (for Instance/Generic types only)
-    fn fallback_chain(recv_ty: &Type) -> SmallVec<[Type; 4]> {
+    /// 3. Included modules (last included first, matching Ruby MRO)
+    /// 4. Object (for Instance/Generic types only)
+    /// 5. Kernel (for Instance/Generic types only)
+    fn fallback_chain(
+        recv_ty: &Type,
+        inclusions: &HashMap<String, Vec<String>>,
+    ) -> SmallVec<[Type; 8]> {
         let mut chain = SmallVec::new();
         chain.push(recv_ty.clone());
 
@@ -89,9 +98,17 @@ impl MethodRegistry {
             chain.push(Type::Instance { name: name.clone() });
         }
 
-        // NOTE: Kernel is a module, not a class. Represented as Type::Instance
-        // due to lack of Type::Module variant.
+        // MRO for Instance/Generic: included modules → Object → Kernel
         if matches!(recv_ty, Type::Instance { .. } | Type::Generic { .. }) {
+            // Included modules (reverse order = last included has highest priority)
+            if let Some(class_name) = recv_ty.base_class_name() {
+                if let Some(modules) = inclusions.get(class_name) {
+                    for module_name in modules.iter().rev() {
+                        chain.push(Type::instance(module_name));
+                    }
+                }
+            }
+
             chain.push(Type::instance(OBJECT_CLASS));
             chain.push(Type::instance(KERNEL_MODULE));
         }
@@ -101,11 +118,17 @@ impl MethodRegistry {
 
     /// Resolve a method for a receiver type
     ///
-    /// Searches the MRO fallback chain: exact type → base class (for generics) → Object → Kernel.
+    /// Searches the MRO fallback chain: exact type → base class (for generics)
+    /// → included modules → Object → Kernel.
     /// For non-instance types (Singleton, Nil, Union, Bot), only exact match is attempted.
-    pub fn resolve(&self, recv_ty: &Type, method_name: &str) -> Option<&MethodInfo> {
+    pub fn resolve(
+        &self,
+        recv_ty: &Type,
+        method_name: &str,
+        inclusions: &HashMap<String, Vec<String>>,
+    ) -> Option<&MethodInfo> {
         let method_key = method_name.to_string();
-        Self::fallback_chain(recv_ty)
+        Self::fallback_chain(recv_ty, inclusions)
             .into_iter()
             .find_map(|ty| self.methods.get(&(ty, method_key.clone())))
     }
@@ -120,23 +143,23 @@ mod tests {
         let mut registry = MethodRegistry::new();
         registry.register(Type::string(), "length", Type::integer());
 
-        let info = registry.resolve(&Type::string(), "length").unwrap();
+        let info = registry.resolve(&Type::string(), "length", &HashMap::new()).unwrap();
         assert_eq!(info.return_type.base_class_name(), Some("Integer"));
     }
 
     #[test]
     fn test_resolve_not_found() {
         let registry = MethodRegistry::new();
-        assert!(registry.resolve(&Type::string(), "unknown").is_none());
+        assert!(registry.resolve(&Type::string(), "unknown", &HashMap::new()).is_none());
     }
 
     #[test]
     fn test_register_user_method_and_resolve() {
         let mut registry = MethodRegistry::new();
         let return_vtx = VertexId(42);
-        registry.register_user_method(Type::instance("User"), "name", return_vtx, vec![]);
+        registry.register_user_method(Type::instance("User"), "name", return_vtx, vec![], None);
 
-        let info = registry.resolve(&Type::instance("User"), "name").unwrap();
+        let info = registry.resolve(&Type::instance("User"), "name", &HashMap::new()).unwrap();
         assert_eq!(info.return_vertex, Some(VertexId(42)));
         assert_eq!(info.return_type, Type::Bot);
     }
@@ -151,9 +174,10 @@ mod tests {
             "add",
             return_vtx,
             param_vtxs,
+            None,
         );
 
-        let info = registry.resolve(&Type::instance("Calc"), "add").unwrap();
+        let info = registry.resolve(&Type::instance("Calc"), "add", &HashMap::new()).unwrap();
         assert_eq!(info.return_vertex, Some(VertexId(10)));
         let pvs = info.param_vertices.as_ref().unwrap();
         assert_eq!(pvs.len(), 2);
@@ -167,7 +191,7 @@ mod tests {
     fn test_resolve_falls_back_to_object() {
         let mut registry = MethodRegistry::new();
         registry.register(Type::instance("Object"), "nil?", Type::instance("TrueClass"));
-        let info = registry.resolve(&Type::instance("CustomClass"), "nil?").unwrap();
+        let info = registry.resolve(&Type::instance("CustomClass"), "nil?", &HashMap::new()).unwrap();
         assert_eq!(info.return_type.base_class_name(), Some("TrueClass"));
     }
 
@@ -175,7 +199,7 @@ mod tests {
     fn test_resolve_falls_back_to_kernel() {
         let mut registry = MethodRegistry::new();
         registry.register(Type::instance("Kernel"), "puts", Type::Nil);
-        let info = registry.resolve(&Type::instance("MyApp"), "puts").unwrap();
+        let info = registry.resolve(&Type::instance("MyApp"), "puts", &HashMap::new()).unwrap();
         assert_eq!(info.return_type, Type::Nil);
     }
 
@@ -184,7 +208,7 @@ mod tests {
         let mut registry = MethodRegistry::new();
         registry.register(Type::instance("Object"), "to_s", Type::string());
         registry.register(Type::instance("Kernel"), "to_s", Type::integer());
-        let info = registry.resolve(&Type::instance("Anything"), "to_s").unwrap();
+        let info = registry.resolve(&Type::instance("Anything"), "to_s", &HashMap::new()).unwrap();
         assert_eq!(info.return_type.base_class_name(), Some("String"));
     }
 
@@ -193,7 +217,7 @@ mod tests {
         let mut registry = MethodRegistry::new();
         registry.register(Type::string(), "length", Type::integer());
         registry.register(Type::instance("Object"), "length", Type::string());
-        let info = registry.resolve(&Type::string(), "length").unwrap();
+        let info = registry.resolve(&Type::string(), "length", &HashMap::new()).unwrap();
         assert_eq!(info.return_type.base_class_name(), Some("Integer"));
     }
 
@@ -203,14 +227,14 @@ mod tests {
     fn test_singleton_type_skips_fallback() {
         let mut registry = MethodRegistry::new();
         registry.register(Type::instance("Kernel"), "puts", Type::Nil);
-        assert!(registry.resolve(&Type::singleton("User"), "puts").is_none());
+        assert!(registry.resolve(&Type::singleton("User"), "puts", &HashMap::new()).is_none());
     }
 
     #[test]
     fn test_nil_type_skips_fallback() {
         let mut registry = MethodRegistry::new();
         registry.register(Type::instance("Kernel"), "puts", Type::Nil);
-        assert!(registry.resolve(&Type::Nil, "puts").is_none());
+        assert!(registry.resolve(&Type::Nil, "puts", &HashMap::new()).is_none());
     }
 
     #[test]
@@ -218,14 +242,14 @@ mod tests {
         let mut registry = MethodRegistry::new();
         registry.register(Type::instance("Kernel"), "puts", Type::Nil);
         let union_ty = Type::Union(vec![Type::string(), Type::integer()]);
-        assert!(registry.resolve(&union_ty, "puts").is_none());
+        assert!(registry.resolve(&union_ty, "puts", &HashMap::new()).is_none());
     }
 
     #[test]
     fn test_bot_type_skips_fallback() {
         let mut registry = MethodRegistry::new();
         registry.register(Type::instance("Kernel"), "puts", Type::Nil);
-        assert!(registry.resolve(&Type::Bot, "puts").is_none());
+        assert!(registry.resolve(&Type::Bot, "puts", &HashMap::new()).is_none());
     }
 
     // --- Generic type fallback chain ---
@@ -235,7 +259,7 @@ mod tests {
         let mut registry = MethodRegistry::new();
         registry.register(Type::instance("Kernel"), "puts", Type::Nil);
         let generic_type = Type::array_of(Type::integer());
-        let info = registry.resolve(&generic_type, "puts").unwrap();
+        let info = registry.resolve(&generic_type, "puts", &HashMap::new()).unwrap();
         assert_eq!(info.return_type, Type::Nil);
     }
 
@@ -246,7 +270,7 @@ mod tests {
         registry.register(Type::instance("Kernel"), "object_id", Type::integer());
         let generic_type = Type::array_of(Type::string());
         // Array[String] → Array (none) → Object (none) → Kernel (exists)
-        let info = registry.resolve(&generic_type, "object_id").unwrap();
+        let info = registry.resolve(&generic_type, "object_id", &HashMap::new()).unwrap();
         assert_eq!(info.return_type.base_class_name(), Some("Integer"));
     }
 
@@ -256,7 +280,75 @@ mod tests {
     fn test_resolve_namespaced_class_falls_back_to_object() {
         let mut registry = MethodRegistry::new();
         registry.register(Type::instance("Object"), "class", Type::string());
-        let info = registry.resolve(&Type::instance("Api::V1::User"), "class").unwrap();
+        let info = registry.resolve(&Type::instance("Api::V1::User"), "class", &HashMap::new()).unwrap();
+        assert_eq!(info.return_type.base_class_name(), Some("String"));
+    }
+
+    // --- Include (mixin) fallback ---
+
+    #[test]
+    fn test_resolve_with_include() {
+        let mut registry = MethodRegistry::new();
+        registry.register(Type::instance("Greetable"), "greet", Type::string());
+
+        let mut inclusions = HashMap::new();
+        inclusions.insert("User".to_string(), vec!["Greetable".to_string()]);
+
+        let info = registry.resolve(&Type::instance("User"), "greet", &inclusions).unwrap();
         assert_eq!(info.return_type.base_class_name(), Some("String"));
     }
+
+    #[test]
+    fn test_resolve_include_order() {
+        // include A; include B → B's method found first (MRO: last included wins)
+        let mut registry = MethodRegistry::new();
+        registry.register(Type::instance("A"), "foo", Type::string());
+        registry.register(Type::instance("B"), "foo", Type::integer());
+
+        let mut inclusions = HashMap::new();
+        inclusions.insert("User".to_string(), vec!["A".to_string(), "B".to_string()]);
+
+        let info = registry.resolve(&Type::instance("User"), "foo", &inclusions).unwrap();
+        assert_eq!(info.return_type.base_class_name(), Some("Integer"));
+    }
+
+    #[test]
+    fn test_resolve_class_method_over_include() {
+        // Class's own method takes priority over included module
+        let mut registry = MethodRegistry::new();
+        registry.register(Type::instance("Greetable"), "greet", Type::string());
+        registry.register(Type::instance("User"), "greet", Type::integer());
+
+        let mut inclusions = HashMap::new();
+        inclusions.insert("User".to_string(), vec!["Greetable".to_string()]);
+
+        let info = registry.resolve(&Type::instance("User"), "greet", &inclusions).unwrap();
+        assert_eq!(info.return_type.base_class_name(), Some("Integer"));
+    }
+
+    #[test]
+    fn test_resolve_include_before_object() {
+        // Included module is searched before Object in MRO
+        let mut registry = MethodRegistry::new();
+        registry.register(Type::instance("Object"), "foo", Type::string());
+        registry.register(Type::instance("MyModule"), "foo", Type::integer());
+
+        let mut inclusions = HashMap::new();
+        inclusions.insert("User".to_string(), vec!["MyModule".to_string()]);
+
+        let info = registry.resolve(&Type::instance("User"), "foo", &inclusions).unwrap();
+        assert_eq!(info.return_type.base_class_name(), Some("Integer"));
+    }
+
+    #[test]
+    fn test_singleton_type_skips_include_fallback() {
+        // include adds instance methods only — Singleton (class-level) should NOT resolve
+        let mut registry = MethodRegistry::new();
+        registry.register(Type::instance("Greetable"), "greet", Type::string());
+
+        let mut inclusions = HashMap::new();
+        inclusions.insert("User".to_string(), vec!["Greetable".to_string()]);
+
+        assert!(registry.resolve(&Type::singleton("User"), "greet", &inclusions).is_none());
+    }
 }

data/{rust → core}/src/env/scope.rs

@@ -7,7 +7,6 @@ pub struct ScopeId(pub usize);
 
 /// Scope kind
 #[derive(Debug, Clone)]
-#[allow(dead_code)]
 pub enum ScopeKind {
     TopLevel,
     Class {
@@ -27,7 +26,6 @@ pub enum ScopeKind {
 
 /// Scope information
 #[derive(Debug, Clone)]
-#[allow(dead_code)]
 pub struct Scope {
     pub id: ScopeId,
     pub kind: ScopeKind,
@@ -46,7 +44,6 @@ pub struct Scope {
     pub constants: HashMap<String, String>,
 }
 
-#[allow(dead_code)]
 impl Scope {
     pub fn new(id: ScopeId, kind: ScopeKind, parent: Option<ScopeId>) -> Self {
         Self {
@@ -89,7 +86,12 @@ pub struct ScopeManager {
     current_scope: ScopeId,
 }
 
-#[allow(dead_code)]
+impl Default for ScopeManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl ScopeManager {
     pub fn new() -> Self {
         let top_level = Scope::new(ScopeId(0), ScopeKind::TopLevel, None);
@@ -243,6 +245,28 @@ impl ScopeManager {
         Some(path_segments.join("::"))
     }
 
+    /// Get current method name from nearest enclosing method scope
+    pub fn current_method_name(&self) -> Option<String> {
+        self.walk_scopes().find_map(|scope| {
+            if let ScopeKind::Method { name, .. } = &scope.kind {
+                Some(name.clone())
+            } else {
+                None
+            }
+        })
+    }
+
+    /// Get superclass name from nearest enclosing class scope
+    pub fn current_superclass(&self) -> Option<String> {
+        self.walk_scopes().find_map(|scope| {
+            if let ScopeKind::Class { superclass, .. } = &scope.kind {
+                superclass.clone()
+            } else {
+                None
+            }
+        })
+    }
+
     /// Get return_vertex from the nearest enclosing method scope
     pub fn current_method_return_vertex(&self) -> Option<VertexId> {
         self.walk_scopes().find_map(|scope| {
@@ -278,6 +302,13 @@ impl ScopeManager {
 mod tests {
     use super::*;
 
+    #[test]
+    fn test_scope_manager_default() {
+        let sm = ScopeManager::default();
+        assert_eq!(sm.current_scope().id, ScopeId(0));
+        assert!(matches!(sm.current_scope().kind, ScopeKind::TopLevel));
+    }
+
     #[test]
     fn test_scope_manager_creation() {
         let sm = ScopeManager::new();
@@ -584,4 +615,60 @@ mod tests {
         // Inside Admin scope, User should resolve to Admin::User
         assert_eq!(sm.lookup_constant("User"), Some("Admin::User".to_string()));
     }
+
+    #[test]
+    fn test_current_method_name() {
+        let mut sm = ScopeManager::new();
+        let class_id = sm.new_scope(ScopeKind::Class {
+            name: "User".to_string(),
+            superclass: None,
+        });
+        sm.enter_scope(class_id);
+        let method_id = sm.new_scope(ScopeKind::Method {
+            name: "greet".to_string(),
+            receiver_type: None,
+            return_vertex: None,
+        });
+        sm.enter_scope(method_id);
+        assert_eq!(sm.current_method_name(), Some("greet".to_string()));
+
+        sm.exit_scope();
+        assert_eq!(sm.current_method_name(), None);
+    }
+
+    #[test]
+    fn test_current_superclass() {
+        let mut sm = ScopeManager::new();
+        let class_id = sm.new_scope(ScopeKind::Class {
+            name: "Dog".to_string(),
+            superclass: Some("Animal".to_string()),
+        });
+        sm.enter_scope(class_id);
+        assert_eq!(sm.current_superclass(), Some("Animal".to_string()));
+
+        sm.exit_scope();
+        assert_eq!(sm.current_superclass(), None);
+    }
+
+    #[test]
+    fn test_current_method_name_from_nested_block() {
+        let mut sm = ScopeManager::new();
+        let class_id = sm.new_scope(ScopeKind::Class {
+            name: "User".to_string(),
+            superclass: Some("Base".to_string()),
+        });
+        sm.enter_scope(class_id);
+        let method_id = sm.new_scope(ScopeKind::Method {
+            name: "process".to_string(),
+            receiver_type: None,
+            return_vertex: None,
+        });
+        sm.enter_scope(method_id);
+        let block_id = sm.new_scope(ScopeKind::Block);
+        sm.enter_scope(block_id);
+
+        // Inside a block, should still find enclosing method/superclass
+        assert_eq!(sm.current_method_name(), Some("process".to_string()));
+        assert_eq!(sm.current_superclass(), Some("Base".to_string()));
+    }
 }

data/{rust → core}/src/env/vertex_manager.rs

@@ -17,7 +17,6 @@ pub struct VertexManager {
     next_vertex_id: usize,
 }
 
-#[allow(dead_code)]
 impl VertexManager {
     /// Create a new empty vertex manager
     pub fn new() -> Self {