method-ray 0.1.6 → 0.1.8

data/rust/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};
@@ -37,7 +39,6 @@ pub struct GlobalEnv {
     pub scope_manager: ScopeManager,
 }
 
-#[allow(dead_code)]
 impl GlobalEnv {
     pub fn new() -> Self {
         Self {
@@ -71,6 +72,21 @@ impl GlobalEnv {
         self.vertex_manager.get_source(id)
     }
 
+    /// Get the types associated with a vertex ID (handles both Vertex and Source)
+    ///
+    /// Returns `None` if neither a Vertex nor Source exists for this ID.
+    /// Returns `Some(vec![])` if a Vertex exists but has no types yet (e.g., unresolved block parameters).
+    /// Returns `Some(vec![ty])` if a Source exists (always exactly one type).
+    pub fn get_receiver_types(&self, id: VertexId) -> Option<Vec<Type>> {
+        if let Some(vertex) = self.get_vertex(id) {
+            Some(vertex.types.keys().cloned().collect())
+        } else if let Some(source) = self.get_source(id) {
+            Some(vec![source.ty.clone()])
+        } else {
+            None
+        }
+    }
+
     /// Add edge (immediate type propagation)
     pub fn add_edge(&mut self, src: VertexId, dst: VertexId) {
         self.vertex_manager.add_edge(src, dst);
@@ -169,9 +185,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 =====
@@ -189,20 +211,36 @@ impl GlobalEnv {
 
     // ===== Scope Management =====
 
+    /// Register a constant (simple name → qualified name) in the parent scope
+    fn register_constant_in_parent(&mut self, scope_id: ScopeId, name: &str) {
+        if name.contains("::") { return; }
+        let qualified = self.scope_manager.current_qualified_name()
+            .unwrap_or_else(|| name.to_string());
+        if let Some(parent_id) = self.scope_manager.get_scope(scope_id)
+            .and_then(|s| s.parent)
+        {
+            if let Some(parent_scope) = self.scope_manager.get_scope_mut(parent_id) {
+                parent_scope.constants.insert(name.to_string(), qualified);
+            }
+        }
+    }
+
     /// Enter a class scope
     pub fn enter_class(&mut self, name: String) -> ScopeId {
         let scope_id = self.scope_manager.new_scope(ScopeKind::Class {
-            name,
+            name: name.clone(),
             superclass: None,
         });
         self.scope_manager.enter_scope(scope_id);
+        self.register_constant_in_parent(scope_id, &name);
         scope_id
     }
 
     /// Enter a module scope
     pub fn enter_module(&mut self, name: String) -> ScopeId {
-        let scope_id = self.scope_manager.new_scope(ScopeKind::Module { name });
+        let scope_id = self.scope_manager.new_scope(ScopeKind::Module { name: name.clone() });
         self.scope_manager.enter_scope(scope_id);
+        self.register_constant_in_parent(scope_id, &name);
         scope_id
     }
 

data/rust/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/src/env/method_registry.rs

@@ -1,8 +1,13 @@
 //! Method registration and resolution
 
+use std::collections::HashMap;
+
 use crate::graph::VertexId;
 use crate::types::Type;
-use std::collections::HashMap;
+use smallvec::SmallVec;
+
+const OBJECT_CLASS: &str = "Object";
+const KERNEL_MODULE: &str = "Kernel";
 
 /// Method information
 #[derive(Debug, Clone)]
@@ -11,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
@@ -47,6 +53,7 @@ impl MethodRegistry {
                 block_param_types,
                 return_vertex: None,
                 param_vertices: None,
+                keyword_param_vertices: None,
             },
         );
     }
@@ -58,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()),
@@ -66,30 +74,45 @@ impl MethodRegistry {
                 block_param_types: None,
                 return_vertex: Some(return_vertex),
                 param_vertices: Some(param_vertices),
+                keyword_param_vertices,
             },
         );
     }
 
-    /// Resolve a method for a receiver type
+    /// Build the method resolution order (MRO) fallback chain for a receiver type.
     ///
-    /// For generic types like `Array[Integer]`, first tries exact match,
-    /// then falls back to base class match (`Array`).
-    pub fn resolve(&self, recv_ty: &Type, method_name: &str) -> Option<&MethodInfo> {
-        // First, try exact match
-        if let Some(info) = self
-            .methods
-            .get(&(recv_ty.clone(), method_name.to_string()))
-        {
-            return Some(info);
-        }
+    /// 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]> {
+        let mut chain = SmallVec::new();
+        chain.push(recv_ty.clone());
 
-        // For generic types, fall back to base class
         if let Type::Generic { name, .. } = recv_ty {
-            let base_type = Type::Instance { name: name.clone() };
-            return self.methods.get(&(base_type, method_name.to_string()));
+            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.
+        if matches!(recv_ty, Type::Instance { .. } | Type::Generic { .. }) {
+            chain.push(Type::instance(OBJECT_CLASS));
+            chain.push(Type::instance(KERNEL_MODULE));
         }
 
-        None
+        chain
+    }
+
+    /// Resolve a method for a receiver type
+    ///
+    /// Searches the MRO fallback chain: exact type → base class (for generics) → 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> {
+        let method_key = method_name.to_string();
+        Self::fallback_chain(recv_ty)
+            .into_iter()
+            .find_map(|ty| self.methods.get(&(ty, method_key.clone())))
     }
 }
 
@@ -116,7 +139,7 @@ mod tests {
     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();
         assert_eq!(info.return_vertex, Some(VertexId(42)));
@@ -133,6 +156,7 @@ mod tests {
             "add",
             return_vtx,
             param_vtxs,
+            None,
         );
 
         let info = registry.resolve(&Type::instance("Calc"), "add").unwrap();
@@ -142,4 +166,103 @@ mod tests {
         assert_eq!(pvs[0], VertexId(20));
         assert_eq!(pvs[1], VertexId(21));
     }
+
+    // --- Object/Kernel fallback ---
+
+    #[test]
+    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();
+        assert_eq!(info.return_type.base_class_name(), Some("TrueClass"));
+    }
+
+    #[test]
+    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();
+        assert_eq!(info.return_type, Type::Nil);
+    }
+
+    #[test]
+    fn test_resolve_object_before_kernel() {
+        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();
+        assert_eq!(info.return_type.base_class_name(), Some("String"));
+    }
+
+    #[test]
+    fn test_resolve_exact_match_over_fallback() {
+        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();
+        assert_eq!(info.return_type.base_class_name(), Some("Integer"));
+    }
+
+    // --- Types that skip fallback ---
+
+    #[test]
+    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());
+    }
+
+    #[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());
+    }
+
+    #[test]
+    fn test_union_type_skips_fallback() {
+        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());
+    }
+
+    #[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());
+    }
+
+    // --- Generic type fallback chain ---
+
+    #[test]
+    fn test_resolve_generic_falls_back_to_kernel() {
+        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();
+        assert_eq!(info.return_type, Type::Nil);
+    }
+
+    #[test]
+    fn test_resolve_generic_full_chain() {
+        // Verify the 4-step fallback: Generic[T] → Base → Object → Kernel
+        let mut registry = MethodRegistry::new();
+        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();
+        assert_eq!(info.return_type.base_class_name(), Some("Integer"));
+    }
+
+    // --- Namespaced class fallback ---
+
+    #[test]
+    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();
+        assert_eq!(info.return_type.base_class_name(), Some("String"));
+    }
 }