method-ray 0.1.7 → 0.1.9

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

@@ -128,6 +128,55 @@ fn install_block_parameter(genv: &mut GlobalEnv, lenv: &mut LocalEnv, name: Stri
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::analyzer::install::AstInstaller;
+    use crate::env::LocalEnv;
+    use crate::parser::ParseSession;
+    use crate::types::Type;
+
+    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);
+        }
+    }
+
+    fn analyze_with_stdlib(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();
+
+        // Register stdlib methods needed for block tests
+        genv.register_builtin_method_with_block(
+            Type::array(),
+            "each",
+            Type::array(),
+            Some(vec![Type::instance("Elem")]),
+        );
+        genv.register_builtin_method_with_block(
+            Type::string(),
+            "each_char",
+            Type::string(),
+            Some(vec![Type::string()]),
+        );
+        genv.register_builtin_method(Type::integer(), "even?", Type::instance("TrueClass"));
+        genv.register_builtin_method(Type::string(), "upcase", Type::string());
+
+        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
+    }
 
     #[test]
     fn test_enter_exit_block_scope() {
@@ -173,4 +222,95 @@ mod tests {
 
         exit_block_scope(&mut genv);
     }
+
+    #[test]
+    fn test_block_parameter_type_from_array() {
+        let source = r#"
+class Foo
+  def bar
+    [1, 2, 3].each { |x| x.even? }
+  end
+end
+"#;
+        let genv = analyze_with_stdlib(source);
+        assert!(
+            genv.type_errors.is_empty(),
+            "x.even? should not produce type errors: {:?}",
+            genv.type_errors
+        );
+        // Verify bar returns Array (each returns its receiver)
+        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_block_external_variable_access() {
+        let source = r#"
+class Foo
+  def bar
+    y = "hello"
+    [1].each { y.upcase }
+  end
+end
+"#;
+        let genv = analyze_with_stdlib(source);
+        assert!(
+            genv.type_errors.is_empty(),
+            "y.upcase should not produce type errors: {:?}",
+            genv.type_errors
+        );
+    }
+
+    #[test]
+    fn test_block_parameter_from_each_char() {
+        let source = r#"
+class Foo
+  def bar
+    "hello".each_char { |c| c.upcase }
+  end
+end
+"#;
+        let genv = analyze_with_stdlib(source);
+        assert!(
+            genv.type_errors.is_empty(),
+            "c.upcase should not produce type errors: {:?}",
+            genv.type_errors
+        );
+    }
+
+    #[test]
+    fn test_block_body_does_not_affect_method_return() {
+        let source = r#"
+class Foo
+  def bar
+    [1, 2].each { |x| "string" }
+  end
+end
+"#;
+        let genv = analyze_with_stdlib(source);
+        // each returns its receiver (Array), not the block body result (String)
+        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_nested_blocks() {
+        let source = r#"
+class Foo
+  def bar
+    [1, 2].each { |x|
+      "hello".each_char { |c| c.upcase }
+    }
+  end
+end
+"#;
+        let genv = analyze_with_stdlib(source);
+        assert!(
+            genv.type_errors.is_empty(),
+            "nested block should not produce type errors: {:?}",
+            genv.type_errors
+        );
+    }
 }

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

@@ -5,6 +5,8 @@
 //! - Managing return value vertices
 //! - Attaching source location for error reporting
 
+use std::collections::HashMap;
+
 use crate::env::GlobalEnv;
 use crate::graph::{MethodCallBox, VertexId};
 use crate::source_map::SourceLocation;
@@ -15,6 +17,7 @@ pub fn install_method_call(
     recv_vtx: VertexId,
     method_name: String,
     arg_vtxs: Vec<VertexId>,
+    kwarg_vtxs: Option<HashMap<String, VertexId>>,
     location: Option<SourceLocation>,
 ) -> VertexId {
     // Create Vertex for return value
@@ -22,7 +25,8 @@ pub fn install_method_call(
 
     // Create MethodCallBox with location and argument vertices
     let box_id = genv.alloc_box_id();
-    let call_box = MethodCallBox::new(box_id, recv_vtx, method_name, ret_vtx, arg_vtxs, location);
+    let call_box =
+        MethodCallBox::new(box_id, recv_vtx, method_name, ret_vtx, arg_vtxs, kwarg_vtxs, location);
     genv.register_box(box_id, Box::new(call_box));
 
     ret_vtx
@@ -39,7 +43,7 @@ mod tests {
 
         let recv_vtx = genv.new_source(Type::string());
         let ret_vtx =
-            install_method_call(&mut genv, recv_vtx, "upcase".to_string(), vec![], None);
+            install_method_call(&mut genv, recv_vtx, "upcase".to_string(), vec![], None, None);
 
         // Return vertex should exist
         assert!(genv.get_vertex(ret_vtx).is_some());
@@ -51,7 +55,7 @@ mod tests {
 
         let recv_vtx = genv.new_source(Type::string());
         let _ret_vtx =
-            install_method_call(&mut genv, recv_vtx, "upcase".to_string(), vec![], None);
+            install_method_call(&mut genv, recv_vtx, "upcase".to_string(), vec![], None, None);
 
         // Box should be added
         assert_eq!(genv.box_count(), 1);

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

@@ -6,6 +6,8 @@
 //! - Method definition scope management (def baz ... end)
 //! - Extracting class/module names from AST nodes (including qualified names like Api::User)
 
+use std::collections::HashMap;
+
 use crate::env::{GlobalEnv, LocalEnv};
 use crate::graph::{ChangeSet, VertexId};
 use crate::types::Type;
@@ -24,7 +26,8 @@ pub(crate) fn process_class_node(
     class_node: &ruby_prism::ClassNode,
 ) -> Option<VertexId> {
     let class_name = extract_class_name(class_node);
-    install_class(genv, class_name);
+    let superclass = class_node.superclass().and_then(|sup| extract_constant_path(&sup));
+    install_class(genv, class_name, superclass.as_deref());
 
     if let Some(body) = class_node.body() {
         if let Some(statements) = body.as_statements_node() {
@@ -78,10 +81,10 @@ pub(crate) fn process_def_node(
     let merge_vtx = genv.scope_manager.current_method_return_vertex();
 
     // Process parameters BEFORE processing body
-    let param_vtxs = if let Some(params_node) = def_node.parameters() {
+    let (param_vtxs, keyword_param_vtxs) = if let Some(params_node) = def_node.parameters() {
         install_parameters(genv, lenv, changes, source, &params_node)
     } else {
-        vec![]
+        (vec![], HashMap::new())
     };
 
     let mut last_vtx = None;
@@ -108,11 +111,13 @@ pub(crate) fn process_def_node(
             } else {
                 Type::instance(&name)
             };
+            let kw_params = (!keyword_param_vtxs.is_empty()).then_some(keyword_param_vtxs);
             genv.register_user_method(
                 recv_type,
                 &method_name,
                 ret_vtx,
                 param_vtxs,
+                kw_params,
             );
         }
     }
@@ -122,8 +127,8 @@ pub(crate) fn process_def_node(
 }
 
 /// Install class definition
-fn install_class(genv: &mut GlobalEnv, class_name: String) {
-    genv.enter_class(class_name);
+fn install_class(genv: &mut GlobalEnv, class_name: String, superclass: Option<&str>) {
+    genv.enter_class(class_name, superclass);
 }
 
 /// Install module definition
@@ -199,7 +204,7 @@ mod tests {
     fn test_enter_exit_class_scope() {
         let mut genv = GlobalEnv::new();
 
-        install_class(&mut genv, "User".to_string());
+        install_class(&mut genv, "User".to_string(), None);
         assert_eq!(
             genv.scope_manager.current_class_name(),
             Some("User".to_string())
@@ -227,7 +232,7 @@ mod tests {
     fn test_nested_method_scope() {
         let mut genv = GlobalEnv::new();
 
-        install_class(&mut genv, "User".to_string());
+        install_class(&mut genv, "User".to_string(), None);
         install_method(&mut genv, "greet".to_string());
 
         // Still in User class context