method-ray 0.1.2 → 0.1.4

data/rust/src/analyzer/parameters.rs

@@ -0,0 +1,218 @@
+//! Parameter Handlers - Processing Ruby method/block parameters
+//!
+//! This module is responsible for:
+//! - Extracting parameter names from DefNode
+//! - Creating vertices for parameters
+//! - Registering parameters as local variables in method scope
+
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::graph::{ChangeSet, VertexId};
+use crate::types::Type;
+
+/// Install a required parameter as a local variable
+///
+/// Required parameters start with Bot (untyped) type since we don't know
+/// what type will be passed at call sites.
+///
+/// # Example
+/// ```ruby
+/// def greet(name)  # 'name' is a required parameter
+///   name.upcase
+/// end
+/// ```
+pub fn install_required_parameter(genv: &mut GlobalEnv, lenv: &mut LocalEnv, name: String) -> VertexId {
+    // Create a vertex for the parameter (starts as Bot/untyped)
+    let param_vtx = genv.new_vertex();
+
+    // Register in LocalEnv for variable lookup
+    lenv.new_var(name, param_vtx);
+
+    param_vtx
+}
+
+/// Install an optional parameter with a default value
+///
+/// The parameter's type is inferred from the default value expression.
+///
+/// # Example
+/// ```ruby
+/// def greet(name = "World")  # 'name' has type String from default
+///   name.upcase
+/// end
+/// ```
+pub fn install_optional_parameter(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    _changes: &mut ChangeSet,
+    name: String,
+    default_value_vtx: VertexId,
+) -> VertexId {
+    // Create a vertex for the parameter
+    let param_vtx = genv.new_vertex();
+
+    // Connect default value to parameter vertex for type inference
+    // Use genv.add_edge directly so the type is immediately propagated
+    // before the method body is processed
+    genv.add_edge(default_value_vtx, param_vtx);
+
+    // Register in LocalEnv for variable lookup
+    lenv.new_var(name, param_vtx);
+
+    param_vtx
+}
+
+/// Install a rest parameter (*args) as a local variable with Array type
+///
+/// Rest parameters collect all remaining arguments into an Array.
+///
+/// # Example
+/// ```ruby
+/// def collect(*items)  # 'items' has type Array
+///   items.first
+/// end
+/// ```
+pub fn install_rest_parameter(genv: &mut GlobalEnv, lenv: &mut LocalEnv, name: String) -> VertexId {
+    // Create a vertex for the parameter
+    let param_vtx = genv.new_vertex();
+
+    // Rest parameters are always Arrays
+    let array_src = genv.new_source(Type::array());
+    genv.add_edge(array_src, param_vtx);
+
+    // Register in LocalEnv for variable lookup
+    lenv.new_var(name, param_vtx);
+
+    param_vtx
+}
+
+/// Install a keyword rest parameter (**kwargs) as a local variable with Hash type
+///
+/// Keyword rest parameters collect all remaining keyword arguments into a Hash.
+///
+/// # Example
+/// ```ruby
+/// def configure(**options)  # 'options' has type Hash
+///   options[:debug]
+/// end
+/// ```
+pub fn install_keyword_rest_parameter(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    name: String,
+) -> VertexId {
+    // Create a vertex for the parameter
+    let param_vtx = genv.new_vertex();
+
+    // Keyword rest parameters are always Hashes
+    let hash_src = genv.new_source(Type::hash());
+    genv.add_edge(hash_src, param_vtx);
+
+    // Register in LocalEnv for variable lookup
+    lenv.new_var(name, param_vtx);
+
+    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::*;
+
+    #[test]
+    fn test_install_required_parameter() {
+        let mut genv = GlobalEnv::new();
+        let mut lenv = LocalEnv::new();
+
+        let vtx = install_required_parameter(&mut genv, &mut lenv, "name".to_string());
+
+        // Parameter should be registered in LocalEnv
+        assert_eq!(lenv.get_var("name"), Some(vtx));
+
+        // Vertex should exist in GlobalEnv (as untyped)
+        let vertex = genv.get_vertex(vtx);
+        assert!(vertex.is_some());
+    }
+
+    #[test]
+    fn test_install_multiple_parameters() {
+        let mut genv = GlobalEnv::new();
+        let mut lenv = LocalEnv::new();
+
+        let vtx_a = install_required_parameter(&mut genv, &mut lenv, "a".to_string());
+        let vtx_b = install_required_parameter(&mut genv, &mut lenv, "b".to_string());
+        let vtx_c = install_required_parameter(&mut genv, &mut lenv, "c".to_string());
+
+        // All parameters should be registered
+        assert_eq!(lenv.get_var("a"), Some(vtx_a));
+        assert_eq!(lenv.get_var("b"), Some(vtx_b));
+        assert_eq!(lenv.get_var("c"), Some(vtx_c));
+
+        // All vertices should be different
+        assert_ne!(vtx_a, vtx_b);
+        assert_ne!(vtx_b, vtx_c);
+        assert_ne!(vtx_a, vtx_c);
+    }
+}

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
@@ -45,13 +54,12 @@ pub fn install_ivar_read(genv: &GlobalEnv, ivar_name: &str) -> Option<VertexId>
 }
 
 /// 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 {
-    if let Some(class_name) = genv.scope_manager.current_class_name() {
-        genv.new_source(Type::Instance { class_name })
+    if let Some(qualified_name) = genv.scope_manager.current_qualified_name() {
+        genv.new_source(Type::instance(&qualified_name))
     } else {
-        genv.new_source(Type::Instance {
-            class_name: "Object".to_string(),
-        })
+        genv.new_source(Type::instance("Object"))
     }
 }
 

data/rust/src/cache/rbs_cache.rs

@@ -26,14 +26,14 @@ pub struct SerializableMethodInfo {
     pub receiver_class: String,
     pub method_name: String,
     pub return_type_str: String, // Simplified: store as string
+    #[serde(default)]
+    pub block_param_types: Option<Vec<String>>,
 }
 
 impl SerializableMethodInfo {
     /// Parse return type string into Type (simple parser for cached data)
     pub fn return_type(&self) -> crate::types::Type {
-        crate::types::Type::Instance {
-            class_name: self.return_type_str.clone(),
-        }
+        crate::types::Type::instance(&self.return_type_str)
     }
 }
 
@@ -79,7 +79,6 @@ impl RbsCache {
         if let Some(bundled_path) = Self::bundled_cache_path() {
             if let Ok(bytes) = fs::read(&bundled_path) {
                 if let Ok(cache) = bincode::deserialize::<Self>(&bytes) {
-                    eprintln!("Loaded bundled cache from {}", bundled_path.display());
                     return Ok(cache);
                 }
             }
@@ -123,6 +122,7 @@ impl RbsCache {
                 receiver_class: m.receiver_class.clone(),
                 method_name: m.method_name.clone(),
                 return_type: crate::rbs::converter::RbsTypeConverter::parse(&m.return_type_str),
+                block_param_types: m.block_param_types.clone(),
             })
             .collect()
     }
@@ -140,6 +140,7 @@ impl RbsCache {
                 receiver_class: m.receiver_class,
                 method_name: m.method_name,
                 return_type_str: m.return_type.show(),
+                block_param_types: m.block_param_types,
             })
             .collect();
 
@@ -166,6 +167,7 @@ mod tests {
                 receiver_class: "String".to_string(),
                 method_name: "upcase".to_string(),
                 return_type_str: "String".to_string(),
+                block_param_types: None,
             }],
             timestamp: SystemTime::now(),
         };
@@ -197,6 +199,7 @@ mod tests {
             receiver_class: "String".to_string(),
             method_name: "upcase".to_string(),
             return_type_str: "String".to_string(),
+            block_param_types: None,
         };
 
         let return_type = method_info.return_type();
@@ -213,11 +216,13 @@ mod tests {
                     receiver_class: "String".to_string(),
                     method_name: "upcase".to_string(),
                     return_type_str: "String".to_string(),
+                    block_param_types: None,
                 },
                 SerializableMethodInfo {
                     receiver_class: "Integer".to_string(),
                     method_name: "to_s".to_string(),
                     return_type_str: "String".to_string(),
+                    block_param_types: None,
                 },
             ],
             timestamp: SystemTime::now(),
@@ -244,11 +249,13 @@ mod tests {
                     receiver_class: "String".to_string(),
                     method_name: "upcase".to_string(),
                     return_type_str: "String".to_string(),
+                    block_param_types: None,
                 },
                 SerializableMethodInfo {
                     receiver_class: "Array".to_string(),
                     method_name: "first".to_string(),
                     return_type_str: "Object".to_string(),
+                    block_param_types: None,
                 },
             ],
             timestamp: SystemTime::now(),

data/rust/src/checker.rs

@@ -1,7 +1,7 @@
 use crate::analyzer::AstInstaller;
 use crate::diagnostics::Diagnostic;
 use crate::env::{GlobalEnv, LocalEnv};
-use crate::parser;
+use crate::parser::ParseSession;
 use anyhow::{Context, Result};
 use std::path::Path;
 
@@ -30,8 +30,12 @@ impl FileChecker {
         let source = std::fs::read_to_string(file_path)
             .with_context(|| format!("Failed to read {}", file_path.display()))?;
 
+        // Create ParseSession (arena allocator) for this check
+        let session = ParseSession::new();
+
         // Parse file
-        let parse_result = parser::parse_ruby_file(file_path)
+        let parse_result = session
+            .parse_source(&source, &file_path.to_string_lossy())
             .with_context(|| format!("Failed to parse {}", file_path.display()))?;
 
         // Create fresh GlobalEnv for this analysis
@@ -56,12 +60,13 @@ impl FileChecker {
         let diagnostics = collect_diagnostics(&genv, file_path);
 
         Ok(diagnostics)
-    }
+    } // session drops here, freeing arena memory
 }
 
 /// Load RBS methods from cache (CLI mode without Ruby runtime)
 fn load_rbs_from_cache(genv: &mut GlobalEnv) -> Result<()> {
     use crate::cache::RbsCache;
+    use crate::rbs::converter::RbsTypeConverter;
     use crate::types::Type;
 
     let cache = RbsCache::load().context(
@@ -70,16 +75,23 @@ fn load_rbs_from_cache(genv: &mut GlobalEnv) -> Result<()> {
     )?;
 
     let methods = cache.methods();
-    eprintln!("Loaded {} methods from cache", methods.len());
 
     for method_info in methods {
-        let receiver_type = Type::Instance {
-            class_name: method_info.receiver_class.clone(),
-        };
-        genv.register_builtin_method(
+        let receiver_type = Type::instance(&method_info.receiver_class);
+
+        // Convert block param type strings to Type enums
+        let block_param_types = method_info.block_param_types.as_ref().map(|types| {
+            types
+                .iter()
+                .map(|s| RbsTypeConverter::parse(s))
+                .collect()
+        });
+
+        genv.register_builtin_method_with_block(
             receiver_type,
             &method_info.method_name,
             method_info.return_type(),
+            block_param_types,
         );
     }
 

data/rust/src/env/global_env.rs

@@ -115,6 +115,11 @@ impl GlobalEnv {
                 }
             }
         }
+
+        // Reschedule boxes that need to run again
+        for box_id in changes.take_reschedule_boxes() {
+            self.box_manager.add_run(box_id);
+        }
     }
 
     /// Execute all Boxes
@@ -145,6 +150,30 @@ impl GlobalEnv {
         self.method_registry.register(recv_ty, method_name, ret_ty);
     }
 
+    /// Register built-in method with block parameter types
+    pub fn register_builtin_method_with_block(
+        &mut self,
+        recv_ty: Type,
+        method_name: &str,
+        ret_ty: Type,
+        block_param_types: Option<Vec<Type>>,
+    ) {
+        self.method_registry
+            .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)
@@ -170,12 +199,23 @@ impl GlobalEnv {
         scope_id
     }
 
+    /// Enter a module scope
+    pub fn enter_module(&mut self, name: String) -> ScopeId {
+        let scope_id = self.scope_manager.new_scope(ScopeKind::Module { name });
+        self.scope_manager.enter_scope(scope_id);
+        scope_id
+    }
+
     /// Enter a method scope
     pub fn enter_method(&mut self, name: String) -> ScopeId {
-        let class_name = self.scope_manager.current_class_name();
+        // Look for class or module context
+        let receiver_type = self
+            .scope_manager
+            .current_class_name()
+            .or_else(|| self.scope_manager.current_module_name());
         let scope_id = self.scope_manager.new_scope(ScopeKind::Method {
             name,
-            receiver_type: class_name,
+            receiver_type,
         });
         self.scope_manager.enter_scope(scope_id);
         scope_id

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;
 
@@ -7,6 +8,9 @@ use std::collections::HashMap;
 #[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>>,
 }
 
 /// Registry for method definitions
@@ -25,18 +29,67 @@ impl MethodRegistry {
 
     /// 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,
+            },
+        );
+    }
+
+    /// 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),
             },
         );
     }
 
     /// Resolve a method for a receiver type
+    ///
+    /// For generic types like `Array[Integer]`, first tries exact match,
+    /// then falls back to base class match (`Array`).
     pub fn resolve(&self, recv_ty: &Type, method_name: &str) -> Option<&MethodInfo> {
-        self.methods
+        // First, try exact match
+        if let Some(info) = self
+            .methods
             .get(&(recv_ty.clone(), method_name.to_string()))
+        {
+            return Some(info);
+        }
+
+        // For generic types, fall back to base class
+        if let Type::Generic { name, .. } = recv_ty {
+            let base_type = Type::Instance { name: name.clone() };
+            return self.methods.get(&(base_type, method_name.to_string()));
+        }
+
+        None
     }
 }
 
@@ -50,9 +103,7 @@ mod tests {
         registry.register(Type::string(), "length", Type::integer());
 
         let info = registry.resolve(&Type::string(), "length").unwrap();
-        assert!(
-            matches!(info.return_type, Type::Instance { ref class_name, .. } if class_name == "Integer")
-        );
+        assert_eq!(info.return_type.base_class_name(), Some("Integer"));
     }
 
     #[test]
@@ -60,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/env/mod.rs

@@ -13,3 +13,4 @@ pub mod vertex_manager;
 
 pub use global_env::GlobalEnv;
 pub use local_env::LocalEnv;
+pub use scope::ScopeKind;