method-ray 0.1.8 → 0.1.10

data/core/src/analyzer/super_calls.rs

@@ -0,0 +1,74 @@
+//! Super call handling: `super` and `super(args)`
+//!
+//! Ruby's `super` calls the same-named method on the parent class.
+//! - `super(args)` → SuperNode: explicit arguments
+//! - `super` (bare) → ForwardingSuperNode: implicit argument forwarding
+//!
+//! Note: ForwardingSuperNode (bare `super`) is treated as a zero-argument
+//! call. In Ruby, bare `super` forwards all arguments from the enclosing
+//! method, but replicating this requires parameter-vertex forwarding that
+//! is not yet implemented. Return type inference is unaffected.
+
+use ruby_prism::{ForwardingSuperNode, SuperNode};
+
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::graph::{ChangeSet, VertexId};
+use crate::source_map::SourceLocation as SL;
+use crate::types::Type;
+
+/// Process SuperNode: `super(args)` — explicit arguments
+pub(crate) fn process_super_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    super_node: &SuperNode,
+) -> Option<VertexId> {
+    let location = SL::from_prism_location_with_source(&super_node.location(), source);
+    process_super_call(genv, lenv, changes, source, super_node.arguments(), location)
+}
+
+/// Process ForwardingSuperNode: `super` — implicit argument forwarding
+pub(crate) fn process_forwarding_super_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    node: &ForwardingSuperNode,
+) -> Option<VertexId> {
+    let location = SL::from_prism_location_with_source(&node.location(), source);
+    process_super_call(genv, lenv, changes, source, None, location)
+}
+
+/// Resolve a super call by looking up the same-named method on the superclass.
+///
+/// Returns `None` if there is no enclosing method scope (super outside a method)
+/// or no explicit superclass declared on the enclosing class.
+fn process_super_call(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    arguments: Option<ruby_prism::ArgumentsNode>,
+    location: SL,
+) -> Option<VertexId> {
+    let method_name = genv.scope_manager.current_method_name()?;
+    let superclass_name = genv.scope_manager.current_superclass()?;
+    let recv_vtx = genv.new_source(Type::instance(&superclass_name));
+
+    let (arg_vtxs, kw) = if let Some(args) = arguments {
+        super::dispatch::collect_arguments(genv, lenv, changes, source, args.arguments().iter())
+    } else {
+        (vec![], None)
+    };
+
+    Some(super::calls::install_method_call(
+        genv,
+        recv_vtx,
+        method_name,
+        arg_vtxs,
+        kw,
+        Some(location),
+        false, // super calls cannot use safe navigation
+    ))
+}

data/{rust → core}/src/analyzer/variables.rs

@@ -10,7 +10,7 @@ use crate::graph::{ChangeSet, VertexId};
 use crate::types::Type;
 
 /// Install local variable write: x = value
-pub fn install_local_var_write(
+pub(crate) fn install_local_var_write(
     genv: &mut GlobalEnv,
     lenv: &mut LocalEnv,
     changes: &mut ChangeSet,
@@ -24,7 +24,7 @@ pub fn install_local_var_write(
 }
 
 /// Install local variable read: x
-pub fn install_local_var_read(lenv: &LocalEnv, var_name: &str) -> Option<VertexId> {
+pub(crate) fn install_local_var_read(lenv: &LocalEnv, var_name: &str) -> Option<VertexId> {
     lenv.get_var(var_name)
 }
 
@@ -33,7 +33,7 @@ pub fn install_local_var_read(lenv: &LocalEnv, var_name: &str) -> Option<VertexI
 /// If @name already has a pre-allocated VertexId (e.g., from attr_reader),
 /// an edge is added from value_vtx to the existing vertex so types propagate.
 /// Otherwise, value_vtx is registered directly as the ivar's VertexId.
-pub fn install_ivar_write(
+pub(crate) fn install_ivar_write(
     genv: &mut GlobalEnv,
     ivar_name: String,
     value_vtx: VertexId,
@@ -49,36 +49,16 @@ pub fn install_ivar_write(
 }
 
 /// Install instance variable read: @name
-pub fn install_ivar_read(genv: &GlobalEnv, ivar_name: &str) -> Option<VertexId> {
+pub(crate) fn install_ivar_read(genv: &GlobalEnv, ivar_name: &str) -> Option<VertexId> {
     genv.scope_manager.lookup_instance_var(ivar_name)
 }
 
 /// Install self node
 /// Uses the fully qualified name if available (e.g., Api::V1::User instead of just User)
-pub fn install_self(genv: &mut GlobalEnv) -> VertexId {
+pub(crate) fn install_self(genv: &mut GlobalEnv) -> VertexId {
     if let Some(qualified_name) = genv.scope_manager.current_qualified_name() {
         genv.new_source(Type::instance(&qualified_name))
     } else {
         genv.new_source(Type::instance("Object"))
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_install_self_at_top_level() {
-        let mut genv = GlobalEnv::new();
-
-        let vtx = install_self(&mut genv);
-        assert_eq!(genv.get_source(vtx).unwrap().ty.show(), "Object");
-    }
-
-    #[test]
-    fn test_local_var_read_not_found() {
-        let lenv = LocalEnv::new();
-
-        assert_eq!(install_local_var_read(&lenv, "unknown"), None);
-    }
-}

data/{rust → core}/src/checker.rs

@@ -134,16 +134,3 @@ fn collect_diagnostics(genv: &GlobalEnv, file_path: &Path) -> Vec<Diagnostic> {
 
     diagnostics
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_file_checker_creation() {
-        // This test will fail if RBS cache doesn't exist
-        // That's expected - cache should be generated from Ruby side first
-        let result = FileChecker::new();
-        assert!(result.is_ok() || result.is_err()); // Just check it doesn't panic
-    }
-}

data/{rust → core}/src/diagnostics/diagnostic.rs

@@ -79,44 +79,3 @@ impl Diagnostic {
         Self::warning(location, message)
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_diagnostic_creation() {
-        let loc = Location {
-            file: PathBuf::from("test.rb"),
-            line: 10,
-            column: 5,
-            length: None,
-        };
-
-        let diag = Diagnostic::undefined_method(loc.clone(), "Integer", "upcase");
-        assert_eq!(diag.level, DiagnosticLevel::Error);
-        assert_eq!(diag.message, "undefined method `upcase` for Integer");
-    }
-
-    #[test]
-    fn test_union_partial_error() {
-        let loc = Location {
-            file: PathBuf::from("test.rb"),
-            line: 15,
-            column: 3,
-            length: None,
-        };
-
-        let diag = Diagnostic::union_partial_error(
-            loc,
-            vec!["String".to_string()],
-            vec!["Integer".to_string()],
-            "upcase",
-        );
-
-        assert_eq!(diag.level, DiagnosticLevel::Warning);
-        assert!(diag
-            .message
-            .contains("method `upcase` is defined for String but not for Integer"));
-    }
-}

data/{rust → core}/src/diagnostics/formatter.rs

@@ -78,41 +78,3 @@ pub fn format_diagnostics_with_file(diagnostics: &[Diagnostic], file_path: &Path
         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 → core}/src/env/box_manager.rs

@@ -87,33 +87,3 @@ impl BoxManager {
         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 → 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;
@@ -37,6 +37,15 @@ 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>>,
+
+    /// 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 {
@@ -47,6 +56,9 @@ impl GlobalEnv {
             method_registry: MethodRegistry::new(),
             type_errors: Vec::new(),
             scope_manager: ScopeManager::new(),
+            module_inclusions: HashMap::new(),
+            superclass_map: HashMap::new(),
+            module_extensions: HashMap::new(),
         }
     }
 
@@ -158,7 +170,33 @@ 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)
+        let ctx = ResolutionContext {
+            inclusions: &self.module_inclusions,
+            superclass_map: &self.superclass_map,
+            extensions: &self.module_extensions,
+        };
+        self.method_registry
+            .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::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());
     }
 
     /// Register built-in method
@@ -225,14 +263,38 @@ 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);
+
+        // 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
     }
 
@@ -279,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

@@ -0,0 +1,42 @@
+use crate::graph::VertexId;
+use std::collections::HashMap;
+
+/// Local environment: mapping of local variable names to VertexIDs
+pub struct LocalEnv {
+    locals: HashMap<String, VertexId>,
+}
+
+impl Default for LocalEnv {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+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()
+    }
+
+    /// 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()
+    }
+}

data/core/src/env/method_registry.rs

@@ -0,0 +1,173 @@
+//! Method registration and resolution
+
+use std::collections::{HashMap, HashSet};
+
+use crate::graph::VertexId;
+use crate::types::Type;
+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 {
+    pub return_type: Type,
+    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
+#[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.register_with_block(recv_ty, method_name, ret_ty, None);
+    }
+
+    /// Register a method with block parameter types
+    pub fn register_with_block(
+        &mut self,
+        recv_ty: Type,
+        method_name: &str,
+        ret_ty: Type,
+        block_param_types: Option<Vec<Type>>,
+    ) {
+        self.methods.insert(
+            (recv_ty, method_name.to_string()),
+            MethodInfo {
+                return_type: ret_ty,
+                block_param_types,
+                return_vertex: None,
+                param_vertices: None,
+                keyword_param_vertices: None,
+            },
+        );
+    }
+
+    /// Register a user-defined method (return type resolved via graph)
+    pub fn register_user_method(
+        &mut self,
+        recv_ty: Type,
+        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()),
+            MethodInfo {
+                return_type: Type::Bot,
+                block_param_types: None,
+                return_vertex: Some(return_vertex),
+                param_vertices: Some(param_vertices),
+                keyword_param_vertices,
+            },
+        );
+    }
+
+    /// 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 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,
+        ctx: &ResolutionContext,
+    ) -> SmallVec<[Type; 8]> {
+        let mut chain = SmallVec::new();
+        chain.push(recv_ty.clone());
+
+        if let Type::Generic { name, .. } = recv_ty {
+            chain.push(Type::Instance { name: name.clone() });
+        }
+
+        // MRO for Instance/Generic: included modules → superclass chain → Object → Kernel
+        if matches!(recv_ty, Type::Instance { .. } | Type::Generic { .. }) {
+            // Included modules of self (reverse order = last included has highest priority)
+            if let Some(class_name) = recv_ty.base_class_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();
+                }
+            }
+
+            chain.push(Type::instance(OBJECT_CLASS));
+            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 → 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,
+        ctx: &ResolutionContext,
+    ) -> Option<&MethodInfo> {
+        let method_key = method_name.to_string();
+        Self::fallback_chain(recv_ty, ctx)
+            .into_iter()
+            .find_map(|ty| self.methods.get(&(ty, method_key.clone())))
+    }
+}