method-ray 0.1.8 → 0.1.9

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

@@ -37,6 +37,10 @@ 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>>,
+
 }
 
 impl GlobalEnv {
@@ -47,6 +51,7 @@ impl GlobalEnv {
             method_registry: MethodRegistry::new(),
             type_errors: Vec::new(),
             scope_manager: ScopeManager::new(),
+            module_inclusions: HashMap::new(),
         }
     }
 
@@ -158,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
@@ -225,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/method_registry.rs

@@ -84,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());
 
@@ -94,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));
         }
@@ -106,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())))
     }
@@ -125,14 +143,14 @@ 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]
@@ -141,7 +159,7 @@ mod tests {
         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").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);
     }
@@ -159,7 +177,7 @@ mod tests {
             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);
@@ -173,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"));
     }
 
@@ -181,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);
     }
 
@@ -190,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"));
     }
 
@@ -199,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"));
     }
 
@@ -209,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]
@@ -224,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 ---
@@ -241,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);
     }
 
@@ -252,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"));
     }
 
@@ -262,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

@@ -245,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| {
@@ -593,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/types.rs

@@ -276,6 +276,17 @@ impl Type {
             type_args: vec![element_type],
         }
     }
+
+    /// Collapse a Vec<Type> into a single Type or Union.
+    /// Returns the single element if len==1, or Union if len>1.
+    /// Panics if the vec is empty.
+    pub fn union_of(mut types: Vec<Type>) -> Self {
+        match types.len() {
+            0 => panic!("union_of called with empty types"),
+            1 => types.pop().unwrap(),
+            _ => Type::Union(types),
+        }
+    }
 }
 
 #[cfg(test)]

data/ext/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "methodray"
-version = "0.1.8"
+version = "0.1.9"
 edition = "2021"
 
 [lib]
@@ -18,7 +18,7 @@ default = []
 cli = ["methodray-core/cli", "dep:clap", "dep:anyhow"]
 
 [dependencies]
-methodray-core = { path = "../rust", features = ["ruby-ffi"] }
+methodray-core = { path = "../core", features = ["ruby-ffi"] }
 magnus = "0.8"
 clap = { version = "4", features = ["derive"], optional = true }
 anyhow = { version = "1", optional = true }

data/lib/methodray/binary_locator.rb

@@ -21,8 +21,8 @@ module MethodRay
         File.expand_path(@binary_name, LIB_DIR),
         # Development: target/release (project root)
         File.expand_path("../../target/release/#{@binary_name}", LIB_DIR),
-        # Development: rust/target/release (legacy standalone binary)
-        File.expand_path("../../rust/target/release/#{@legacy_binary_name}", LIB_DIR)
+        # Development: core/target/release (legacy standalone binary)
+        File.expand_path("../../core/target/release/#{@legacy_binary_name}", LIB_DIR)
       ]
     end
   end

data/lib/methodray/commands.rb

@@ -46,7 +46,7 @@ module MethodRay
           warn 'Error: CLI binary not found.'
           warn ''
           warn 'For development, build with:'
-          warn '  cd rust && cargo build --release --bin methodray --features cli'
+          warn '  cd core && cargo build --release --bin methodray --features cli'
           warn ''
           warn 'If installed via gem, this might be a platform compatibility issue.'
           warn 'Please report at: https://github.com/dak2/method-ray/issues'

data/lib/methodray/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MethodRay
-  VERSION = '0.1.8'
+  VERSION = '0.1.9'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: method-ray
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - dak2
@@ -37,6 +37,59 @@ files:
 - CHANGELOG.md
 - LICENSE
 - README.md
+- core/Cargo.toml
+- core/src/analyzer/assignments.rs
+- core/src/analyzer/attributes.rs
+- core/src/analyzer/blocks.rs
+- core/src/analyzer/calls.rs
+- core/src/analyzer/conditionals.rs
+- core/src/analyzer/definitions.rs
+- core/src/analyzer/dispatch.rs
+- core/src/analyzer/exceptions.rs
+- core/src/analyzer/install.rs
+- core/src/analyzer/literals.rs
+- core/src/analyzer/loops.rs
+- core/src/analyzer/mod.rs
+- core/src/analyzer/operators.rs
+- core/src/analyzer/parameters.rs
+- core/src/analyzer/parentheses.rs
+- core/src/analyzer/returns.rs
+- core/src/analyzer/super_calls.rs
+- core/src/analyzer/variables.rs
+- core/src/cache/mod.rs
+- core/src/cache/rbs_cache.rs
+- core/src/checker.rs
+- core/src/cli/args.rs
+- core/src/cli/commands.rs
+- core/src/cli/mod.rs
+- core/src/diagnostics/diagnostic.rs
+- core/src/diagnostics/formatter.rs
+- core/src/diagnostics/mod.rs
+- core/src/env/box_manager.rs
+- core/src/env/global_env.rs
+- core/src/env/local_env.rs
+- core/src/env/method_registry.rs
+- core/src/env/mod.rs
+- core/src/env/scope.rs
+- core/src/env/type_error.rs
+- core/src/env/vertex_manager.rs
+- core/src/graph/box.rs
+- core/src/graph/change_set.rs
+- core/src/graph/mod.rs
+- core/src/graph/vertex.rs
+- core/src/lib.rs
+- core/src/lsp/diagnostics.rs
+- core/src/lsp/main.rs
+- core/src/lsp/mod.rs
+- core/src/lsp/server.rs
+- core/src/main.rs
+- core/src/parser.rs
+- core/src/rbs/converter.rs
+- core/src/rbs/error.rs
+- core/src/rbs/loader.rs
+- core/src/rbs/mod.rs
+- core/src/source_map.rs
+- core/src/types.rs
 - exe/methodray
 - ext/Cargo.toml
 - ext/extconf.rb
@@ -47,58 +100,6 @@ files:
 - lib/methodray/cli.rb
 - lib/methodray/commands.rb
 - lib/methodray/version.rb
-- rust/Cargo.toml
-- rust/src/analyzer/assignments.rs
-- rust/src/analyzer/attributes.rs
-- rust/src/analyzer/blocks.rs
-- rust/src/analyzer/calls.rs
-- rust/src/analyzer/conditionals.rs
-- rust/src/analyzer/definitions.rs
-- rust/src/analyzer/dispatch.rs
-- rust/src/analyzer/exceptions.rs
-- rust/src/analyzer/install.rs
-- rust/src/analyzer/literals.rs
-- rust/src/analyzer/loops.rs
-- rust/src/analyzer/mod.rs
-- rust/src/analyzer/operators.rs
-- rust/src/analyzer/parameters.rs
-- rust/src/analyzer/parentheses.rs
-- rust/src/analyzer/returns.rs
-- rust/src/analyzer/variables.rs
-- rust/src/cache/mod.rs
-- rust/src/cache/rbs_cache.rs
-- rust/src/checker.rs
-- rust/src/cli/args.rs
-- rust/src/cli/commands.rs
-- rust/src/cli/mod.rs
-- rust/src/diagnostics/diagnostic.rs
-- rust/src/diagnostics/formatter.rs
-- rust/src/diagnostics/mod.rs
-- rust/src/env/box_manager.rs
-- rust/src/env/global_env.rs
-- rust/src/env/local_env.rs
-- rust/src/env/method_registry.rs
-- rust/src/env/mod.rs
-- rust/src/env/scope.rs
-- rust/src/env/type_error.rs
-- rust/src/env/vertex_manager.rs
-- rust/src/graph/box.rs
-- rust/src/graph/change_set.rs
-- rust/src/graph/mod.rs
-- rust/src/graph/vertex.rs
-- rust/src/lib.rs
-- rust/src/lsp/diagnostics.rs
-- rust/src/lsp/main.rs
-- rust/src/lsp/mod.rs
-- rust/src/lsp/server.rs
-- rust/src/main.rs
-- rust/src/parser.rs
-- rust/src/rbs/converter.rs
-- rust/src/rbs/error.rs
-- rust/src/rbs/loader.rs
-- rust/src/rbs/mod.rs
-- rust/src/source_map.rs
-- rust/src/types.rs
 homepage: https://github.com/dak2/method-ray
 licenses:
 - MIT