method-ray 0.1.7 → 0.1.9

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

@@ -5,6 +5,8 @@
 //! - Creating vertices for parameters
 //! - Registering parameters as local variables in method scope
 
+use std::collections::HashMap;
+
 use crate::env::{GlobalEnv, LocalEnv};
 use crate::graph::{ChangeSet, VertexId};
 use crate::types::Type;
@@ -117,16 +119,18 @@ pub fn install_keyword_rest_parameter(
 
 /// Install method parameters as local variables
 ///
-/// Returns a Vec of VertexId for required and optional parameters (positional),
-/// which can be used for argument-to-parameter type propagation.
+/// Returns a tuple of:
+/// - Vec<VertexId>: positional parameter vertices (required and optional)
+/// - HashMap<String, VertexId>: keyword parameter vertices (name → vertex)
 pub(crate) fn install_parameters(
     genv: &mut GlobalEnv,
     lenv: &mut LocalEnv,
     changes: &mut ChangeSet,
     source: &str,
     params_node: &ruby_prism::ParametersNode,
-) -> Vec<VertexId> {
+) -> (Vec<VertexId>, HashMap<String, VertexId>) {
     let mut param_vtxs = Vec::new();
+    let mut keyword_param_vtxs: HashMap<String, VertexId> = HashMap::new();
 
     // Required parameters: def foo(a, b)
     for node in params_node.requireds().iter() {
@@ -165,8 +169,30 @@ pub(crate) fn install_parameters(
         }
     }
 
+    // Keyword parameters: def foo(name:, age: 0)
+    // Reuses install_required_parameter / install_optional_parameter
+    // since the logic is identical for positional and keyword parameters.
+    for node in params_node.keywords().iter() {
+        if let Some(req_kw) = node.as_required_keyword_parameter_node() {
+            let name = bytes_to_name(req_kw.name().as_slice());
+            let vtx = install_required_parameter(genv, lenv, name.clone());
+            keyword_param_vtxs.insert(name, vtx);
+        } else if let Some(opt_kw) = node.as_optional_keyword_parameter_node() {
+            let name = bytes_to_name(opt_kw.name().as_slice());
+            let default_value = opt_kw.value();
+            let vtx = if let Some(default_vtx) =
+                super::install::install_node(genv, lenv, changes, source, &default_value)
+            {
+                install_optional_parameter(genv, lenv, changes, name.clone(), default_vtx)
+            } else {
+                install_required_parameter(genv, lenv, name.clone())
+            };
+            keyword_param_vtxs.insert(name, vtx);
+        }
+    }
+
     // Keyword rest parameter: def foo(**kwargs)
-    // Not included in param_vtxs (keyword args need special handling)
+    // Not included in keyword_param_vtxs (collects all remaining keywords)
     if let Some(kwrest_node) = params_node.keyword_rest() {
         if let Some(kwrest_param) = kwrest_node.as_keyword_rest_parameter_node() {
             if let Some(name_id) = kwrest_param.name() {
@@ -176,12 +202,42 @@ pub(crate) fn install_parameters(
         }
     }
 
-    param_vtxs
+    (param_vtxs, keyword_param_vtxs)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::analyzer::install::AstInstaller;
+    use crate::parser::ParseSession;
+
+    fn analyze(source: &str) -> GlobalEnv {
+        let session = ParseSession::new();
+        let parse_result = session.parse_source(source, "test.rb").unwrap();
+        let root = parse_result.node();
+        let program = root.as_program_node().unwrap();
+
+        let mut genv = GlobalEnv::new();
+        let mut lenv = LocalEnv::new();
+
+        let mut installer = AstInstaller::new(&mut genv, &mut lenv, source);
+        for stmt in &program.statements().body() {
+            installer.install_node(&stmt);
+        }
+        installer.finish();
+
+        genv
+    }
+
+    fn get_type_show(genv: &GlobalEnv, vtx: VertexId) -> String {
+        if let Some(vertex) = genv.get_vertex(vtx) {
+            vertex.show()
+        } else if let Some(source) = genv.get_source(vtx) {
+            source.ty.show()
+        } else {
+            panic!("vertex {:?} not found as either Vertex or Source", vtx);
+        }
+    }
 
     #[test]
     fn test_install_required_parameter() {
@@ -217,4 +273,157 @@ mod tests {
         assert_ne!(vtx_b, vtx_c);
         assert_ne!(vtx_a, vtx_c);
     }
+
+    #[test]
+    fn test_install_optional_parameter_inherits_default_type() {
+        let mut genv = GlobalEnv::new();
+        let mut lenv = LocalEnv::new();
+        let mut changes = ChangeSet::new();
+
+        // Default value: 0 (Integer)
+        let default_vtx = genv.new_source(Type::integer());
+        let vtx = install_optional_parameter(
+            &mut genv,
+            &mut lenv,
+            &mut changes,
+            "age".to_string(),
+            default_vtx,
+        );
+
+        assert_eq!(lenv.get_var("age"), Some(vtx));
+
+        // Type should propagate from default value
+        let vertex = genv.get_vertex(vtx).unwrap();
+        assert_eq!(vertex.show(), "Integer");
+    }
+
+    #[test]
+    fn test_required_parameter_type_propagation() {
+        let source = r#"
+class Foo
+  def greet(name)
+    name
+  end
+end
+
+Foo.new.greet("Alice")
+"#;
+        let genv = analyze(source);
+        let info = genv.resolve_method(&Type::instance("Foo"), "greet").unwrap();
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+
+    #[test]
+    fn test_optional_parameter_default_type() {
+        let source = r#"
+class Foo
+  def greet(name = "World")
+    name
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv.resolve_method(&Type::instance("Foo"), "greet").unwrap();
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+
+    #[test]
+    fn test_multiple_parameters_from_call_site() {
+        let source = r#"
+class Calc
+  def add(x, y)
+    x
+  end
+end
+
+Calc.new.add(1, 2)
+"#;
+        let genv = analyze(source);
+        let info = genv.resolve_method(&Type::instance("Calc"), "add").unwrap();
+        let param_vtxs = info.param_vertices.as_ref().unwrap();
+        assert_eq!(param_vtxs.len(), 2);
+        // Verify return type is Integer (method returns x, which receives 1)
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "Integer");
+    }
+
+    #[test]
+    fn test_keyword_parameter_propagation() {
+        let source = r#"
+class Foo
+  def greet(name:)
+    name
+  end
+end
+
+Foo.new.greet(name: "Alice")
+"#;
+        let genv = analyze(source);
+        let info = genv.resolve_method(&Type::instance("Foo"), "greet").unwrap();
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+
+    #[test]
+    fn test_optional_keyword_parameter_default() {
+        let source = r#"
+class Counter
+  def count(step: 1)
+    step
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv.resolve_method(&Type::instance("Counter"), "count").unwrap();
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "Integer");
+    }
+
+    #[test]
+    fn test_mixed_positional_and_keyword_params() {
+        let source = r#"
+class User
+  def initialize(id, name:)
+    @id = id
+    @name = name
+  end
+end
+
+User.new(1, name: "Alice")
+"#;
+        let genv = analyze(source);
+        assert!(genv.type_errors.is_empty());
+    }
+
+    #[test]
+    fn test_rest_parameter() {
+        let source = r#"
+class Foo
+  def bar(*args)
+    args
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv.resolve_method(&Type::instance("Foo"), "bar").unwrap();
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "Array");
+    }
+
+    #[test]
+    fn test_no_parameters() {
+        let source = r#"
+class Foo
+  def bar
+    "hello"
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv.resolve_method(&Type::instance("Foo"), "bar").unwrap();
+        let param_vtxs = info.param_vertices.as_ref().unwrap();
+        assert!(param_vtxs.is_empty());
+    }
 }

data/core/src/analyzer/super_calls.rs

@@ -0,0 +1,285 @@
+//! 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),
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::analyzer::install::AstInstaller;
+    use crate::env::{GlobalEnv, LocalEnv};
+    use crate::graph::VertexId;
+    use crate::parser::ParseSession;
+    use crate::types::Type;
+
+    /// Helper: parse Ruby source, process with AstInstaller, and return GlobalEnv
+    fn analyze(source: &str) -> GlobalEnv {
+        let session = ParseSession::new();
+        let parse_result = session.parse_source(source, "test.rb").unwrap();
+        let root = parse_result.node();
+        let program = root.as_program_node().unwrap();
+
+        let mut genv = GlobalEnv::new();
+        let mut lenv = LocalEnv::new();
+
+        let mut installer = AstInstaller::new(&mut genv, &mut lenv, source);
+        for stmt in &program.statements().body() {
+            installer.install_node(&stmt);
+        }
+        installer.finish();
+
+        genv
+    }
+
+    /// Helper: get the type string for a vertex ID
+    fn get_type_show(genv: &GlobalEnv, vtx: VertexId) -> String {
+        if let Some(vertex) = genv.get_vertex(vtx) {
+            vertex.show()
+        } else if let Some(source) = genv.get_source(vtx) {
+            source.ty.show()
+        } else {
+            panic!("vertex {:?} not found as either Vertex or Source", vtx);
+        }
+    }
+
+    #[test]
+    fn test_super_basic() {
+        let source = r#"
+class Animal
+  def speak
+    "..."
+  end
+end
+
+class Dog < Animal
+  def speak
+    super
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Dog"), "speak")
+            .expect("Dog#speak should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+
+    #[test]
+    fn test_super_with_method_chain() {
+        let source = r#"
+class Animal
+  def speak
+    "hello"
+  end
+end
+
+class Dog < Animal
+  def speak
+    super.upcase
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Dog"), "speak")
+            .expect("Dog#speak should be registered");
+        assert!(info.return_vertex.is_some());
+    }
+
+    #[test]
+    fn test_super_with_arguments() {
+        let source = r#"
+class Base
+  def greet(name)
+    name
+  end
+end
+
+class Child < Base
+  def greet(name)
+    super(name)
+  end
+end
+
+Child.new.greet("Alice")
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Child"), "greet")
+            .expect("Child#greet should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+
+    #[test]
+    fn test_super_outside_method_ignored() {
+        let source = r#"
+class Foo < Object
+  super
+end
+"#;
+        analyze(source);
+    }
+
+    #[test]
+    fn test_super_explicit_empty_args() {
+        let source = r#"
+class Animal
+  def speak
+    "hello"
+  end
+end
+
+class Dog < Animal
+  def speak
+    super()
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Dog"), "speak")
+            .expect("Dog#speak should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+
+    #[test]
+    fn test_super_without_superclass_ignored() {
+        let source = r#"
+class Foo
+  def bar
+    super
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("Foo#bar should be registered");
+        assert!(info.return_vertex.is_some());
+    }
+
+    #[test]
+    fn test_super_qualified_superclass() {
+        let source = r#"
+module Animals
+  class Pet
+    def name
+      "pet"
+    end
+  end
+end
+
+class Dog < Animals::Pet
+  def name
+    super
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Dog"), "name")
+            .expect("Dog#name should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+
+    #[test]
+    fn test_super_multi_level_inheritance() {
+        let source = r#"
+class A
+  def foo
+    "hello"
+  end
+end
+
+class B < A
+  def foo
+    super
+  end
+end
+
+class C < B
+  def foo
+    super
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("C"), "foo")
+            .expect("C#foo should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+}

data/{rust → core}/src/cache/rbs_cache.rs

@@ -37,7 +37,6 @@ impl SerializableMethodInfo {
     }
 }
 
-#[allow(dead_code)]
 impl RbsCache {
     /// Get user cache file path (in ~/.cache/methodray/)
     pub fn cache_path() -> Result<PathBuf> {

data/{rust → core}/src/cli/commands.rs

@@ -1,7 +1,7 @@
 //! CLI command implementations
 
 use anyhow::Result;
-use std::path::PathBuf;
+use std::path::Path;
 
 use crate::cache::RbsCache;
 use crate::checker::FileChecker;
@@ -9,7 +9,7 @@ use crate::diagnostics;
 
 /// Check a single Ruby file for type errors
 /// Returns Ok(true) if no errors, Ok(false) if errors found
-pub fn check_single_file(file_path: &PathBuf, verbose: bool) -> Result<bool> {
+pub fn check_single_file(file_path: &Path, verbose: bool) -> Result<bool> {
     let checker = FileChecker::new()?;
     let diagnostics = checker.check_file(file_path)?;
 
@@ -38,7 +38,7 @@ pub fn check_project(_verbose: bool) -> Result<()> {
 }
 
 /// Watch a file for changes and re-check on modifications
-pub fn watch_file(file_path: &PathBuf) -> Result<()> {
+pub fn watch_file(file_path: &Path) -> Result<()> {
     use notify::{Config, RecommendedWatcher, RecursiveMode, Watcher};
     use std::sync::mpsc::channel;
     use std::time::Duration;

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

@@ -2,7 +2,6 @@ use std::path::PathBuf;
 
 /// Diagnostic severity level (LSP compatible)
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[allow(dead_code)]
 pub enum DiagnosticLevel {
     Error,
     Warning,
@@ -28,7 +27,6 @@ pub struct Location {
 
 /// Type checking diagnostic
 #[derive(Debug, Clone)]
-#[allow(dead_code)]
 pub struct Diagnostic {
     pub location: Location,
     pub level: DiagnosticLevel,
@@ -36,7 +34,6 @@ pub struct Diagnostic {
     pub code: Option<String>, // e.g., "E001"
 }
 
-#[allow(dead_code)]
 impl Diagnostic {
     /// Create an error diagnostic
     pub fn error(location: Location, message: String) -> Self {

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

@@ -8,7 +8,6 @@ use std::path::Path;
 /// ```text
 /// app/models/user.rb:10:5: error: undefined method `upcase` for Integer
 /// ```
-#[allow(dead_code)]
 pub fn format_diagnostics(diagnostics: &[Diagnostic]) -> String {
     diagnostics
         .iter()

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

@@ -6,7 +6,6 @@ use crate::graph::{BoxId, BoxTrait};
 use std::collections::{HashMap, HashSet, VecDeque};
 
 /// Manages boxes and their execution queue
-#[allow(dead_code)]
 pub struct BoxManager {
     /// All registered boxes
     pub boxes: HashMap<BoxId, Box<dyn BoxTrait>>,
@@ -24,7 +23,6 @@ impl Default for BoxManager {
     }
 }
 
-#[allow(dead_code)]
 impl BoxManager {
     /// Create a new empty box manager
     pub fn new() -> Self {
@@ -37,8 +35,8 @@ impl BoxManager {
     }
 
     /// Get a box by ID
-    pub fn get(&self, id: BoxId) -> Option<&Box<dyn BoxTrait>> {
-        self.boxes.get(&id)
+    pub fn get(&self, id: BoxId) -> Option<&dyn BoxTrait> {
+        self.boxes.get(&id).map(|b| b.as_ref())
     }
 
     /// Remove a box and return it (for temporary mutation)