method-ray 0.1.9 → 0.1.10

data/core/src/env/global_env.rs

@@ -6,7 +6,7 @@
 use std::collections::HashMap;
 
 use crate::env::box_manager::BoxManager;
-use crate::env::method_registry::{MethodInfo, MethodRegistry};
+use crate::env::method_registry::{MethodInfo, MethodRegistry, ResolutionContext};
 use crate::env::scope::{Scope, ScopeId, ScopeKind, ScopeManager};
 use crate::env::type_error::TypeError;
 use crate::env::vertex_manager::VertexManager;
@@ -41,6 +41,11 @@ pub struct GlobalEnv {
     /// Module inclusions: class_name → Vec<module_name> (in include order)
     module_inclusions: HashMap<String, Vec<String>>,
 
+    /// Superclass map: child_class → parent_class
+    superclass_map: HashMap<String, String>,
+
+    /// Module extensions: class_name → Vec<module_name> (in extend order)
+    module_extensions: HashMap<String, Vec<String>>,
 }
 
 impl GlobalEnv {
@@ -52,6 +57,8 @@ impl GlobalEnv {
             type_errors: Vec::new(),
             scope_manager: ScopeManager::new(),
             module_inclusions: HashMap::new(),
+            superclass_map: HashMap::new(),
+            module_extensions: HashMap::new(),
         }
     }
 
@@ -163,14 +170,31 @@ impl GlobalEnv {
 
     /// Resolve method
     pub fn resolve_method(&self, recv_ty: &Type, method_name: &str) -> Option<&MethodInfo> {
+        let ctx = ResolutionContext {
+            inclusions: &self.module_inclusions,
+            superclass_map: &self.superclass_map,
+            extensions: &self.module_extensions,
+        };
         self.method_registry
-            .resolve(recv_ty, method_name, &self.module_inclusions)
+            .resolve(recv_ty, method_name, &ctx)
     }
 
     /// 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())
+        Self::record_mixin(&mut self.module_inclusions, class_name, module_name);
+    }
+
+    /// Record that a class extends a module
+    pub fn record_extend(&mut self, class_name: &str, module_name: &str) {
+        Self::record_mixin(&mut self.module_extensions, class_name, module_name);
+    }
+
+    fn record_mixin(
+        map: &mut HashMap<String, Vec<String>>,
+        class_name: &str,
+        module_name: &str,
+    ) {
+        map.entry(class_name.to_string())
             .or_default()
             .push(module_name.to_string());
     }
@@ -247,6 +271,30 @@ impl GlobalEnv {
         });
         self.scope_manager.enter_scope(scope_id);
         self.register_constant_in_parent(scope_id, &name);
+
+        // Record superclass relationship in superclass_map
+        if let Some(parent) = superclass {
+            let child_name = self.scope_manager.current_qualified_name()
+                .unwrap_or_else(|| name.clone());
+            // NOTE: lookup_constant may fail for cross-namespace inheritance
+            // (e.g., `class Dog < Animal` inside `module Service` where Animal is `Api::Animal`).
+            // In that case, the raw name is used. This is a known limitation (see design doc Q2).
+            let parent_name = self.scope_manager.lookup_constant(parent)
+                .unwrap_or_else(|| parent.to_string());
+
+            // Detect superclass mismatch (Ruby raises TypeError for this at runtime)
+            if let Some(existing) = self.superclass_map.get(&child_name) {
+                if *existing != parent_name {
+                    eprintln!(
+                        "[methodray] warning: superclass mismatch for {}: previously {}, now {}",
+                        child_name, existing, parent_name
+                    );
+                }
+            }
+
+            self.superclass_map.insert(child_name, parent_name);
+        }
+
         scope_id
     }
 
@@ -293,78 +341,3 @@ impl Default for GlobalEnv {
         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/core/src/env/local_env.rs

@@ -40,53 +40,3 @@ impl LocalEnv {
         self.locals.iter()
     }
 }
-
-#[cfg(test)]
-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();
-
-        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_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();
-
-        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/core/src/env/method_registry.rs

@@ -1,6 +1,6 @@
 //! Method registration and resolution
 
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
 use crate::graph::VertexId;
 use crate::types::Type;
@@ -9,6 +9,13 @@ use smallvec::SmallVec;
 const OBJECT_CLASS: &str = "Object";
 const KERNEL_MODULE: &str = "Kernel";
 
+/// Aggregated context for method resolution (inclusions, superclass chain, extensions)
+pub struct ResolutionContext<'a> {
+    pub inclusions: &'a HashMap<String, Vec<String>>,
+    pub superclass_map: &'a HashMap<String, String>,
+    pub extensions: &'a HashMap<String, Vec<String>>,
+}
+
 /// Method information
 #[derive(Debug, Clone)]
 pub struct MethodInfo {
@@ -79,17 +86,32 @@ impl MethodRegistry {
         );
     }
 
+    /// Add included modules for a given class name to the chain.
+    fn add_included_modules(
+        chain: &mut SmallVec<[Type; 8]>,
+        class_name: &str,
+        inclusions: &HashMap<String, Vec<String>>,
+    ) {
+        if let Some(modules) = inclusions.get(class_name) {
+            for module_name in modules.iter().rev() {
+                chain.push(Type::instance(module_name));
+            }
+        }
+    }
+
     /// Build the method resolution order (MRO) fallback chain for a receiver type.
     ///
     /// Returns a list of types to search in order:
     /// 1. Exact receiver type
     /// 2. Generic → base class (e.g., Array[Integer] → Array)
-    /// 3. Included modules (last included first, matching Ruby MRO)
-    /// 4. Object (for Instance/Generic types only)
-    /// 5. Kernel (for Instance/Generic types only)
+    /// 3. Included modules of self (last included first, matching Ruby MRO)
+    /// 4. Superclass chain: for each parent, add parent type + its included modules
+    /// 5. Object (for Instance/Generic types only)
+    /// 6. Kernel (for Instance/Generic types only)
+    /// 7. Extended modules (for Singleton types only, last extended has highest priority)
     fn fallback_chain(
         recv_ty: &Type,
-        inclusions: &HashMap<String, Vec<String>>,
+        ctx: &ResolutionContext,
     ) -> SmallVec<[Type; 8]> {
         let mut chain = SmallVec::new();
         chain.push(recv_ty.clone());
@@ -98,14 +120,24 @@ impl MethodRegistry {
             chain.push(Type::Instance { name: name.clone() });
         }
 
-        // MRO for Instance/Generic: included modules → Object → Kernel
+        // MRO for Instance/Generic: included modules → superclass chain → Object → Kernel
         if matches!(recv_ty, Type::Instance { .. } | Type::Generic { .. }) {
-            // Included modules (reverse order = last included has highest priority)
+            // Included modules of self (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));
+                Self::add_included_modules(&mut chain, class_name, ctx.inclusions);
+
+                // Walk superclass chain
+                let mut visited = HashSet::new();
+                visited.insert(class_name.to_string());
+                let mut current = class_name.to_string();
+                while let Some(parent) = ctx.superclass_map.get(&current) {
+                    if !visited.insert(parent.clone()) {
+                        // Cycle detected, stop walking
+                        break;
                     }
+                    chain.push(Type::instance(parent));
+                    Self::add_included_modules(&mut chain, parent, ctx.inclusions);
+                    current = parent.clone();
                 }
             }
 
@@ -113,242 +145,29 @@ impl MethodRegistry {
             chain.push(Type::instance(KERNEL_MODULE));
         }
 
+        // Singleton type: search extended modules (extend makes module methods available as class methods)
+        if let Type::Singleton { name } = recv_ty {
+            Self::add_included_modules(&mut chain, name.full_name(), ctx.extensions);
+        }
+
         chain
     }
 
     /// Resolve a method for a receiver type
     ///
     /// 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.
+    /// → included modules → superclass chain → Object → Kernel.
+    /// For Singleton types, also searches extended modules after exact match.
+    /// For other non-instance types (Nil, Union, Bot), only exact match is attempted.
     pub fn resolve(
         &self,
         recv_ty: &Type,
         method_name: &str,
-        inclusions: &HashMap<String, Vec<String>>,
+        ctx: &ResolutionContext,
     ) -> Option<&MethodInfo> {
         let method_key = method_name.to_string();
-        Self::fallback_chain(recv_ty, inclusions)
+        Self::fallback_chain(recv_ty, ctx)
             .into_iter()
             .find_map(|ty| self.methods.get(&(ty, method_key.clone())))
     }
 }
-
-#[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", &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", &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![], None);
-
-        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);
-    }
-
-    #[test]
-    fn test_register_user_method_with_param_vertices() {
-        let mut registry = MethodRegistry::new();
-        let return_vtx = VertexId(10);
-        let param_vtxs = vec![VertexId(20), VertexId(21)];
-        registry.register_user_method(
-            Type::instance("Calc"),
-            "add",
-            return_vtx,
-            param_vtxs,
-            None,
-        );
-
-        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);
-        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?", &HashMap::new()).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", &HashMap::new()).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", &HashMap::new()).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", &HashMap::new()).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", &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", &HashMap::new()).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", &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", &HashMap::new()).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", &HashMap::new()).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", &HashMap::new()).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", &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());
-    }
-}