method-ray 0.1.3 → 0.1.4

data/rust/src/analyzer/literals.rs

@@ -3,60 +3,215 @@
 //! This module is responsible for:
 //! - String, Integer, Float, Regexp literals
 //! - nil, true, false, Symbol literals
+//! - Array, Hash, Range literals with element type inference
 //! - Creating Source vertices with fixed types
-//!
-//! Note: Array, Hash, and Range literals are handled in install.rs for element type inference
 
-use crate::env::GlobalEnv;
-use crate::graph::VertexId;
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::graph::{ChangeSet, VertexId};
 use crate::types::Type;
 use ruby_prism::Node;
+use std::collections::HashSet;
+
+/// Install literal node (including complex types: Array, Hash, Range)
+pub(crate) fn install_literal_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    node: &Node,
+) -> Option<VertexId> {
+    if node.as_array_node().is_some() {
+        let elements: Vec<Node> = node.as_array_node().unwrap().elements().iter().collect();
+        return install_array_literal_elements(genv, lenv, changes, source, elements);
+    }
 
-/// Install literal nodes and return their VertexId
-///
-/// Note: Array and Hash literals are NOT handled here because they require
-/// child processing for element type inference. See install.rs.
-pub fn install_literal(genv: &mut GlobalEnv, node: &Node) -> Option<VertexId> {
-    // "hello"
+    if node.as_hash_node().is_some() {
+        let elements: Vec<Node> = node.as_hash_node().unwrap().elements().iter().collect();
+        return install_hash_literal_elements(genv, lenv, changes, source, elements);
+    }
+
+    if let Some(range_node) = node.as_range_node() {
+        return install_range_literal(genv, lenv, changes, source, &range_node);
+    }
+
+    install_simple_literal(genv, node)
+}
+
+/// Install simple literal nodes (String, Integer, Float, nil, true, false, Symbol, Regexp)
+fn install_simple_literal(genv: &mut GlobalEnv, node: &Node) -> Option<VertexId> {
     if node.as_string_node().is_some() {
         return Some(genv.new_source(Type::string()));
     }
-
-    // 42
     if node.as_integer_node().is_some() {
         return Some(genv.new_source(Type::integer()));
     }
-
-    // 3.14
     if node.as_float_node().is_some() {
         return Some(genv.new_source(Type::float()));
     }
-
-    // nil
     if node.as_nil_node().is_some() {
         return Some(genv.new_source(Type::Nil));
     }
-
-    // true
     if node.as_true_node().is_some() {
         return Some(genv.new_source(Type::instance("TrueClass")));
     }
-
-    // false
     if node.as_false_node().is_some() {
         return Some(genv.new_source(Type::instance("FalseClass")));
     }
-
-    // :symbol
     if node.as_symbol_node().is_some() {
         return Some(genv.new_source(Type::symbol()));
     }
-
-    // /pattern/
     if node.as_regular_expression_node().is_some() {
         return Some(genv.new_source(Type::regexp()));
     }
+    None
+}
+
+/// Install array literal with element type inference
+fn install_array_literal_elements(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    elements: Vec<Node>,
+) -> Option<VertexId> {
+    if elements.is_empty() {
+        return Some(genv.new_source(Type::array()));
+    }
+
+    let mut element_types: HashSet<Type> = HashSet::new();
+
+    for element in &elements {
+        if let Some(vtx) = super::install::install_node(genv, lenv, changes, source, element) {
+            if let Some(src) = genv.get_source(vtx) {
+                element_types.insert(src.ty.clone());
+            } else if let Some(vertex) = genv.get_vertex(vtx) {
+                for ty in vertex.types.keys() {
+                    element_types.insert(ty.clone());
+                }
+            }
+        }
+    }
+
+    let array_type = if element_types.is_empty() {
+        Type::array()
+    } else if element_types.len() == 1 {
+        let elem_type = element_types.into_iter().next().unwrap();
+        Type::array_of(elem_type)
+    } else {
+        let types_vec: Vec<Type> = element_types.into_iter().collect();
+        let union_type = Type::Union(types_vec);
+        Type::array_of(union_type)
+    };
+
+    Some(genv.new_source(array_type))
+}
+
+/// Install hash literal with key/value type inference
+fn install_hash_literal_elements(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    elements: Vec<Node>,
+) -> Option<VertexId> {
+    if elements.is_empty() {
+        return Some(genv.new_source(Type::hash()));
+    }
+
+    let mut key_types: HashSet<Type> = HashSet::new();
+    let mut value_types: HashSet<Type> = HashSet::new();
+
+    for element in &elements {
+        if let Some(assoc_node) = element.as_assoc_node() {
+            if let Some(key_vtx) =
+                super::install::install_node(genv, lenv, changes, source, &assoc_node.key())
+            {
+                if let Some(src) = genv.get_source(key_vtx) {
+                    key_types.insert(src.ty.clone());
+                } else if let Some(vertex) = genv.get_vertex(key_vtx) {
+                    for ty in vertex.types.keys() {
+                        key_types.insert(ty.clone());
+                    }
+                }
+            }
+
+            if let Some(value_vtx) =
+                super::install::install_node(genv, lenv, changes, source, &assoc_node.value())
+            {
+                if let Some(src) = genv.get_source(value_vtx) {
+                    value_types.insert(src.ty.clone());
+                } else if let Some(vertex) = genv.get_vertex(value_vtx) {
+                    for ty in vertex.types.keys() {
+                        value_types.insert(ty.clone());
+                    }
+                }
+            }
+        }
+    }
 
+    let hash_type = if key_types.is_empty() || value_types.is_empty() {
+        Type::hash()
+    } else {
+        let key_type = if key_types.len() == 1 {
+            key_types.into_iter().next().unwrap()
+        } else {
+            let types_vec: Vec<Type> = key_types.into_iter().collect();
+            Type::Union(types_vec)
+        };
+        let value_type = if value_types.len() == 1 {
+            value_types.into_iter().next().unwrap()
+        } else {
+            let types_vec: Vec<Type> = value_types.into_iter().collect();
+            Type::Union(types_vec)
+        };
+        Type::hash_of(key_type, value_type)
+    };
+
+    Some(genv.new_source(hash_type))
+}
+
+/// Install range literal with element type inference
+fn install_range_literal(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    range_node: &ruby_prism::RangeNode,
+) -> Option<VertexId> {
+    let element_type = if let Some(left) = range_node.left() {
+        infer_range_element_type(genv, lenv, changes, source, &left)
+    } else if let Some(right) = range_node.right() {
+        infer_range_element_type(genv, lenv, changes, source, &right)
+    } else {
+        None
+    };
+
+    let range_type = match element_type {
+        Some(ty) => Type::range_of(ty),
+        None => Type::range(),
+    };
+
+    Some(genv.new_source(range_type))
+}
+
+/// Infer element type from a range endpoint node
+fn infer_range_element_type(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    node: &Node,
+) -> Option<Type> {
+    if let Some(vtx) = super::install::install_node(genv, lenv, changes, source, node) {
+        if let Some(src) = genv.get_source(vtx) {
+            return Some(src.ty.clone());
+        }
+        if let Some(vertex) = genv.get_vertex(vtx) {
+            if let Some(ty) = vertex.types.keys().next() {
+                return Some(ty.clone());
+            }
+        }
+    }
     None
 }
 
@@ -67,9 +222,6 @@ mod tests {
     #[test]
     fn test_install_string_literal() {
         let mut genv = GlobalEnv::new();
-
-        // Create a mock string node - we test via integration instead
-        // Unit test just verifies the type creation
         let vtx = genv.new_source(Type::string());
         assert_eq!(genv.get_source(vtx).unwrap().ty.show(), "String");
     }
@@ -77,7 +229,6 @@ mod tests {
     #[test]
     fn test_install_integer_literal() {
         let mut genv = GlobalEnv::new();
-
         let vtx = genv.new_source(Type::integer());
         assert_eq!(genv.get_source(vtx).unwrap().ty.show(), "Integer");
     }
@@ -85,7 +236,6 @@ mod tests {
     #[test]
     fn test_install_float_literal() {
         let mut genv = GlobalEnv::new();
-
         let vtx = genv.new_source(Type::float());
         assert_eq!(genv.get_source(vtx).unwrap().ty.show(), "Float");
     }
@@ -93,7 +243,6 @@ mod tests {
     #[test]
     fn test_install_regexp_literal() {
         let mut genv = GlobalEnv::new();
-
         let vtx = genv.new_source(Type::regexp());
         assert_eq!(genv.get_source(vtx).unwrap().ty.show(), "Regexp");
     }

data/rust/src/analyzer/mod.rs

@@ -1,5 +1,7 @@
+mod attributes;
 mod blocks;
 mod calls;
+mod conditionals;
 mod definitions;
 mod dispatch;
 mod install;

data/rust/src/analyzer/parameters.rs

@@ -113,6 +113,70 @@ pub fn install_keyword_rest_parameter(
     param_vtx
 }
 
+/// 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.
+pub(crate) fn install_parameters(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    params_node: &ruby_prism::ParametersNode,
+) -> Vec<VertexId> {
+    let mut param_vtxs = Vec::new();
+
+    // Required parameters: def foo(a, b)
+    for node in params_node.requireds().iter() {
+        if let Some(req_param) = node.as_required_parameter_node() {
+            let name = String::from_utf8_lossy(req_param.name().as_slice()).to_string();
+            let vtx = install_required_parameter(genv, lenv, name);
+            param_vtxs.push(vtx);
+        }
+    }
+
+    // Optional parameters: def foo(a = 1, b = "hello")
+    for node in params_node.optionals().iter() {
+        if let Some(opt_param) = node.as_optional_parameter_node() {
+            let name = String::from_utf8_lossy(opt_param.name().as_slice()).to_string();
+            let default_value = opt_param.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, default_vtx)
+            } else {
+                install_required_parameter(genv, lenv, name)
+            };
+            param_vtxs.push(vtx);
+        }
+    }
+
+    // Rest parameter: def foo(*args)
+    // Not included in param_vtxs (variadic args need special handling)
+    if let Some(rest_node) = params_node.rest() {
+        if let Some(rest_param) = rest_node.as_rest_parameter_node() {
+            if let Some(name_id) = rest_param.name() {
+                let name = String::from_utf8_lossy(name_id.as_slice()).to_string();
+                install_rest_parameter(genv, lenv, name);
+            }
+        }
+    }
+
+    // Keyword rest parameter: def foo(**kwargs)
+    // Not included in param_vtxs (keyword args need special handling)
+    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() {
+                let name = String::from_utf8_lossy(name_id.as_slice()).to_string();
+                install_keyword_rest_parameter(genv, lenv, name);
+            }
+        }
+    }
+
+    param_vtxs
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

data/rust/src/analyzer/variables.rs

@@ -29,14 +29,23 @@ pub fn install_local_var_read(lenv: &LocalEnv, var_name: &str) -> Option<VertexI
 }
 
 /// Install instance variable write: @name = value
+///
+/// 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(
     genv: &mut GlobalEnv,
     ivar_name: String,
     value_vtx: VertexId,
 ) -> VertexId {
-    genv.scope_manager
-        .set_instance_var_in_class(ivar_name, value_vtx);
-    value_vtx
+    if let Some(existing_vtx) = genv.scope_manager.lookup_instance_var(&ivar_name) {
+        genv.add_edge(value_vtx, existing_vtx);
+        existing_vtx
+    } else {
+        genv.scope_manager
+            .set_instance_var_in_class(ivar_name, value_vtx);
+        value_vtx
+    }
 }
 
 /// Install instance variable read: @name

data/rust/src/env/global_env.rs

@@ -162,6 +162,18 @@ impl GlobalEnv {
             .register_with_block(recv_ty, method_name, ret_ty, block_param_types);
     }
 
+    /// 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>,
+    ) {
+        self.method_registry
+            .register_user_method(recv_ty, method_name, return_vertex, param_vertices);
+    }
+
     // ===== Type Errors =====
 
     /// Record a type error (undefined method)

data/rust/src/env/method_registry.rs

@@ -1,5 +1,6 @@
 //! Method registration and resolution
 
+use crate::graph::VertexId;
 use crate::types::Type;
 use std::collections::HashMap;
 
@@ -8,6 +9,8 @@ use std::collections::HashMap;
 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>>,
 }
 
 /// Registry for method definitions
@@ -42,6 +45,27 @@ impl MethodRegistry {
             MethodInfo {
                 return_type: ret_ty,
                 block_param_types,
+                return_vertex: None,
+                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>,
+    ) {
+        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),
             },
         );
     }
@@ -87,4 +111,35 @@ mod tests {
         let registry = MethodRegistry::new();
         assert!(registry.resolve(&Type::string(), "unknown").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![]);
+
+        let info = registry.resolve(&Type::instance("User"), "name").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,
+        );
+
+        let info = registry.resolve(&Type::instance("Calc"), "add").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));
+    }
 }

data/rust/src/graph/box.rs

@@ -23,6 +23,7 @@ pub struct MethodCallBox {
     recv: VertexId,
     method_name: String,
     ret: VertexId,
+    arg_vtxs: Vec<VertexId>,
     location: Option<SourceLocation>, // Source code location
     /// Number of times this box has been rescheduled
     reschedule_count: u8,
@@ -37,6 +38,7 @@ impl MethodCallBox {
         recv: VertexId,
         method_name: String,
         ret: VertexId,
+        arg_vtxs: Vec<VertexId>,
         location: Option<SourceLocation>,
     ) -> Self {
         Self {
@@ -44,6 +46,7 @@ impl MethodCallBox {
             recv,
             method_name,
             ret,
+            arg_vtxs,
             location,
             reschedule_count: 0,
         }
@@ -86,11 +89,52 @@ impl BoxTrait for MethodCallBox {
         for recv_ty in recv_types {
             // Resolve method
             if let Some(method_info) = genv.resolve_method(&recv_ty, &self.method_name) {
-                // Create return type as Source
-                let ret_src_id = genv.new_source(method_info.return_type.clone());
-
-                // Add edge to return value
-                changes.add_edge(ret_src_id, self.ret);
+                if let Some(return_vtx) = method_info.return_vertex {
+                    // User-defined: edge from body's last expr → call site return
+                    changes.add_edge(return_vtx, self.ret);
+
+                    // Propagate argument types to parameter vertices
+                    if let Some(param_vtxs) = &method_info.param_vertices {
+                        for (i, param_vtx) in param_vtxs.iter().enumerate() {
+                            if let Some(arg_vtx) = self.arg_vtxs.get(i) {
+                                changes.add_edge(*arg_vtx, *param_vtx);
+                            }
+                        }
+                    }
+                } else {
+                    // RBS/builtin: create Source with fixed return type
+                    let ret_src_id = genv.new_source(method_info.return_type.clone());
+                    changes.add_edge(ret_src_id, self.ret);
+                }
+            } else if self.method_name == "new" {
+                if let Type::Singleton { name } = &recv_ty {
+                    // singleton(User)#new → instance(User)
+                    let instance_type = Type::instance(name.full_name());
+                    let ret_src = genv.new_source(instance_type.clone());
+                    changes.add_edge(ret_src, self.ret);
+
+                    // Propagate arguments to initialize parameters
+                    if let Some(init_info) = genv.resolve_method(&instance_type, "initialize") {
+                        if let Some(param_vtxs) = &init_info.param_vertices {
+                            for (i, param_vtx) in param_vtxs.iter().enumerate() {
+                                if let Some(arg_vtx) = self.arg_vtxs.get(i) {
+                                    changes.add_edge(*arg_vtx, *param_vtx);
+                                }
+                            }
+                        }
+                    }
+                    continue;
+                }
+                // Non-singleton .new: record error
+                genv.record_type_error(
+                    recv_ty.clone(),
+                    self.method_name.clone(),
+                    self.location.clone(),
+                );
+            } else if matches!(&recv_ty, Type::Singleton { .. }) {
+                // Skip error for unknown class methods on Singleton types
+                // (class method RBS registration is not yet supported)
+                continue;
             } else {
                 // Record type error for diagnostic reporting
                 genv.record_type_error(
@@ -271,6 +315,7 @@ mod tests {
             x_vtx,
             "upcase".to_string(),
             ret_vtx,
+            vec![],
             None, // No location in test
         );
 
@@ -302,6 +347,7 @@ mod tests {
             x_vtx,
             "unknown_method".to_string(),
             ret_vtx,
+            vec![],
             None, // No location in test
         );
 
@@ -488,4 +534,98 @@ mod tests {
         assert_eq!(genv.get_vertex(key_vtx).unwrap().show(), "String");
         assert_eq!(genv.get_vertex(value_vtx).unwrap().show(), "Integer");
     }
+
+    #[test]
+    fn test_method_call_box_user_defined_method() {
+        let mut genv = GlobalEnv::new();
+
+        // Simulate: def name; "Alice"; end
+        let body_src = genv.new_source(Type::string());
+
+        // Register user-defined method User#name with return_vertex
+        genv.register_user_method(Type::instance("User"), "name", body_src, vec![]);
+
+        // Simulate: user.name (receiver has type User)
+        let recv_vtx = genv.new_vertex();
+        let recv_src = genv.new_source(Type::instance("User"));
+        genv.add_edge(recv_src, recv_vtx);
+
+        let ret_vtx = genv.new_vertex();
+        let box_id = genv.alloc_box_id();
+        let call_box = MethodCallBox::new(
+            box_id,
+            recv_vtx,
+            "name".to_string(),
+            ret_vtx,
+            vec![],
+            None,
+        );
+        genv.register_box(box_id, Box::new(call_box));
+
+        genv.run_all();
+
+        // Return type should be String (propagated from body's last expression)
+        assert_eq!(genv.get_vertex(ret_vtx).unwrap().show(), "String");
+    }
+
+    #[test]
+    fn test_method_call_box_param_type_propagation() {
+        let mut genv = GlobalEnv::new();
+
+        // Simulate: def format(value); value.to_s; end
+        // 1. Create parameter vertex for 'value'
+        let param_vtx = genv.new_vertex();
+
+        // 2. Register Integer#to_s -> String (builtin)
+        genv.register_builtin_method(Type::integer(), "to_s", Type::string());
+
+        // 3. Create MethodCallBox for value.to_s (inside method body)
+        let inner_ret_vtx = genv.new_vertex();
+        let inner_box_id = genv.alloc_box_id();
+        let inner_call = MethodCallBox::new(
+            inner_box_id,
+            param_vtx,
+            "to_s".to_string(),
+            inner_ret_vtx,
+            vec![],
+            None,
+        );
+        genv.register_box(inner_box_id, Box::new(inner_call));
+
+        // 4. Register user-defined method Formatter#format with return_vertex and param_vertices
+        genv.register_user_method(
+            Type::instance("Formatter"),
+            "format",
+            inner_ret_vtx,
+            vec![param_vtx],
+        );
+
+        // 5. Simulate call: Formatter.new.format(42)
+        let recv_vtx = genv.new_vertex();
+        let recv_src = genv.new_source(Type::instance("Formatter"));
+        genv.add_edge(recv_src, recv_vtx);
+
+        let arg_vtx = genv.new_source(Type::integer()); // argument: 42
+
+        let call_ret_vtx = genv.new_vertex();
+        let call_box_id = genv.alloc_box_id();
+        let call_box = MethodCallBox::new(
+            call_box_id,
+            recv_vtx,
+            "format".to_string(),
+            call_ret_vtx,
+            vec![arg_vtx],
+            None,
+        );
+        genv.register_box(call_box_id, Box::new(call_box));
+
+        // Run all boxes
+        genv.run_all();
+
+        // param_vtx should have Integer type (propagated from argument)
+        assert_eq!(genv.get_vertex(param_vtx).unwrap().show(), "Integer");
+
+        // Return type should be String (Integer#to_s -> String)
+        assert_eq!(genv.get_vertex(call_ret_vtx).unwrap().show(), "String");
+    }
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: method-ray
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - dak2
@@ -48,8 +48,10 @@ files:
 - lib/methodray/commands.rb
 - lib/methodray/version.rb
 - rust/Cargo.toml
+- 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/install.rs